174 files changed, 4731 insertions, 2326 deletions
diff --git a/include/linux/a.out.h b/include/linux/a.out.h
index af8a1dfa5c32..f913cc3e1b0d 100644
--- a/include/linux/a.out.h
+++ b/include/linux/a.out.h
@@ -138,7 +138,7 @@ enum machine_type {
 #endif
 #endif
-#define _N_SEGMENT_ROUND(x) (((x) + SEGMENT_SIZE - 1) & ~(SEGMENT_SIZE - 1))
+#define _N_SEGMENT_ROUND(x) ALIGN(x, SEGMENT_SIZE)
 #define _N_TXTENDADDR(x) (N_TXTADDR(x)+(x).a_text)
diff --git a/include/linux/acpi.h b/include/linux/acpi.h
index b123cc08773d..b46a5205ee7b 100644
--- a/include/linux/acpi.h
+++ b/include/linux/acpi.h
@@ -206,7 +206,10 @@ struct acpi_table_plat_int_src {
        u8                      eid;
        u8                      iosapic_vector;
        u32                     global_irq;
-        u32                     reserved;
+        struct {
+                u32                     cpei_override_flag:1;
+                u32                     reserved:31;
+        }                       plint_flags;
 } __attribute__ ((packed));
 enum acpi_interrupt_id {
@@ -342,11 +345,19 @@ struct acpi_table_ecdt {
 /* PCI MMCONFIG */
+/* Defined in PCI Firmware Specification 3.0 */
+struct acpi_table_mcfg_config {
+        u32                             base_address;
+        u32                             base_reserved;
+        u16                             pci_segment_group_number;
+        u8                              start_bus_number;
+        u8                              end_bus_number;
+        u8                              reserved[4];
+} __attribute__ ((packed));
 struct acpi_table_mcfg {
        struct acpi_table_header        header;
        u8                              reserved[8];
-        u32                             base_address;
+        struct acpi_table_mcfg_config   config[0];
-        u32                             base_reserved;
 } __attribute__ ((packed));
 /* Table Handlers */
@@ -391,6 +402,7 @@ int acpi_table_parse (enum acpi_table_id id, acpi_table_handler handler);
 int acpi_get_table_header_early (enum acpi_table_id id, struct acpi_table_header **header);
 int acpi_table_parse_madt (enum acpi_madt_entry_id id, acpi_madt_entry_handler handler, unsigned int max_entries);
 int acpi_table_parse_srat (enum acpi_srat_entry_id id, acpi_madt_entry_handler handler, unsigned int max_entries);
+int acpi_parse_mcfg (unsigned long phys_addr, unsigned long size);
 void acpi_table_print (struct acpi_table_header *header, unsigned long phys_addr);
 void acpi_table_print_madt_entry (acpi_table_entry_header *madt);
 void acpi_table_print_srat_entry (acpi_table_entry_header *srat);
@@ -407,9 +419,13 @@ int acpi_map_lsapic(acpi_handle handle, int *pcpu);
 int acpi_unmap_lsapic(int cpu);
 #endif /* CONFIG_ACPI_HOTPLUG_CPU */
+int acpi_register_ioapic(acpi_handle handle, u64 phys_addr, u32 gsi_base);
+int acpi_unregister_ioapic(acpi_handle handle, u32 gsi_base);
 extern int acpi_mp_config;
-extern u32 pci_mmcfg_base_addr;
+extern struct acpi_table_mcfg_config *pci_mmcfg_config;
+extern int pci_mmcfg_config_num;
 extern int sbf_port ;
@@ -437,9 +453,7 @@ int acpi_gsi_to_irq (u32 gsi, unsigned int *irq);
 * If this matches the last registration, any IRQ resources for gsi
 * are freed.
 */
-#ifdef CONFIG_ACPI_DEALLOCATE_IRQ
 void acpi_unregister_gsi (u32 gsi);
-#endif
 #ifdef CONFIG_ACPI_PCI
@@ -462,11 +476,9 @@ struct acpi_prt_list {
 struct pci_dev;
 int acpi_pci_irq_enable (struct pci_dev *dev);
-void acpi_penalize_isa_irq(int irq);
+void acpi_penalize_isa_irq(int irq, int active);
-#ifdef CONFIG_ACPI_DEALLOCATE_IRQ
 void acpi_pci_irq_disable (struct pci_dev *dev);
-#endif
 struct acpi_pci_driver {
        struct acpi_pci_driver *next;
diff --git a/include/linux/atalk.h b/include/linux/atalk.h
index 09a1451c1159..911c09cb9bf9 100644
--- a/include/linux/atalk.h
+++ b/include/linux/atalk.h
@@ -1,6 +1,8 @@
 #ifndef __LINUX_ATALK_H__
 #define __LINUX_ATALK_H__
+#include <asm/byteorder.h>
 /*
 * AppleTalk networking structures
 *
diff --git a/include/linux/audit.h b/include/linux/audit.h
index bf2ad3ba72eb..68aba0c02e49 100644
--- a/include/linux/audit.h
+++ b/include/linux/audit.h
@@ -165,7 +165,7 @@
 #define AUDIT_ARCH_SH64         (EM_SH|__AUDIT_ARCH_64BIT)
 #define AUDIT_ARCH_SHEL64       (EM_SH|__AUDIT_ARCH_64BIT|__AUDIT_ARCH_LE)
 #define AUDIT_ARCH_SPARC        (EM_SPARC)
-#define AUDIT_ARCH_SPARC64      (EM_SPARC64|__AUDIT_ARCH_64BIT)
+#define AUDIT_ARCH_SPARC64      (EM_SPARCV9|__AUDIT_ARCH_64BIT)
 #define AUDIT_ARCH_V850         (EM_V850|__AUDIT_ARCH_LE)
 #define AUDIT_ARCH_X86_64       (EM_X86_64|__AUDIT_ARCH_64BIT|__AUDIT_ARCH_LE)
diff --git a/include/linux/binfmts.h b/include/linux/binfmts.h
index 7e736e201c46..c1e82c514443 100644
--- a/include/linux/binfmts.h
+++ b/include/linux/binfmts.h
@@ -69,6 +69,11 @@ extern void remove_arg_zero(struct linux_binprm *);
 extern int search_binary_handler(struct linux_binprm *,struct pt_regs *);
 extern int flush_old_exec(struct linux_binprm * bprm);
+extern int suid_dumpable;
+#define SUID_DUMP_DISABLE       0       /* No setuid dumping */
+#define SUID_DUMP_USER          1       /* Dump as user of process */
+#define SUID_DUMP_ROOT          2       /* Dump as root */
 /* Stack area protections */
 #define EXSTACK_DEFAULT   0     /* Whatever the arch defaults to */
 #define EXSTACK_DISABLE_X 1     /* Disable executable stacks */
diff --git a/include/linux/bio.h b/include/linux/bio.h
index 038022763f09..36ef29fa0d8b 100644
--- a/include/linux/bio.h
+++ b/include/linux/bio.h
@@ -22,6 +22,7 @@
 #include <linux/highmem.h>
 #include <linux/mempool.h>
+#include <linux/ioprio.h>
 /* Platforms may set this to teach the BIO layer about IOMMU hardware. */
 #include <asm/io.h>
@@ -150,6 +151,19 @@ struct bio {
 #define BIO_RW_SYNC     4
 /*
+ * upper 16 bits of bi_rw define the io priority of this bio
+ */
+#define BIO_PRIO_SHIFT  (8 * sizeof(unsigned long) - IOPRIO_BITS)
+#define bio_prio(bio)   ((bio)->bi_rw >> BIO_PRIO_SHIFT)
+#define bio_prio_valid(bio)     ioprio_valid(bio_prio(bio))
+#define bio_set_prio(bio, prio)         do {                    \
+        WARN_ON(prio >= (1 << IOPRIO_BITS));                    \
+        (bio)->bi_rw &= ((1UL << BIO_PRIO_SHIFT) - 1);          \
+        (bio)->bi_rw |= ((unsigned long) (prio) << BIO_PRIO_SHIFT);     \
+} while (0)
+/*
 * various member access, note that bio_data should of course not be used
 * on highmem page vectors
 */
diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
index 4a99b76c5a33..19bd8e7e11bf 100644
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
@@ -54,16 +54,23 @@ struct as_io_context {
 struct cfq_queue;
 struct cfq_io_context {
-        void (*dtor)(struct cfq_io_context *);
-        void (*exit)(struct cfq_io_context *);
-        struct io_context *ioc;
        /*
         * circular list of cfq_io_contexts belonging to a process io context
         */
        struct list_head list;
        struct cfq_queue *cfqq;
+        void *key;
+        struct io_context *ioc;
+        unsigned long last_end_request;
+        unsigned long last_queue;
+        unsigned long ttime_total;
+        unsigned long ttime_samples;
+        unsigned long ttime_mean;
+        void (*dtor)(struct cfq_io_context *);
+        void (*exit)(struct cfq_io_context *);
 };
 /*
@@ -73,7 +80,9 @@ struct cfq_io_context {
 */
 struct io_context {
        atomic_t refcount;
-        pid_t pid;
+        struct task_struct *task;
+        int (*set_ioprio)(struct io_context *, unsigned int);
        /*
         * For request batching
@@ -81,14 +90,13 @@ struct io_context {
        unsigned long last_waited; /* Time last woken after wait for request */
        int nr_batch_requests;     /* Number of requests left in the batch */
-        spinlock_t lock;
        struct as_io_context *aic;
        struct cfq_io_context *cic;
 };
 void put_io_context(struct io_context *ioc);
 void exit_io_context(void);
+struct io_context *current_io_context(int gfp_flags);
 struct io_context *get_io_context(int gfp_flags);
 void copy_io_context(struct io_context **pdst, struct io_context **psrc);
 void swap_io_context(struct io_context **ioc1, struct io_context **ioc2);
@@ -134,6 +142,8 @@ struct request {
        void *elevator_private;
+        unsigned short ioprio;
        int rq_status;  /* should split this into a few status bits */
        struct gendisk *rq_disk;
        int errors;
@@ -285,9 +295,6 @@ enum blk_queue_state {
        Queue_up,
 };
-#define BLK_TAGS_PER_LONG       (sizeof(unsigned long) * 8)
-#define BLK_TAGS_MASK           (BLK_TAGS_PER_LONG - 1)
 struct blk_queue_tag {
        struct request **tag_index;     /* map of busy tags */
        unsigned long *tag_map;         /* bit map of free/busy tags */
@@ -396,6 +403,7 @@ struct request_queue
         */
        unsigned int            sg_timeout;
        unsigned int            sg_reserved_size;
+        int                     node;
        struct list_head        drain_list;
@@ -542,15 +550,12 @@ extern void generic_make_request(struct bio *bio);
 extern void blk_put_request(struct request *);
 extern void blk_end_sync_rq(struct request *rq);
 extern void blk_attempt_remerge(request_queue_t *, struct request *);
-extern void __blk_attempt_remerge(request_queue_t *, struct request *);
 extern struct request *blk_get_request(request_queue_t *, int, int);
 extern void blk_insert_request(request_queue_t *, struct request *, int, void *);
 extern void blk_requeue_request(request_queue_t *, struct request *);
 extern void blk_plug_device(request_queue_t *);
 extern int blk_remove_plug(request_queue_t *);
 extern void blk_recount_segments(request_queue_t *, struct bio *);
-extern int blk_phys_contig_segment(request_queue_t *q, struct bio *, struct bio *);
-extern int blk_hw_contig_segment(request_queue_t *q, struct bio *, struct bio *);
 extern int scsi_cmd_ioctl(struct file *, struct gendisk *, unsigned int, void __user *);
 extern void blk_start_queue(request_queue_t *q);
 extern void blk_stop_queue(request_queue_t *q);
@@ -615,6 +620,8 @@ static inline void blkdev_dequeue_request(struct request *req)
 /*
 * Access functions for manipulating queue properties
 */
+extern request_queue_t *blk_init_queue_node(request_fn_proc *rfn,
+                                        spinlock_t *lock, int node_id);
 extern request_queue_t *blk_init_queue(request_fn_proc *, spinlock_t *);
 extern void blk_cleanup_queue(request_queue_t *);
 extern void blk_queue_make_request(request_queue_t *, make_request_fn *);
@@ -632,7 +639,6 @@ extern void blk_queue_dma_alignment(request_queue_t *, int);
 extern struct backing_dev_info *blk_get_backing_dev_info(struct block_device *bdev);
 extern void blk_queue_ordered(request_queue_t *, int);
 extern void blk_queue_issue_flush_fn(request_queue_t *, issue_flush_fn *);
-extern int blkdev_scsi_issue_flush_fn(request_queue_t *, struct gendisk *, sector_t *);
 extern struct request *blk_start_pre_flush(request_queue_t *,struct request *);
 extern int blk_complete_barrier_rq(request_queue_t *, struct request *, int);
 extern int blk_complete_barrier_rq_locked(request_queue_t *, struct request *, int);
@@ -646,7 +652,8 @@ extern void blk_wait_queue_drained(request_queue_t *, int);
 extern void blk_finish_queue_drain(request_queue_t *);
 int blk_get_queue(request_queue_t *);
-request_queue_t *blk_alloc_queue(int);
+request_queue_t *blk_alloc_queue(int gfp_mask);
+request_queue_t *blk_alloc_queue_node(int,int);
 #define blk_put_queue(q) blk_cleanup_queue((q))
 /*
@@ -675,8 +682,6 @@ extern int blkdev_issue_flush(struct block_device *, sector_t *);
 #define blkdev_entry_to_request(entry) list_entry((entry), struct request, queuelist)
-extern void drive_stat_acct(struct request *, int, int);
 static inline int queue_hardsect_size(request_queue_t *q)
 {
        int retval = 512;
diff --git a/include/linux/bootmem.h b/include/linux/bootmem.h
index 0dd8ca1a3d5a..82bd8842d11c 100644
--- a/include/linux/bootmem.h
+++ b/include/linux/bootmem.h
@@ -22,6 +22,10 @@ extern unsigned long min_low_pfn;
 */
 extern unsigned long max_pfn;
+#ifdef CONFIG_CRASH_DUMP
+extern unsigned long saved_max_pfn;
+#endif
 /*
 * node_bootmem_map is a map pointer - the bits represent all physical 
 * memory pages (including holes) on the node.
@@ -67,6 +71,15 @@ extern void * __init __alloc_bootmem_node (pg_data_t *pgdat, unsigned long size,
        __alloc_bootmem_node((pgdat), (x), PAGE_SIZE, 0)
 #endif /* !CONFIG_HAVE_ARCH_BOOTMEM_NODE */
+#ifdef CONFIG_HAVE_ARCH_ALLOC_REMAP
+extern void *alloc_remap(int nid, unsigned long size);
+#else
+static inline void *alloc_remap(int nid, unsigned long size)
+{
+        return NULL;
+}
+#endif
 extern unsigned long __initdata nr_kernel_pages;
 extern unsigned long __initdata nr_all_pages;
diff --git a/include/linux/buffer_head.h b/include/linux/buffer_head.h
index 802c91e9b3da..90828493791f 100644
--- a/include/linux/buffer_head.h
+++ b/include/linux/buffer_head.h
@@ -19,6 +19,9 @@ enum bh_state_bits {
        BH_Dirty,       /* Is dirty */
        BH_Lock,        /* Is locked */
        BH_Req,         /* Has been submitted for I/O */
+        BH_Uptodate_Lock,/* Used by the first bh in a page, to serialise
+                          * IO completion of other buffers in the page
+                          */
        BH_Mapped,      /* Has a disk mapping */
        BH_New,         /* Disk mapping was newly created by get_block */
diff --git a/include/linux/byteorder/swabb.h b/include/linux/byteorder/swabb.h
index d28d9a804d3b..d5f2a3205109 100644
--- a/include/linux/byteorder/swabb.h
+++ b/include/linux/byteorder/swabb.h
@@ -92,29 +92,32 @@
 #endif /* OPTIMIZE */
-static __inline__ __const__ __u32 __fswahw32(__u32 x)
+static inline __u32 __fswahw32(__u32 x)
 {
        return __arch__swahw32(x);
 }
-static __inline__ __u32 __swahw32p(__u32 *x)
+static inline __u32 __swahw32p(__u32 *x)
 {
        return __arch__swahw32p(x);
 }
-static __inline__ void __swahw32s(__u32 *addr)
+static inline void __swahw32s(__u32 *addr)
 {
        __arch__swahw32s(addr);
 }
+static inline __u32 __fswahb32(__u32 x)
-static __inline__ __const__ __u32 __fswahb32(__u32 x)
 {
        return __arch__swahb32(x);
 }
-static __inline__ __u32 __swahb32p(__u32 *x)
+static inline __u32 __swahb32p(__u32 *x)
 {
        return __arch__swahb32p(x);
 }
-static __inline__ void __swahb32s(__u32 *addr)
+static inline void __swahb32s(__u32 *addr)
 {
        __arch__swahb32s(addr);
 }
diff --git a/include/linux/cache.h b/include/linux/cache.h
index 4d767b93738a..f6b5a46c5f82 100644
--- a/include/linux/cache.h
+++ b/include/linux/cache.h
@@ -13,6 +13,12 @@
 #define SMP_CACHE_BYTES L1_CACHE_BYTES
 #endif
+#if defined(CONFIG_X86) || defined(CONFIG_SPARC64)
+#define __read_mostly __attribute__((__section__(".data.read_mostly")))
+#else
+#define __read_mostly
+#endif
 #ifndef ____cacheline_aligned
 #define ____cacheline_aligned __attribute__((__aligned__(SMP_CACHE_BYTES)))
 #endif
diff --git a/include/linux/cciss_ioctl.h b/include/linux/cciss_ioctl.h
index ee0c6e8995da..424d5e622b43 100644
--- a/include/linux/cciss_ioctl.h
+++ b/include/linux/cciss_ioctl.h
@@ -10,6 +10,7 @@
 typedef struct _cciss_pci_info_struct
 {
        unsigned char   bus;
+        unsigned short  domain;
        unsigned char   dev_fn;
        __u32           board_id;
 } cciss_pci_info_struct; 
diff --git a/include/linux/compat_ioctl.h b/include/linux/compat_ioctl.h
index 70a4ebb5d964..ecb0d39c0798 100644
--- a/include/linux/compat_ioctl.h
+++ b/include/linux/compat_ioctl.h
@@ -346,10 +346,27 @@ COMPATIBLE_IOCTL(PPPOEIOCDFWD)
 /* LP */
 COMPATIBLE_IOCTL(LPGETSTATUS)
 /* ppdev */
+COMPATIBLE_IOCTL(PPSETMODE)
+COMPATIBLE_IOCTL(PPRSTATUS)
+COMPATIBLE_IOCTL(PPRCONTROL)
+COMPATIBLE_IOCTL(PPWCONTROL)
+COMPATIBLE_IOCTL(PPFCONTROL)
+COMPATIBLE_IOCTL(PPRDATA)
+COMPATIBLE_IOCTL(PPWDATA)
 COMPATIBLE_IOCTL(PPCLAIM)
 COMPATIBLE_IOCTL(PPRELEASE)
-COMPATIBLE_IOCTL(PPEXCL)
 COMPATIBLE_IOCTL(PPYIELD)
+COMPATIBLE_IOCTL(PPEXCL)
+COMPATIBLE_IOCTL(PPDATADIR)
+COMPATIBLE_IOCTL(PPNEGOT)
+COMPATIBLE_IOCTL(PPWCTLONIRQ)
+COMPATIBLE_IOCTL(PPCLRIRQ)
+COMPATIBLE_IOCTL(PPSETPHASE)
+COMPATIBLE_IOCTL(PPGETMODES)
+COMPATIBLE_IOCTL(PPGETMODE)
+COMPATIBLE_IOCTL(PPGETPHASE)
+COMPATIBLE_IOCTL(PPGETFLAGS)
+COMPATIBLE_IOCTL(PPSETFLAGS)
 /* CDROM stuff */
 COMPATIBLE_IOCTL(CDROMPAUSE)
 COMPATIBLE_IOCTL(CDROMRESUME)
diff --git a/include/linux/cpu.h b/include/linux/cpu.h
index fe0298e5dae1..e8904c0da686 100644
--- a/include/linux/cpu.h
+++ b/include/linux/cpu.h
@@ -69,6 +69,7 @@ extern struct semaphore cpucontrol;
        register_cpu_notifier(&fn##_nb);                        \
 }
 int cpu_down(unsigned int cpu);
+extern int __attribute__((weak)) smp_prepare_cpu(int cpu);
 #define cpu_is_offline(cpu) unlikely(!cpu_online(cpu))
 #else
 #define lock_cpu_hotplug()      do { } while (0)
diff --git a/include/linux/cpufreq.h b/include/linux/cpufreq.h
index 927daa86c9b3..ff7f80f48df1 100644
--- a/include/linux/cpufreq.h
+++ b/include/linux/cpufreq.h
@@ -201,7 +201,7 @@ struct cpufreq_driver {
        /* optional */
        int     (*exit)         (struct cpufreq_policy *policy);
-        int     (*suspend)      (struct cpufreq_policy *policy, u32 state);
+        int     (*suspend)      (struct cpufreq_policy *policy, pm_message_t pmsg);
        int     (*resume)       (struct cpufreq_policy *policy);
        struct freq_attr        **attr;
 };
diff --git a/include/linux/crash_dump.h b/include/linux/crash_dump.h
new file mode 100644
index 000000000000..534d750d922d
--- /dev/null
+++ b/include/linux/crash_dump.h
@@ -0,0 +1,18 @@
+#ifndef LINUX_CRASH_DUMP_H
+#define LINUX_CRASH_DUMP_H
+#ifdef CONFIG_CRASH_DUMP
+#include <linux/kexec.h>
+#include <linux/smp_lock.h>
+#include <linux/device.h>
+#include <linux/proc_fs.h>
+#define ELFCORE_ADDR_MAX        (-1ULL)
+extern unsigned long long elfcorehdr_addr;
+extern ssize_t copy_oldmem_page(unsigned long, char *, size_t,
+                                                unsigned long, int);
+extern struct file_operations proc_vmcore_operations;
+extern struct proc_dir_entry *proc_vmcore;
+#endif /* CONFIG_CRASH_DUMP */
+#endif /* LINUX_CRASHDUMP_H */
diff --git a/include/linux/crypto.h b/include/linux/crypto.h
index 387da6a3e58c..5e2bcc636a02 100644
--- a/include/linux/crypto.h
+++ b/include/linux/crypto.h
@@ -61,6 +61,15 @@
 #define CRYPTO_DIR_DECRYPT              0
 struct scatterlist;
+struct crypto_tfm;
+struct cipher_desc {
+        struct crypto_tfm *tfm;
+        void (*crfn)(void *ctx, u8 *dst, const u8 *src);
+        unsigned int (*prfn)(const struct cipher_desc *desc, u8 *dst,
+                             const u8 *src, unsigned int nbytes);
+        void *info;
+};
 /*
 * Algorithms: modular crypto algorithm implementations, managed
@@ -73,6 +82,19 @@ struct cipher_alg {
                          unsigned int keylen, u32 *flags);
        void (*cia_encrypt)(void *ctx, u8 *dst, const u8 *src);
        void (*cia_decrypt)(void *ctx, u8 *dst, const u8 *src);
+        unsigned int (*cia_encrypt_ecb)(const struct cipher_desc *desc,
+                                        u8 *dst, const u8 *src,
+                                        unsigned int nbytes);
+        unsigned int (*cia_decrypt_ecb)(const struct cipher_desc *desc,
+                                        u8 *dst, const u8 *src,
+                                        unsigned int nbytes);
+        unsigned int (*cia_encrypt_cbc)(const struct cipher_desc *desc,
+                                        u8 *dst, const u8 *src,
+                                        unsigned int nbytes);
+        unsigned int (*cia_decrypt_cbc)(const struct cipher_desc *desc,
+                                        u8 *dst, const u8 *src,
+                                        unsigned int nbytes);
 };
 struct digest_alg {
@@ -102,6 +124,7 @@ struct crypto_alg {
        u32 cra_flags;
        unsigned int cra_blocksize;
        unsigned int cra_ctxsize;
+        unsigned int cra_alignmask;
        const char cra_name[CRYPTO_MAX_ALG_NAME];
        union {
@@ -136,7 +159,6 @@ static inline int crypto_alg_available(const char *name, u32 flags)
 * and core processing logic.  Managed via crypto_alloc_tfm() and
 * crypto_free_tfm(), as well as the various helpers below.
 */
-struct crypto_tfm;
 struct cipher_tfm {
        void *cit_iv;
@@ -266,6 +288,16 @@ static inline unsigned int crypto_tfm_alg_digestsize(struct crypto_tfm *tfm)
        return tfm->__crt_alg->cra_digest.dia_digestsize;
 }
+static inline unsigned int crypto_tfm_alg_alignmask(struct crypto_tfm *tfm)
+{
+        return tfm->__crt_alg->cra_alignmask;
+}
+static inline void *crypto_tfm_ctx(struct crypto_tfm *tfm)
+{
+        return (void *)&tfm[1];
+}
 /*
 * API wrappers.
 */
diff --git a/include/linux/dcookies.h b/include/linux/dcookies.h
index c28050136164..1d68428c925d 100644
--- a/include/linux/dcookies.h
+++ b/include/linux/dcookies.h
@@ -48,12 +48,12 @@ int get_dcookie(struct dentry * dentry, struct vfsmount * vfsmnt,
 #else
-struct dcookie_user * dcookie_register(void)
+static inline struct dcookie_user * dcookie_register(void)
 {
        return NULL;
 }
-void dcookie_unregister(struct dcookie_user * user)
+static inline void dcookie_unregister(struct dcookie_user * user)
 {
        return;
 }
diff --git a/include/linux/device.h b/include/linux/device.h
index 7b781a72b293..06e5d42f2c7b 100644
--- a/include/linux/device.h
+++ b/include/linux/device.h
@@ -69,7 +69,7 @@ struct bus_type {
 extern int bus_register(struct bus_type * bus);
 extern void bus_unregister(struct bus_type * bus);
-extern int bus_rescan_devices(struct bus_type * bus);
+extern void bus_rescan_devices(struct bus_type * bus);
 extern struct bus_type * get_bus(struct bus_type * bus);
 extern void put_bus(struct bus_type * bus);
@@ -80,6 +80,8 @@ extern struct bus_type * find_bus(char * name);
 int bus_for_each_dev(struct bus_type * bus, struct device * start, void * data,
                     int (*fn)(struct device *, void *));
+struct device * bus_find_device(struct bus_type *bus, struct device *start,
+                                void *data, int (*match)(struct device *, void *));
 int bus_for_each_drv(struct bus_type * bus, struct device_driver * start, 
                     void * data, int (*fn)(struct device_driver *, void *));
@@ -142,6 +144,9 @@ extern void driver_remove_file(struct device_driver *, struct driver_attribute *
 extern int driver_for_each_device(struct device_driver * drv, struct device * start,
                                  void * data, int (*fn)(struct device *, void *));
+struct device * driver_find_device(struct device_driver *drv,
+                                   struct device *start, void *data,
+                                   int (*match)(struct device *, void *));
 /*
@@ -279,8 +284,10 @@ struct device {
        struct device_driver *driver;   /* which driver has allocated this
                                           device */
        void            *driver_data;   /* data private to the driver */
-        void            *platform_data; /* Platform specific data (e.g. ACPI,
+        void            *platform_data; /* Platform specific data, device
-                                           BIOS data relevant to device) */
+                                           core doesn't touch it */
+        void            *firmware_data; /* Firmware specific data (e.g. ACPI,
+                                           BIOS data),reserved for device core*/
        struct dev_pm_info      power;
        u64             *dma_mask;      /* dma mask (if dma'able device) */
diff --git a/include/linux/dmi.h b/include/linux/dmi.h
index d2bcf556088b..5e93e6dce9a4 100644
--- a/include/linux/dmi.h
+++ b/include/linux/dmi.h
@@ -9,6 +9,7 @@ enum dmi_field {
        DMI_SYS_VENDOR,
        DMI_PRODUCT_NAME,
        DMI_PRODUCT_VERSION,
+        DMI_PRODUCT_SERIAL,
        DMI_BOARD_VENDOR,
        DMI_BOARD_NAME,
        DMI_BOARD_VERSION,
diff --git a/include/linux/dqblk_v1.h b/include/linux/dqblk_v1.h
index 42fbf4797156..57f1250d5a52 100644
--- a/include/linux/dqblk_v1.h
+++ b/include/linux/dqblk_v1.h
@@ -11,6 +11,12 @@
 /* Root squash turned on */
 #define V1_DQF_RSQUASH 1
+/* Numbers of blocks needed for updates */
+#define V1_INIT_ALLOC 1
+#define V1_INIT_REWRITE 1
+#define V1_DEL_ALLOC 0
+#define V1_DEL_REWRITE 2
 /* Special information about quotafile */
 struct v1_mem_dqinfo {
 };
diff --git a/include/linux/dqblk_v2.h b/include/linux/dqblk_v2.h
index 4a6c5f6867bb..4f853322cb7f 100644
--- a/include/linux/dqblk_v2.h
+++ b/include/linux/dqblk_v2.h
@@ -10,6 +10,12 @@
 /* id numbers of quota format */
 #define QFMT_VFS_V0 2
+/* Numbers of blocks needed for updates */
+#define V2_INIT_ALLOC 4
+#define V2_INIT_REWRITE 2
+#define V2_DEL_ALLOC 0
+#define V2_DEL_REWRITE 6
 /* Inmemory copy of version specific information */
 struct v2_mem_dqinfo {
        unsigned int dqi_blocks;
diff --git a/include/linux/efi.h b/include/linux/efi.h
index 047e7222df7a..73781ec165b4 100644
--- a/include/linux/efi.h
+++ b/include/linux/efi.h
@@ -315,7 +315,7 @@ extern struct efi_memory_map memmap;
 */
 static inline int efi_range_is_wc(unsigned long start, unsigned long len)
 {
-        int i;
+        unsigned long i;
        for (i = 0; i < len; i += (1UL << EFI_PAGE_SHIFT)) {
                unsigned long paddr = __pa(start + i);
diff --git a/include/linux/elevator.h b/include/linux/elevator.h
index ee54f81faad5..ea6bbc2d7407 100644
--- a/include/linux/elevator.h
+++ b/include/linux/elevator.h
@@ -16,9 +16,9 @@ typedef void (elevator_remove_req_fn) (request_queue_t *, struct request *);
 typedef void (elevator_requeue_req_fn) (request_queue_t *, struct request *);
 typedef struct request *(elevator_request_list_fn) (request_queue_t *, struct request *);
 typedef void (elevator_completed_req_fn) (request_queue_t *, struct request *);
-typedef int (elevator_may_queue_fn) (request_queue_t *, int);
+typedef int (elevator_may_queue_fn) (request_queue_t *, int, struct bio *);
-typedef int (elevator_set_req_fn) (request_queue_t *, struct request *, int);
+typedef int (elevator_set_req_fn) (request_queue_t *, struct request *, struct bio *, int);
 typedef void (elevator_put_req_fn) (request_queue_t *, struct request *);
 typedef void (elevator_deactivate_req_fn) (request_queue_t *, struct request *);
@@ -96,9 +96,9 @@ extern struct request *elv_former_request(request_queue_t *, struct request *);
 extern struct request *elv_latter_request(request_queue_t *, struct request *);
 extern int elv_register_queue(request_queue_t *q);
 extern void elv_unregister_queue(request_queue_t *q);
-extern int elv_may_queue(request_queue_t *, int);
+extern int elv_may_queue(request_queue_t *, int, struct bio *);
 extern void elv_completed_request(request_queue_t *, struct request *);
-extern int elv_set_request(request_queue_t *, struct request *, int);
+extern int elv_set_request(request_queue_t *, struct request *, struct bio *, int);
 extern void elv_put_request(request_queue_t *, struct request *);
 /*
diff --git a/include/linux/etherdevice.h b/include/linux/etherdevice.h
index a1478258d002..ce8518e658b6 100644
--- a/include/linux/etherdevice.h
+++ b/include/linux/etherdevice.h
@@ -25,6 +25,7 @@
 #define _LINUX_ETHERDEVICE_H
 #include <linux/if_ether.h>
+#include <linux/netdevice.h>
 #include <linux/random.h>
 #ifdef __KERNEL__
@@ -32,7 +33,7 @@ extern int		eth_header(struct sk_buff *skb, struct net_device *dev,
                                   unsigned short type, void *daddr,
                                   void *saddr, unsigned len);
 extern int              eth_rebuild_header(struct sk_buff *skb);
-extern unsigned short   eth_type_trans(struct sk_buff *skb, struct net_device *dev);
+extern __be16           eth_type_trans(struct sk_buff *skb, struct net_device *dev);
 extern void             eth_header_cache_update(struct hh_cache *hh, struct net_device *dev,
                                                unsigned char * haddr);
 extern int              eth_header_cache(struct neighbour *neigh,
@@ -65,7 +66,7 @@ static inline int is_zero_ether_addr(const u8 *addr)
 */
 static inline int is_multicast_ether_addr(const u8 *addr)
 {
-        return addr[0] & 0x01;
+        return ((addr[0] != 0xff) && (0x01 & addr[0]));
 }
 /**
diff --git a/include/linux/ext2_fs.h b/include/linux/ext2_fs.h
index fab43527e597..a657130ba03a 100644
--- a/include/linux/ext2_fs.h
+++ b/include/linux/ext2_fs.h
@@ -300,18 +300,19 @@ struct ext2_inode {
 /*
 * Mount flags
 */
-#define EXT2_MOUNT_CHECK                0x0001  /* Do mount-time checks */
+#define EXT2_MOUNT_CHECK                0x000001  /* Do mount-time checks */
-#define EXT2_MOUNT_OLDALLOC             0x0002  /* Don't use the new Orlov allocator */
+#define EXT2_MOUNT_OLDALLOC             0x000002  /* Don't use the new Orlov allocator */
-#define EXT2_MOUNT_GRPID                0x0004  /* Create files with directory's group */
+#define EXT2_MOUNT_GRPID                0x000004  /* Create files with directory's group */
-#define EXT2_MOUNT_DEBUG                0x0008  /* Some debugging messages */
+#define EXT2_MOUNT_DEBUG                0x000008  /* Some debugging messages */
-#define EXT2_MOUNT_ERRORS_CONT          0x0010  /* Continue on errors */
+#define EXT2_MOUNT_ERRORS_CONT          0x000010  /* Continue on errors */
-#define EXT2_MOUNT_ERRORS_RO            0x0020  /* Remount fs ro on errors */
+#define EXT2_MOUNT_ERRORS_RO            0x000020  /* Remount fs ro on errors */
-#define EXT2_MOUNT_ERRORS_PANIC         0x0040  /* Panic on errors */
+#define EXT2_MOUNT_ERRORS_PANIC         0x000040  /* Panic on errors */
-#define EXT2_MOUNT_MINIX_DF             0x0080  /* Mimics the Minix statfs */
+#define EXT2_MOUNT_MINIX_DF             0x000080  /* Mimics the Minix statfs */
-#define EXT2_MOUNT_NOBH                 0x0100  /* No buffer_heads */
+#define EXT2_MOUNT_NOBH                 0x000100  /* No buffer_heads */
-#define EXT2_MOUNT_NO_UID32             0x0200  /* Disable 32-bit UIDs */
+#define EXT2_MOUNT_NO_UID32             0x000200  /* Disable 32-bit UIDs */
-#define EXT2_MOUNT_XATTR_USER           0x4000  /* Extended user attributes */
+#define EXT2_MOUNT_XATTR_USER           0x004000  /* Extended user attributes */
-#define EXT2_MOUNT_POSIX_ACL            0x8000  /* POSIX Access Control Lists */
+#define EXT2_MOUNT_POSIX_ACL            0x008000  /* POSIX Access Control Lists */
+#define EXT2_MOUNT_XIP                  0x010000  /* Execute in place */
 #define clear_opt(o, opt)               o &= ~EXT2_MOUNT_##opt
 #define set_opt(o, opt)                 o |= EXT2_MOUNT_##opt
diff --git a/include/linux/ext3_fs.h b/include/linux/ext3_fs.h
index 74ad31781e3e..c16662836c58 100644
--- a/include/linux/ext3_fs.h
+++ b/include/linux/ext3_fs.h
@@ -239,6 +239,20 @@ struct ext3_new_group_data {
 #define EXT3_IOC_SETRSVSZ               _IOW('f', 6, long)
 /*
+ *  Mount options
+ */
+struct ext3_mount_options {
+        unsigned long s_mount_opt;
+        uid_t s_resuid;
+        gid_t s_resgid;
+        unsigned long s_commit_interval;
+#ifdef CONFIG_QUOTA
+        int s_jquota_fmt;
+        char *s_qf_names[MAXQUOTAS];
+#endif
+};
+/*
 * Structure of an inode on the disk
 */
 struct ext3_inode {
@@ -358,6 +372,7 @@ struct ext3_inode {
 #define EXT3_MOUNT_RESERVATION          0x10000 /* Preallocation */
 #define EXT3_MOUNT_BARRIER              0x20000 /* Use block barriers */
 #define EXT3_MOUNT_NOBH                 0x40000 /* No bufferheads */
+#define EXT3_MOUNT_QUOTA                0x80000 /* Some quota option set */
 /* Compatibility, for having both ext2_fs.h and ext3_fs.h included at once */
 #ifndef _LINUX_EXT2_FS_H
diff --git a/include/linux/ext3_jbd.h b/include/linux/ext3_jbd.h
index e8292af9033b..c8307c02dd07 100644
--- a/include/linux/ext3_jbd.h
+++ b/include/linux/ext3_jbd.h
@@ -42,15 +42,15 @@
 * superblock only gets updated once, of course, so don't bother
 * counting that again for the quota updates. */
-#define EXT3_DATA_TRANS_BLOCKS          (EXT3_SINGLEDATA_TRANS_BLOCKS + \
+#define EXT3_DATA_TRANS_BLOCKS(sb)      (EXT3_SINGLEDATA_TRANS_BLOCKS + \
                                         EXT3_XATTR_TRANS_BLOCKS - 2 + \
-                                         2*EXT3_QUOTA_TRANS_BLOCKS)
+                                         2*EXT3_QUOTA_TRANS_BLOCKS(sb))
 /* Delete operations potentially hit one directory's namespace plus an
 * entire inode, plus arbitrary amounts of bitmap/indirection data.  Be
 * generous.  We can grow the delete transaction later if necessary. */
-#define EXT3_DELETE_TRANS_BLOCKS        (2 * EXT3_DATA_TRANS_BLOCKS + 64)
+#define EXT3_DELETE_TRANS_BLOCKS(sb)    (2 * EXT3_DATA_TRANS_BLOCKS(sb) + 64)
 /* Define an arbitrary limit for the amount of data we will anticipate
 * writing to any given transaction.  For unbounded transactions such as
@@ -74,14 +74,17 @@
 #ifdef CONFIG_QUOTA
 /* Amount of blocks needed for quota update - we know that the structure was
 * allocated so we need to update only inode+data */
-#define EXT3_QUOTA_TRANS_BLOCKS 2
+#define EXT3_QUOTA_TRANS_BLOCKS(sb) (test_opt(sb, QUOTA) ? 2 : 0)
 /* Amount of blocks needed for quota insert/delete - we do some block writes
 * but inode, sb and group updates are done only once */
-#define EXT3_QUOTA_INIT_BLOCKS (DQUOT_MAX_WRITES*\
+#define EXT3_QUOTA_INIT_BLOCKS(sb) (test_opt(sb, QUOTA) ? (DQUOT_INIT_ALLOC*\
-                                (EXT3_SINGLEDATA_TRANS_BLOCKS-3)+3)
+                (EXT3_SINGLEDATA_TRANS_BLOCKS-3)+3+DQUOT_INIT_REWRITE) : 0)
+#define EXT3_QUOTA_DEL_BLOCKS(sb) (test_opt(sb, QUOTA) ? (DQUOT_DEL_ALLOC*\
+                (EXT3_SINGLEDATA_TRANS_BLOCKS-3)+3+DQUOT_DEL_REWRITE) : 0)
 #else
-#define EXT3_QUOTA_TRANS_BLOCKS 0
+#define EXT3_QUOTA_TRANS_BLOCKS(sb) 0
-#define EXT3_QUOTA_INIT_BLOCKS 0
+#define EXT3_QUOTA_INIT_BLOCKS(sb) 0
+#define EXT3_QUOTA_DEL_BLOCKS(sb) 0
 #endif
 int
diff --git a/include/linux/fadvise.h b/include/linux/fadvise.h
index 6fc656dfb93d..e8e747139b9a 100644
--- a/include/linux/fadvise.h
+++ b/include/linux/fadvise.h
@@ -5,7 +5,17 @@
 #define POSIX_FADV_RANDOM       1 /* Expect random page references.  */
 #define POSIX_FADV_SEQUENTIAL   2 /* Expect sequential page references.  */
 #define POSIX_FADV_WILLNEED     3 /* Will need these pages.  */
+/*
+ * The advise values for POSIX_FADV_DONTNEED and POSIX_ADV_NOREUSE
+ * for s390-64 differ from the values for the rest of the world.
+ */
+#if defined(__s390x__)
+#define POSIX_FADV_DONTNEED     6 /* Don't need these pages.  */
+#define POSIX_FADV_NOREUSE      7 /* Data will be accessed once.  */
+#else
 #define POSIX_FADV_DONTNEED     4 /* Don't need these pages.  */
 #define POSIX_FADV_NOREUSE      5 /* Data will be accessed once.  */
+#endif
 #endif  /* FADVISE_H_INCLUDED */
diff --git a/include/linux/fcntl.h b/include/linux/fcntl.h
index 704fb76b6334..8a7c82151de9 100644
--- a/include/linux/fcntl.h
+++ b/include/linux/fcntl.h
@@ -25,6 +25,10 @@
 #ifdef __KERNEL__
+#ifndef force_o_largefile
+#define force_o_largefile() (BITS_PER_LONG != 32)
+#endif
 #if BITS_PER_LONG == 32
 #define IS_GETLK32(cmd)         ((cmd) == F_GETLK)
 #define IS_SETLK32(cmd)         ((cmd) == F_SETLK)
diff --git a/include/linux/fddidevice.h b/include/linux/fddidevice.h
index 002f6367697d..e61e42dfd317 100644
--- a/include/linux/fddidevice.h
+++ b/include/linux/fddidevice.h
@@ -25,7 +25,7 @@
 #include <linux/if_fddi.h>
 #ifdef __KERNEL__
-extern unsigned short   fddi_type_trans(struct sk_buff *skb,
+extern __be16   fddi_type_trans(struct sk_buff *skb,
                                struct net_device *dev);
 extern struct net_device *alloc_fddidev(int sizeof_priv);
 #endif
diff --git a/include/linux/fs.h b/include/linux/fs.h
index 9b8b696d4f15..67e6732d4fdc 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -213,6 +213,7 @@ extern int dir_notify_enable;
 #include <linux/radix-tree.h>
 #include <linux/prio_tree.h>
 #include <linux/init.h>
+#include <linux/sched.h>
 #include <asm/atomic.h>
 #include <asm/semaphore.h>
@@ -220,6 +221,7 @@ extern int dir_notify_enable;
 struct iovec;
 struct nameidata;
+struct kiocb;
 struct pipe_inode_info;
 struct poll_table_struct;
 struct kstatfs;
@@ -240,7 +242,7 @@ typedef int (get_block_t)(struct inode *inode, sector_t iblock,
 typedef int (get_blocks_t)(struct inode *inode, sector_t iblock,
                        unsigned long max_blocks,
                        struct buffer_head *bh_result, int create);
-typedef void (dio_iodone_t)(struct inode *inode, loff_t offset,
+typedef void (dio_iodone_t)(struct kiocb *iocb, loff_t offset,
                        ssize_t bytes, void *private);
 /*
@@ -302,7 +304,6 @@ struct iattr {
 struct page;
 struct address_space;
 struct writeback_control;
-struct kiocb;
 struct address_space_operations {
        int (*writepage)(struct page *page, struct writeback_control *wbc);
@@ -330,6 +331,8 @@ struct address_space_operations {
        int (*releasepage) (struct page *, int);
        ssize_t (*direct_IO)(int, struct kiocb *, const struct iovec *iov,
                        loff_t offset, unsigned long nr_segs);
+        struct page* (*get_xip_page)(struct address_space *, sector_t,
+                        int);
 };
 struct backing_dev_info;
@@ -471,6 +474,11 @@ struct inode {
        struct dnotify_struct   *i_dnotify; /* for directory notifications */
 #endif
+#ifdef CONFIG_INOTIFY
+        struct list_head        inotify_watches; /* watches on this inode */
+        struct semaphore        inotify_sem;    /* protects the watches list */
+#endif
        unsigned long           i_state;
        unsigned long           dirtied_when;   /* jiffies of first dirtying */
@@ -581,7 +589,6 @@ struct file {
        atomic_t                f_count;
        unsigned int            f_flags;
        mode_t                  f_mode;
-        int                     f_error;
        loff_t                  f_pos;
        struct fown_struct      f_owner;
        unsigned int            f_uid, f_gid;
@@ -674,6 +681,7 @@ struct file_lock {
        struct lock_manager_operations *fl_lmops;       /* Callbacks for lockmanagers */
        union {
                struct nfs_lock_info    nfs_fl;
+                struct nfs4_lock_info   nfs4_fl;
        } fl_u;
 };
@@ -689,11 +697,13 @@ extern struct list_head file_lock_list;
 #include <linux/fcntl.h>
 extern int fcntl_getlk(struct file *, struct flock __user *);
-extern int fcntl_setlk(struct file *, unsigned int, struct flock __user *);
+extern int fcntl_setlk(unsigned int, struct file *, unsigned int,
+                        struct flock __user *);
 #if BITS_PER_LONG == 32
 extern int fcntl_getlk64(struct file *, struct flock64 __user *);
-extern int fcntl_setlk64(struct file *, unsigned int, struct flock64 __user *);
+extern int fcntl_setlk64(unsigned int, struct file *, unsigned int,
+                        struct flock64 __user *);
 #endif
 extern void send_sigio(struct fown_struct *fown, int fd, int band);
@@ -820,16 +830,34 @@ enum {
 #define vfs_check_frozen(sb, level) \
        wait_event((sb)->s_wait_unfrozen, ((sb)->s_frozen < (level)))
+static inline void get_fs_excl(void)
+{
+        atomic_inc(&current->fs_excl);
+}
+static inline void put_fs_excl(void)
+{
+        atomic_dec(&current->fs_excl);
+}
+static inline int has_fs_excl(void)
+{
+        return atomic_read(&current->fs_excl);
+}
 /*
 * Superblock locking.
 */
 static inline void lock_super(struct super_block * sb)
 {
+        get_fs_excl();
        down(&sb->s_lock);
 }
 static inline void unlock_super(struct super_block * sb)
 {
+        put_fs_excl();
        up(&sb->s_lock);
 }
@@ -883,7 +911,9 @@ struct block_device_operations {
        int (*open) (struct inode *, struct file *);
        int (*release) (struct inode *, struct file *);
        int (*ioctl) (struct inode *, struct file *, unsigned, unsigned long);
+        long (*unlocked_ioctl) (struct file *, unsigned, unsigned long);
        long (*compat_ioctl) (struct file *, unsigned, unsigned long);
+        int (*direct_access) (struct block_device *, sector_t, unsigned long *);
        int (*media_changed) (struct gendisk *);
        int (*revalidate_disk) (struct gendisk *);
        struct module *owner;
@@ -963,8 +993,8 @@ struct inode_operations {
        int (*rename) (struct inode *, struct dentry *,
                        struct inode *, struct dentry *);
        int (*readlink) (struct dentry *, char __user *,int);
-        int (*follow_link) (struct dentry *, struct nameidata *);
+        void * (*follow_link) (struct dentry *, struct nameidata *);
-        void (*put_link) (struct dentry *, struct nameidata *);
+        void (*put_link) (struct dentry *, struct nameidata *, void *);
        void (*truncate) (struct inode *);
        int (*permission) (struct inode *, int, struct nameidata *);
        int (*setattr) (struct dentry *, struct iattr *);
@@ -1024,6 +1054,7 @@ struct super_operations {
 #define I_FREEING               16
 #define I_CLEAR                 32
 #define I_NEW                   64
+#define I_WILL_FREE             128
 #define I_DIRTY (I_DIRTY_SYNC | I_DIRTY_DATASYNC | I_DIRTY_PAGES)
@@ -1369,7 +1400,6 @@ extern void emergency_remount(void);
 extern int do_remount_sb(struct super_block *sb, int flags,
                         void *data, int force);
 extern sector_t bmap(struct inode *, sector_t);
-extern int setattr_mask(unsigned int);
 extern int notify_change(struct dentry *, struct iattr *);
 extern int permission(struct inode *, int, struct nameidata *);
 extern int generic_permission(struct inode *, int,
@@ -1411,7 +1441,11 @@ extern struct inode * igrab(struct inode *);
 extern ino_t iunique(struct super_block *, ino_t);
 extern int inode_needs_sync(struct inode *inode);
 extern void generic_delete_inode(struct inode *inode);
+extern void generic_drop_inode(struct inode *inode);
+extern struct inode *ilookup5_nowait(struct super_block *sb,
+                unsigned long hashval, int (*test)(struct inode *, void *),
+                void *data);
 extern struct inode *ilookup5(struct super_block *sb, unsigned long hashval,
                int (*test)(struct inode *, void *), void *data);
 extern struct inode *ilookup(struct super_block *sb, unsigned long ino);
@@ -1494,6 +1528,23 @@ extern loff_t remote_llseek(struct file *file, loff_t offset, int origin);
 extern int generic_file_open(struct inode * inode, struct file * filp);
 extern int nonseekable_open(struct inode * inode, struct file * filp);
+#ifdef CONFIG_FS_XIP
+extern ssize_t xip_file_read(struct file *filp, char __user *buf, size_t len,
+                             loff_t *ppos);
+extern ssize_t xip_file_sendfile(struct file *in_file, loff_t *ppos,
+                                 size_t count, read_actor_t actor,
+                                 void *target);
+extern int xip_file_mmap(struct file * file, struct vm_area_struct * vma);
+extern ssize_t xip_file_write(struct file *filp, const char __user *buf,
+                              size_t len, loff_t *ppos);
+extern int xip_truncate_page(struct address_space *mapping, loff_t from);
+#else
+static inline int xip_truncate_page(struct address_space *mapping, loff_t from)
+{
+        return 0;
+}
+#endif
 static inline void do_generic_file_read(struct file * filp, loff_t *ppos,
                                        read_descriptor_t * desc,
                                        read_actor_t actor)
@@ -1551,8 +1602,8 @@ extern struct file_operations generic_ro_fops;
 extern int vfs_readlink(struct dentry *, char __user *, int, const char *);
 extern int vfs_follow_link(struct nameidata *, const char *);
 extern int page_readlink(struct dentry *, char __user *, int);
-extern int page_follow_link_light(struct dentry *, struct nameidata *);
+extern void *page_follow_link_light(struct dentry *, struct nameidata *);
-extern void page_put_link(struct dentry *, struct nameidata *);
+extern void page_put_link(struct dentry *, struct nameidata *, void *);
 extern int page_symlink(struct inode *inode, const char *symname, int len);
 extern struct inode_operations page_symlink_inode_operations;
 extern int generic_readlink(struct dentry *, char __user *, int);
diff --git a/include/linux/fsnotify.h b/include/linux/fsnotify.h
new file mode 100644
index 000000000000..03b8e7932b83
--- /dev/null
+++ b/include/linux/fsnotify.h
@@ -0,0 +1,251 @@
+#ifndef _LINUX_FS_NOTIFY_H
+#define _LINUX_FS_NOTIFY_H
+/*
+ * include/linux/fsnotify.h - generic hooks for filesystem notification, to
+ * reduce in-source duplication from both dnotify and inotify.
+ *
+ * We don't compile any of this away in some complicated menagerie of ifdefs.
+ * Instead, we rely on the code inside to optimize away as needed.
+ *
+ * (C) Copyright 2005 Robert Love
+ */
+#ifdef __KERNEL__
+#include <linux/dnotify.h>
+#include <linux/inotify.h>
+/*
+ * fsnotify_move - file old_name at old_dir was moved to new_name at new_dir
+ */
+static inline void fsnotify_move(struct inode *old_dir, struct inode *new_dir,
+                                 const char *old_name, const char *new_name,
+                                 int isdir, struct inode *target, struct inode *source)
+{
+        u32 cookie = inotify_get_cookie();
+        if (old_dir == new_dir)
+                inode_dir_notify(old_dir, DN_RENAME);
+        else {
+                inode_dir_notify(old_dir, DN_DELETE);
+                inode_dir_notify(new_dir, DN_CREATE);
+        }
+        if (isdir)
+                isdir = IN_ISDIR;
+        inotify_inode_queue_event(old_dir, IN_MOVED_FROM|isdir,cookie,old_name);
+        inotify_inode_queue_event(new_dir, IN_MOVED_TO|isdir, cookie, new_name);
+        if (target) {
+                inotify_inode_queue_event(target, IN_DELETE_SELF, 0, NULL);
+                inotify_inode_is_dead(target);
+        }
+        if (source) {
+                inotify_inode_queue_event(source, IN_MOVE_SELF, 0, NULL);
+        }
+}
+/*
+ * fsnotify_nameremove - a filename was removed from a directory
+ */
+static inline void fsnotify_nameremove(struct dentry *dentry, int isdir)
+{
+        if (isdir)
+                isdir = IN_ISDIR;
+        dnotify_parent(dentry, DN_DELETE);
+        inotify_dentry_parent_queue_event(dentry, IN_DELETE|isdir, 0, dentry->d_name.name);
+}
+/*
+ * fsnotify_inoderemove - an inode is going away
+ */
+static inline void fsnotify_inoderemove(struct inode *inode)
+{
+        inotify_inode_queue_event(inode, IN_DELETE_SELF, 0, NULL);
+        inotify_inode_is_dead(inode);
+}
+/*
+ * fsnotify_create - 'name' was linked in
+ */
+static inline void fsnotify_create(struct inode *inode, const char *name)
+{
+        inode_dir_notify(inode, DN_CREATE);
+        inotify_inode_queue_event(inode, IN_CREATE, 0, name);
+}
+/*
+ * fsnotify_mkdir - directory 'name' was created
+ */
+static inline void fsnotify_mkdir(struct inode *inode, const char *name)
+{
+        inode_dir_notify(inode, DN_CREATE);
+        inotify_inode_queue_event(inode, IN_CREATE | IN_ISDIR, 0, name);
+}
+/*
+ * fsnotify_access - file was read
+ */
+static inline void fsnotify_access(struct dentry *dentry)
+{
+        struct inode *inode = dentry->d_inode;
+        u32 mask = IN_ACCESS;
+        if (S_ISDIR(inode->i_mode))
+                mask |= IN_ISDIR;
+        dnotify_parent(dentry, DN_ACCESS);
+        inotify_dentry_parent_queue_event(dentry, mask, 0, dentry->d_name.name);
+        inotify_inode_queue_event(inode, mask, 0, NULL);
+}
+/*
+ * fsnotify_modify - file was modified
+ */
+static inline void fsnotify_modify(struct dentry *dentry)
+{
+        struct inode *inode = dentry->d_inode;
+        u32 mask = IN_MODIFY;
+        if (S_ISDIR(inode->i_mode))
+                mask |= IN_ISDIR;
+        dnotify_parent(dentry, DN_MODIFY);
+        inotify_dentry_parent_queue_event(dentry, mask, 0, dentry->d_name.name);
+        inotify_inode_queue_event(inode, mask, 0, NULL);
+}
+/*
+ * fsnotify_open - file was opened
+ */
+static inline void fsnotify_open(struct dentry *dentry)
+{
+        struct inode *inode = dentry->d_inode;
+        u32 mask = IN_OPEN;
+        if (S_ISDIR(inode->i_mode))
+                mask |= IN_ISDIR;
+        inotify_dentry_parent_queue_event(dentry, mask, 0, dentry->d_name.name);
+        inotify_inode_queue_event(inode, mask, 0, NULL);        
+}
+/*
+ * fsnotify_close - file was closed
+ */
+static inline void fsnotify_close(struct file *file)
+{
+        struct dentry *dentry = file->f_dentry;
+        struct inode *inode = dentry->d_inode;
+        const char *name = dentry->d_name.name;
+        mode_t mode = file->f_mode;
+        u32 mask = (mode & FMODE_WRITE) ? IN_CLOSE_WRITE : IN_CLOSE_NOWRITE;
+        if (S_ISDIR(inode->i_mode))
+                mask |= IN_ISDIR;
+        inotify_dentry_parent_queue_event(dentry, mask, 0, name);
+        inotify_inode_queue_event(inode, mask, 0, NULL);
+}
+/*
+ * fsnotify_xattr - extended attributes were changed
+ */
+static inline void fsnotify_xattr(struct dentry *dentry)
+{
+        struct inode *inode = dentry->d_inode;
+        u32 mask = IN_ATTRIB;
+        if (S_ISDIR(inode->i_mode))
+                mask |= IN_ISDIR;
+        inotify_dentry_parent_queue_event(dentry, mask, 0, dentry->d_name.name);
+        inotify_inode_queue_event(inode, mask, 0, NULL);
+}
+/*
+ * fsnotify_change - notify_change event.  file was modified and/or metadata
+ * was changed.
+ */
+static inline void fsnotify_change(struct dentry *dentry, unsigned int ia_valid)
+{
+        struct inode *inode = dentry->d_inode;
+        int dn_mask = 0;
+        u32 in_mask = 0;
+        if (ia_valid & ATTR_UID) {
+                in_mask |= IN_ATTRIB;
+                dn_mask |= DN_ATTRIB;
+        }
+        if (ia_valid & ATTR_GID) {
+                in_mask |= IN_ATTRIB;
+                dn_mask |= DN_ATTRIB;
+        }
+        if (ia_valid & ATTR_SIZE) {
+                in_mask |= IN_MODIFY;
+                dn_mask |= DN_MODIFY;
+        }
+        /* both times implies a utime(s) call */
+        if ((ia_valid & (ATTR_ATIME | ATTR_MTIME)) == (ATTR_ATIME | ATTR_MTIME))
+        {
+                in_mask |= IN_ATTRIB;
+                dn_mask |= DN_ATTRIB;
+        } else if (ia_valid & ATTR_ATIME) {
+                in_mask |= IN_ACCESS;
+                dn_mask |= DN_ACCESS;
+        } else if (ia_valid & ATTR_MTIME) {
+                in_mask |= IN_MODIFY;
+                dn_mask |= DN_MODIFY;
+        }
+        if (ia_valid & ATTR_MODE) {
+                in_mask |= IN_ATTRIB;
+                dn_mask |= DN_ATTRIB;
+        }
+        if (dn_mask)
+                dnotify_parent(dentry, dn_mask);
+        if (in_mask) {
+                if (S_ISDIR(inode->i_mode))
+                        in_mask |= IN_ISDIR;
+                inotify_inode_queue_event(inode, in_mask, 0, NULL);
+                inotify_dentry_parent_queue_event(dentry, in_mask, 0,
+                                                  dentry->d_name.name);
+        }
+}
+#ifdef CONFIG_INOTIFY   /* inotify helpers */
+/*
+ * fsnotify_oldname_init - save off the old filename before we change it
+ */
+static inline const char *fsnotify_oldname_init(const char *name)
+{
+        return kstrdup(name, GFP_KERNEL);
+}
+/*
+ * fsnotify_oldname_free - free the name we got from fsnotify_oldname_init
+ */
+static inline void fsnotify_oldname_free(const char *old_name)
+{
+        kfree(old_name);
+}
+#else   /* CONFIG_INOTIFY */
+static inline const char *fsnotify_oldname_init(const char *name)
+{
+        return NULL;
+}
+static inline void fsnotify_oldname_free(const char *old_name)
+{
+}
+#endif  /* ! CONFIG_INOTIFY */
+#endif  /* __KERNEL__ */
+#endif  /* _LINUX_FS_NOTIFY_H */
diff --git a/include/linux/ftape.h b/include/linux/ftape.h
index c6b38d5b9186..72faeec9f6e1 100644
--- a/include/linux/ftape.h
+++ b/include/linux/ftape.h
@@ -165,7 +165,7 @@ typedef union {
 #  undef  CONFIG_FT_FDC_DMA
 #  define CONFIG_FT_FDC_DMA 2
 # endif
-#elif CONFIG_FT_ALT_FDC == 1  /* CONFIG_FT_MACH2 */
+#elif defined(CONFIG_FT_ALT_FDC)  /* CONFIG_FT_MACH2 */
 # if CONFIG_FT_FDC_BASE == 0
 #  undef  CONFIG_FT_FDC_BASE
 #  define CONFIG_FT_FDC_BASE 0x370
diff --git a/include/linux/genhd.h b/include/linux/genhd.h
index 47dedaf971d6..01796c41c951 100644
--- a/include/linux/genhd.h
+++ b/include/linux/genhd.h
@@ -224,7 +224,7 @@ static inline void free_disk_stats(struct gendisk *disk)
 extern void disk_round_stats(struct gendisk *disk);
 /* drivers/block/genhd.c */
-extern int get_blkdev_list(char *);
+extern int get_blkdev_list(char *, int);
 extern void add_disk(struct gendisk *disk);
 extern void del_gendisk(struct gendisk *gp);
 extern void unlink_gendisk(struct gendisk *gp);
@@ -403,6 +403,7 @@ extern int rescan_partitions(struct gendisk *disk, struct block_device *bdev);
 extern void add_partition(struct gendisk *, int, sector_t, sector_t);
 extern void delete_partition(struct gendisk *, int);
+extern struct gendisk *alloc_disk_node(int minors, int node_id);
 extern struct gendisk *alloc_disk(int minors);
 extern struct kobject *get_disk(struct gendisk *disk);
 extern void put_disk(struct gendisk *disk);
diff --git a/include/linux/gfp.h b/include/linux/gfp.h
index 8d6bf608b199..7c7400137e97 100644
--- a/include/linux/gfp.h
+++ b/include/linux/gfp.h
@@ -12,8 +12,8 @@ struct vm_area_struct;
 * GFP bitmasks..
 */
 /* Zone modifiers in GFP_ZONEMASK (see linux/mmzone.h - low two bits) */
-#define __GFP_DMA       0x01
+#define __GFP_DMA       0x01u
-#define __GFP_HIGHMEM   0x02
+#define __GFP_HIGHMEM   0x02u
 /*
 * Action modifiers - doesn't change the zoning
diff --git a/include/linux/hardirq.h b/include/linux/hardirq.h
index 8336dba18971..5912874ca83c 100644
--- a/include/linux/hardirq.h
+++ b/include/linux/hardirq.h
@@ -2,6 +2,7 @@
 #define LINUX_HARDIRQ_H
 #include <linux/config.h>
+#include <linux/preempt.h>
 #include <linux/smp_lock.h>
 #include <asm/hardirq.h>
 #include <asm/system.h>
diff --git a/include/linux/hdlc.h b/include/linux/hdlc.h
index ed2927ef1ff7..df695e9ae327 100644
--- a/include/linux/hdlc.h
+++ b/include/linux/hdlc.h
@@ -242,8 +242,8 @@ static __inline__ struct net_device_stats *hdlc_stats(struct net_device *dev)
 }
-static __inline__ unsigned short hdlc_type_trans(struct sk_buff *skb,
+static __inline__ __be16 hdlc_type_trans(struct sk_buff *skb,
-                                                 struct net_device *dev)
+                                         struct net_device *dev)
 {
        hdlc_device *hdlc = dev_to_hdlc(dev);
diff --git a/include/linux/highmem.h b/include/linux/highmem.h
index 2a7e6c65c882..6bece9280eb7 100644
--- a/include/linux/highmem.h
+++ b/include/linux/highmem.h
@@ -28,6 +28,7 @@ static inline void *kmap(struct page *page)
 #define kmap_atomic(page, idx)          page_address(page)
 #define kunmap_atomic(addr, idx)        do { } while (0)
+#define kmap_atomic_pfn(pfn, idx)       page_address(pfn_to_page(pfn))
 #define kmap_atomic_to_page(ptr)        virt_to_page(ptr)
 #endif /* CONFIG_HIGHMEM */
diff --git a/include/linux/i2c-sysfs.h b/include/linux/hwmon-sysfs.h
index d7bf6ce11679..1b5018a965f5 100644
--- a/include/linux/i2c-sysfs.h
+++ b/include/linux/hwmon-sysfs.h
@@ -1,5 +1,5 @@
 /*
- *  i2c-sysfs.h - i2c chip driver sysfs defines
+ *  hwmon-sysfs.h - hardware monitoring chip driver sysfs defines
 *
 *  Copyright (C) 2005 Yani Ioannou <yani.ioannou@gmail.com>
 *
@@ -17,8 +17,8 @@
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
-#ifndef _LINUX_I2C_SYSFS_H
+#ifndef _LINUX_HWMON_SYSFS_H
-#define _LINUX_I2C_SYSFS_H
+#define _LINUX_HWMON_SYSFS_H
 struct sensor_device_attribute{
        struct device_attribute dev_attr;
@@ -33,4 +33,4 @@ struct sensor_device_attribute sensor_dev_attr_##_name = {	\
        .index =        _index,                                 \
 }
-#endif /* _LINUX_I2C_SYSFS_H */
+#endif /* _LINUX_HWMON_SYSFS_H */
diff --git a/include/linux/i2c-dev.h b/include/linux/i2c-dev.h
index d228230ffe5d..541695679762 100644
--- a/include/linux/i2c-dev.h
+++ b/include/linux/i2c-dev.h
@@ -25,6 +25,7 @@
 #define _LINUX_I2C_DEV_H
 #include <linux/types.h>
+#include <linux/compiler.h>
 /* Some IOCTL commands are defined in <linux/i2c.h> */
 /* Note: 10-bit addresses are NOT supported! */
diff --git a/include/linux/i2c-id.h b/include/linux/i2c-id.h
index 89270ce51470..33f08258f22b 100644
--- a/include/linux/i2c-id.h
+++ b/include/linux/i2c-id.h
@@ -108,6 +108,7 @@
 #define I2C_DRIVERID_TDA7313    62      /* TDA7313 audio processor      */
 #define I2C_DRIVERID_MAX6900    63      /* MAX6900 real-time clock      */
 #define I2C_DRIVERID_SAA7114H   64      /* video decoder                */
+#define I2C_DRIVERID_DS1374     65      /* DS1374 real time clock       */
 #define I2C_DRIVERID_EXP0       0xF0    /* experimental use id's        */
diff --git a/include/linux/i2c-vid.h b/include/linux/i2c-vid.h
index 974835e3530f..41d0635e0ba9 100644
--- a/include/linux/i2c-vid.h
+++ b/include/linux/i2c-vid.h
@@ -97,3 +97,15 @@ static inline int vid_from_reg(int val, int vrm)
                                     2050 - (val) * 50);
        }
 }
+static inline int vid_to_reg(int val, int vrm)
+{
+        switch (vrm) {
+        case 91:                /* VRM 9.1 */
+        case 90:                /* VRM 9.0 */
+                return ((val >= 1100) && (val <= 1850) ?
+                        ((18499 - val * 10) / 25 + 5) / 10 : -1);
+        default:
+                return -1;
+        }
+}
diff --git a/include/linux/i2c.h b/include/linux/i2c.h
index ebcd745f4cd6..be837b13f297 100644
--- a/include/linux/i2c.h
+++ b/include/linux/i2c.h
@@ -290,11 +290,8 @@ static inline void i2c_set_adapdata (struct i2c_adapter *dev, void *data)
 */
 struct i2c_client_address_data {
        unsigned short *normal_i2c;
-        unsigned short *normal_i2c_range;
        unsigned short *probe;
-        unsigned short *probe_range;
        unsigned short *ignore;
-        unsigned short *ignore_range;
        unsigned short *force;
 };
@@ -563,24 +560,15 @@ union i2c_smbus_data {
 #define I2C_CLIENT_INSMOD \
  I2C_CLIENT_MODULE_PARM(probe, \
                      "List of adapter,address pairs to scan additionally"); \
-  I2C_CLIENT_MODULE_PARM(probe_range, \
-                      "List of adapter,start-addr,end-addr triples to scan " \
-                      "additionally"); \
  I2C_CLIENT_MODULE_PARM(ignore, \
                      "List of adapter,address pairs not to scan"); \
-  I2C_CLIENT_MODULE_PARM(ignore_range, \
-                      "List of adapter,start-addr,end-addr triples not to " \
-                      "scan"); \
  I2C_CLIENT_MODULE_PARM(force, \
                      "List of adapter,address pairs to boldly assume " \
                      "to be present"); \
        static struct i2c_client_address_data addr_data = {             \
                        .normal_i2c =           normal_i2c,             \
-                        .normal_i2c_range =     normal_i2c_range,       \
                        .probe =                probe,                  \
-                        .probe_range =          probe_range,            \
                        .ignore =               ignore,                 \
-                        .ignore_range =         ignore_range,           \
                        .force =                force,                  \
                }
diff --git a/include/linux/i2o-dev.h b/include/linux/i2o-dev.h
index ef7f644dd873..36fd18cdad28 100644
--- a/include/linux/i2o-dev.h
+++ b/include/linux/i2o-dev.h
@@ -24,6 +24,13 @@
 #define MAX_I2O_CONTROLLERS     32
 //#include <linux/ioctl.h>
+#ifndef __KERNEL__
+typedef unsigned char u8;
+typedef unsigned short u16;
+typedef unsigned int u32;
+#endif                          /* __KERNEL__ */
 /*
 * I2O Control IOCTLs and structures
@@ -113,6 +120,10 @@ struct i2o_evt_get {
        int lost;
 };
+typedef struct i2o_sg_io_hdr {
+        unsigned int flags;     /* see I2O_DPT_SG_IO_FLAGS */
+} i2o_sg_io_hdr_t;
 /**************************************************************************
 * HRT related constants and structures
 **************************************************************************/
@@ -126,14 +137,6 @@ struct i2o_evt_get {
 #define I2O_BUS_CARDBUS 7
 #define I2O_BUS_UNKNOWN 0x80
-#ifndef __KERNEL__
-typedef unsigned char u8;
-typedef unsigned short u16;
-typedef unsigned int u32;
-#endif                          /* __KERNEL__ */
 typedef struct _i2o_pci_bus {
        u8 PciFunctionNumber;
        u8 PciDeviceNumber;
@@ -333,7 +336,7 @@ typedef struct _i2o_status_block {
 #define I2O_CLASS_ATE_PERIPHERAL                0x061
 #define I2O_CLASS_FLOPPY_CONTROLLER             0x070
 #define I2O_CLASS_FLOPPY_DEVICE                 0x071
-#define I2O_CLASS_BUS_ADAPTER_PORT              0x080
+#define I2O_CLASS_BUS_ADAPTER                   0x080
 #define I2O_CLASS_PEER_TRANSPORT_AGENT          0x090
 #define I2O_CLASS_PEER_TRANSPORT                0x091
 #define I2O_CLASS_END                           0xfff
@@ -399,4 +402,26 @@ typedef struct _i2o_status_block {
 #define ADAPTER_STATE_FAILED                    0x10
 #define ADAPTER_STATE_FAULTED                   0x11
+/*
+ *      Software module types
+ */
+#define I2O_SOFTWARE_MODULE_IRTOS               0x11
+#define I2O_SOFTWARE_MODULE_IOP_PRIVATE         0x22
+#define I2O_SOFTWARE_MODULE_IOP_CONFIG          0x23
+/*
+ *      Vendors
+ */
+#define I2O_VENDOR_DPT                          0x001b
+/*
+ * DPT / Adaptec specific values for i2o_sg_io_hdr flags.
+ */
+#define I2O_DPT_SG_FLAG_INTERPRET               0x00010000
+#define I2O_DPT_SG_FLAG_PHYSICAL                0x00020000
+#define I2O_DPT_FLASH_FRAG_SIZE                 0x10000
+#define I2O_DPT_FLASH_READ                      0x0101
+#define I2O_DPT_FLASH_WRITE                     0x0102
 #endif                          /* _I2O_DEV_H */
diff --git a/include/linux/i2o.h b/include/linux/i2o.h
index ea9a3ad4b67f..bdc286ec947c 100644
--- a/include/linux/i2o.h
+++ b/include/linux/i2o.h
@@ -119,12 +119,21 @@ struct i2o_driver {
 };
 /*
- *      Contains all information which are necessary for DMA operations
+ *      Contains DMA mapped address information
 */
 struct i2o_dma {
        void *virt;
        dma_addr_t phys;
-        u32 len;
+        size_t len;
+};
+/*
+ *      Contains IO mapped address information
+ */
+struct i2o_io {
+        void __iomem *virt;
+        unsigned long phys;
+        unsigned long len;
 };
 /*
@@ -147,28 +156,25 @@ struct i2o_controller {
        struct pci_dev *pdev;   /* PCI device */
-        unsigned int short_req:1;       /* use small block sizes */
+        unsigned int promise:1; /* Promise controller */
+        unsigned int adaptec:1; /* DPT / Adaptec controller */
+        unsigned int raptor:1;  /* split bar */
        unsigned int no_quiesce:1;      /* dont quiesce before reset */
-        unsigned int raptor:1;          /* split bar */
+        unsigned int short_req:1;       /* use small block sizes */
-        unsigned int promise:1;         /* Promise controller */
+        unsigned int limit_sectors:1;   /* limit number of sectors / request */
+        unsigned int pae_support:1;     /* controller has 64-bit SGL support */
-#ifdef CONFIG_MTRR
-        int mtrr_reg0;
-        int mtrr_reg1;
-#endif
        struct list_head devices;       /* list of I2O devices */
-        struct notifier_block *event_notifer;   /* Events */
-        atomic_t users;
        struct list_head list;  /* Controller list */
-        void __iomem *post_port;        /* Inbout port address */
-        void __iomem *reply_port;       /* Outbound port address */
+        void __iomem *in_port;  /* Inbout port address */
-        void __iomem *irq_mask;         /* Interrupt register address */
+        void __iomem *out_port; /* Outbound port address */
+        void __iomem *irq_status;       /* Interrupt status register address */
+        void __iomem *irq_mask; /* Interrupt mask register address */
        /* Dynamic LCT related data */
-        struct i2o_dma status;  /* status of IOP */
+        struct i2o_dma status;  /* IOP status block */
        struct i2o_dma hrt;     /* HW Resource Table */
        i2o_lct *lct;           /* Logical Config Table */
@@ -176,21 +182,19 @@ struct i2o_controller {
        struct semaphore lct_lock;      /* Lock for LCT updates */
        struct i2o_dma status_block;    /* IOP status block */
-        struct i2o_dma base;    /* controller messaging unit */
+        struct i2o_io base;     /* controller messaging unit */
-        struct i2o_dma in_queue;        /* inbound message queue Host->IOP */
+        struct i2o_io in_queue; /* inbound message queue Host->IOP */
        struct i2o_dma out_queue;       /* outbound message queue IOP->Host */
-        unsigned int battery:1;         /* Has a battery backup */
+        unsigned int battery:1; /* Has a battery backup */
        unsigned int io_alloc:1;        /* An I/O resource was allocated */
        unsigned int mem_alloc:1;       /* A memory resource was allocated */
        struct resource io_resource;    /* I/O resource allocated to the IOP */
        struct resource mem_resource;   /* Mem resource allocated to the IOP */
-        struct proc_dir_entry *proc_entry;      /* /proc dir */
-        struct list_head bus_list;      /* list of busses on IOP */
        struct device device;
+        struct class_device classdev;   /* I2O controller class */
        struct i2o_device *exec;        /* Executive */
 #if BITS_PER_LONG == 64
        spinlock_t context_list_lock;   /* lock for context_list */
@@ -241,9 +245,10 @@ struct i2o_sys_tbl {
 extern struct list_head i2o_controllers;
 /* Message functions */
-static inline u32 i2o_msg_get(struct i2o_controller *, struct i2o_message __iomem **);
+static inline u32 i2o_msg_get(struct i2o_controller *,
-extern u32 i2o_msg_get_wait(struct i2o_controller *, struct i2o_message __iomem **,
+                              struct i2o_message __iomem **);
-                            int);
+extern u32 i2o_msg_get_wait(struct i2o_controller *,
+                            struct i2o_message __iomem **, int);
 static inline void i2o_msg_post(struct i2o_controller *, u32);
 static inline int i2o_msg_post_wait(struct i2o_controller *, u32,
                                    unsigned long);
@@ -252,15 +257,6 @@ extern int i2o_msg_post_wait_mem(struct i2o_controller *, u32, unsigned long,
 extern void i2o_msg_nop(struct i2o_controller *, u32);
 static inline void i2o_flush_reply(struct i2o_controller *, u32);
-/* DMA handling functions */
-static inline int i2o_dma_alloc(struct device *, struct i2o_dma *, size_t,
-                                unsigned int);
-static inline void i2o_dma_free(struct device *, struct i2o_dma *);
-int i2o_dma_realloc(struct device *, struct i2o_dma *, size_t, unsigned int);
-static inline int i2o_dma_map(struct device *, struct i2o_dma *);
-static inline void i2o_dma_unmap(struct device *, struct i2o_dma *);
 /* IOP functions */
 extern int i2o_status_get(struct i2o_controller *);
@@ -285,6 +281,16 @@ static inline u32 i2o_ptr_high(void *ptr)
 {
        return (u32) ((u64) ptr >> 32);
 };
+static inline u32 i2o_dma_low(dma_addr_t dma_addr)
+{
+        return (u32) (u64) dma_addr;
+};
+static inline u32 i2o_dma_high(dma_addr_t dma_addr)
+{
+        return (u32) ((u64) dma_addr >> 32);
+};
 #else
 static inline u32 i2o_cntxt_list_add(struct i2o_controller *c, void *ptr)
 {
@@ -315,8 +321,246 @@ static inline u32 i2o_ptr_high(void *ptr)
 {
        return 0;
 };
+static inline u32 i2o_dma_low(dma_addr_t dma_addr)
+{
+        return (u32) dma_addr;
+};
+static inline u32 i2o_dma_high(dma_addr_t dma_addr)
+{
+        return 0;
+};
 #endif
+/**
+ *      i2o_sg_tablesize - Calculate the maximum number of elements in a SGL
+ *      @c: I2O controller for which the calculation should be done
+ *      @body_size: maximum body size used for message in 32-bit words.
+ *
+ *      Return the maximum number of SG elements in a SG list.
+ */
+static inline u16 i2o_sg_tablesize(struct i2o_controller *c, u16 body_size)
+{
+        i2o_status_block *sb = c->status_block.virt;
+        u16 sg_count =
+            (sb->inbound_frame_size - sizeof(struct i2o_message) / 4) -
+            body_size;
+        if (c->pae_support) {
+                /*
+                 * for 64-bit a SG attribute element must be added and each
+                 * SG element needs 12 bytes instead of 8.
+                 */
+                sg_count -= 2;
+                sg_count /= 3;
+        } else
+                sg_count /= 2;
+        if (c->short_req && (sg_count > 8))
+                sg_count = 8;
+        return sg_count;
+};
+/**
+ *      i2o_dma_map_single - Map pointer to controller and fill in I2O message.
+ *      @c: I2O controller
+ *      @ptr: pointer to the data which should be mapped
+ *      @size: size of data in bytes
+ *      @direction: DMA_TO_DEVICE / DMA_FROM_DEVICE
+ *      @sg_ptr: pointer to the SG list inside the I2O message
+ *
+ *      This function does all necessary DMA handling and also writes the I2O
+ *      SGL elements into the I2O message. For details on DMA handling see also
+ *      dma_map_single(). The pointer sg_ptr will only be set to the end of the
+ *      SG list if the allocation was successful.
+ *
+ *      Returns DMA address which must be checked for failures using
+ *      dma_mapping_error().
+ */
+static inline dma_addr_t i2o_dma_map_single(struct i2o_controller *c, void *ptr,
+                                            size_t size,
+                                            enum dma_data_direction direction,
+                                            u32 __iomem ** sg_ptr)
+{
+        u32 sg_flags;
+        u32 __iomem *mptr = *sg_ptr;
+        dma_addr_t dma_addr;
+        switch (direction) {
+        case DMA_TO_DEVICE:
+                sg_flags = 0xd4000000;
+                break;
+        case DMA_FROM_DEVICE:
+                sg_flags = 0xd0000000;
+                break;
+        default:
+                return 0;
+        }
+        dma_addr = dma_map_single(&c->pdev->dev, ptr, size, direction);
+        if (!dma_mapping_error(dma_addr)) {
+#ifdef CONFIG_I2O_EXT_ADAPTEC_DMA64
+                if ((sizeof(dma_addr_t) > 4) && c->pae_support) {
+                        writel(0x7C020002, mptr++);
+                        writel(PAGE_SIZE, mptr++);
+                }
+#endif
+                writel(sg_flags | size, mptr++);
+                writel(i2o_dma_low(dma_addr), mptr++);
+#ifdef CONFIG_I2O_EXT_ADAPTEC_DMA64
+                if ((sizeof(dma_addr_t) > 4) && c->pae_support)
+                        writel(i2o_dma_high(dma_addr), mptr++);
+#endif
+                *sg_ptr = mptr;
+        }
+        return dma_addr;
+};
+/**
+ *      i2o_dma_map_sg - Map a SG List to controller and fill in I2O message.
+ *      @c: I2O controller
+ *      @sg: SG list to be mapped
+ *      @sg_count: number of elements in the SG list
+ *      @direction: DMA_TO_DEVICE / DMA_FROM_DEVICE
+ *      @sg_ptr: pointer to the SG list inside the I2O message
+ *
+ *      This function does all necessary DMA handling and also writes the I2O
+ *      SGL elements into the I2O message. For details on DMA handling see also
+ *      dma_map_sg(). The pointer sg_ptr will only be set to the end of the SG
+ *      list if the allocation was successful.
+ *
+ *      Returns 0 on failure or 1 on success.
+ */
+static inline int i2o_dma_map_sg(struct i2o_controller *c,
+                                 struct scatterlist *sg, int sg_count,
+                                 enum dma_data_direction direction,
+                                 u32 __iomem ** sg_ptr)
+{
+        u32 sg_flags;
+        u32 __iomem *mptr = *sg_ptr;
+        switch (direction) {
+        case DMA_TO_DEVICE:
+                sg_flags = 0x14000000;
+                break;
+        case DMA_FROM_DEVICE:
+                sg_flags = 0x10000000;
+                break;
+        default:
+                return 0;
+        }
+        sg_count = dma_map_sg(&c->pdev->dev, sg, sg_count, direction);
+        if (!sg_count)
+                return 0;
+#ifdef CONFIG_I2O_EXT_ADAPTEC_DMA64
+        if ((sizeof(dma_addr_t) > 4) && c->pae_support) {
+                writel(0x7C020002, mptr++);
+                writel(PAGE_SIZE, mptr++);
+        }
+#endif
+        while (sg_count-- > 0) {
+                if (!sg_count)
+                        sg_flags |= 0xC0000000;
+                writel(sg_flags | sg_dma_len(sg), mptr++);
+                writel(i2o_dma_low(sg_dma_address(sg)), mptr++);
+#ifdef CONFIG_I2O_EXT_ADAPTEC_DMA64
+                if ((sizeof(dma_addr_t) > 4) && c->pae_support)
+                        writel(i2o_dma_high(sg_dma_address(sg)), mptr++);
+#endif
+                sg++;
+        }
+        *sg_ptr = mptr;
+        return 1;
+};
+/**
+ *      i2o_dma_alloc - Allocate DMA memory
+ *      @dev: struct device pointer to the PCI device of the I2O controller
+ *      @addr: i2o_dma struct which should get the DMA buffer
+ *      @len: length of the new DMA memory
+ *      @gfp_mask: GFP mask
+ *
+ *      Allocate a coherent DMA memory and write the pointers into addr.
+ *
+ *      Returns 0 on success or -ENOMEM on failure.
+ */
+static inline int i2o_dma_alloc(struct device *dev, struct i2o_dma *addr,
+                                size_t len, unsigned int gfp_mask)
+{
+        struct pci_dev *pdev = to_pci_dev(dev);
+        int dma_64 = 0;
+        if ((sizeof(dma_addr_t) > 4) && (pdev->dma_mask == DMA_64BIT_MASK)) {
+                dma_64 = 1;
+                if (pci_set_dma_mask(pdev, DMA_32BIT_MASK))
+                        return -ENOMEM;
+        }
+        addr->virt = dma_alloc_coherent(dev, len, &addr->phys, gfp_mask);
+        if ((sizeof(dma_addr_t) > 4) && dma_64)
+                if (pci_set_dma_mask(pdev, DMA_64BIT_MASK))
+                        printk(KERN_WARNING "i2o: unable to set 64-bit DMA");
+        if (!addr->virt)
+                return -ENOMEM;
+        memset(addr->virt, 0, len);
+        addr->len = len;
+        return 0;
+};
+/**
+ *      i2o_dma_free - Free DMA memory
+ *      @dev: struct device pointer to the PCI device of the I2O controller
+ *      @addr: i2o_dma struct which contains the DMA buffer
+ *
+ *      Free a coherent DMA memory and set virtual address of addr to NULL.
+ */
+static inline void i2o_dma_free(struct device *dev, struct i2o_dma *addr)
+{
+        if (addr->virt) {
+                if (addr->phys)
+                        dma_free_coherent(dev, addr->len, addr->virt,
+                                          addr->phys);
+                else
+                        kfree(addr->virt);
+                addr->virt = NULL;
+        }
+};
+/**
+ *      i2o_dma_realloc - Realloc DMA memory
+ *      @dev: struct device pointer to the PCI device of the I2O controller
+ *      @addr: pointer to a i2o_dma struct DMA buffer
+ *      @len: new length of memory
+ *      @gfp_mask: GFP mask
+ *
+ *      If there was something allocated in the addr, free it first. If len > 0
+ *      than try to allocate it and write the addresses back to the addr
+ *      structure. If len == 0 set the virtual address to NULL.
+ *
+ *      Returns the 0 on success or negative error code on failure.
+ */
+static inline int i2o_dma_realloc(struct device *dev, struct i2o_dma *addr,
+                                  size_t len, unsigned int gfp_mask)
+{
+        i2o_dma_free(dev, addr);
+        if (len)
+                return i2o_dma_alloc(dev, addr, len, gfp_mask);
+        return 0;
+};
 /* I2O driver (OSM) functions */
 extern int i2o_driver_register(struct i2o_driver *);
 extern void i2o_driver_unregister(struct i2o_driver *);
@@ -385,49 +629,11 @@ extern int i2o_device_claim_release(struct i2o_device *);
 /* Exec OSM functions */
 extern int i2o_exec_lct_get(struct i2o_controller *);
-/* device to i2o_device and driver to i2o_driver convertion functions */
+/* device / driver / kobject conversion functions */
 #define to_i2o_driver(drv) container_of(drv,struct i2o_driver, driver)
 #define to_i2o_device(dev) container_of(dev, struct i2o_device, device)
+#define to_i2o_controller(dev) container_of(dev, struct i2o_controller, device)
-/*
+#define kobj_to_i2o_device(kobj) to_i2o_device(container_of(kobj, struct device, kobj))
- *      Messenger inlines
- */
-static inline u32 I2O_POST_READ32(struct i2o_controller *c)
-{
-        rmb();
-        return readl(c->post_port);
-};
-static inline void I2O_POST_WRITE32(struct i2o_controller *c, u32 val)
-{
-        wmb();
-        writel(val, c->post_port);
-};
-static inline u32 I2O_REPLY_READ32(struct i2o_controller *c)
-{
-        rmb();
-        return readl(c->reply_port);
-};
-static inline void I2O_REPLY_WRITE32(struct i2o_controller *c, u32 val)
-{
-        wmb();
-        writel(val, c->reply_port);
-};
-static inline u32 I2O_IRQ_READ32(struct i2o_controller *c)
-{
-        rmb();
-        return readl(c->irq_mask);
-};
-static inline void I2O_IRQ_WRITE32(struct i2o_controller *c, u32 val)
-{
-        wmb();
-        writel(val, c->irq_mask);
-        wmb();
-};
 /**
 *      i2o_msg_get - obtain an I2O message from the IOP
@@ -443,11 +649,11 @@ static inline void I2O_IRQ_WRITE32(struct i2o_controller *c, u32 val)
 *      available returns I2O_QUEUE_EMPTY and msg is leaved untouched.
 */
 static inline u32 i2o_msg_get(struct i2o_controller *c,
-                              struct i2o_message __iomem **msg)
+                              struct i2o_message __iomem ** msg)
 {
-        u32 m;
+        u32 m = readl(c->in_port);
-        if ((m = I2O_POST_READ32(c)) != I2O_QUEUE_EMPTY)
+        if (m != I2O_QUEUE_EMPTY)
                *msg = c->in_queue.virt + m;
        return m;
@@ -462,7 +668,7 @@ static inline u32 i2o_msg_get(struct i2o_controller *c,
 */
 static inline void i2o_msg_post(struct i2o_controller *c, u32 m)
 {
-        I2O_POST_WRITE32(c, m);
+        writel(m, c->in_port);
 };
 /**
@@ -491,12 +697,10 @@ static inline int i2o_msg_post_wait(struct i2o_controller *c, u32 m,
 *      The I2O controller must be informed that the reply message is not needed
 *      anymore. If you forget to flush the reply, the message frame can't be
 *      used by the controller anymore and is therefore lost.
- *
- *      FIXME: is there a timeout after which the controller reuse the message?
 */
 static inline void i2o_flush_reply(struct i2o_controller *c, u32 m)
 {
-        I2O_REPLY_WRITE32(c, m);
+        writel(m, c->out_port);
 };
 /**
@@ -530,97 +734,13 @@ static inline struct i2o_message *i2o_msg_out_to_virt(struct i2o_controller *c,
 *      work for receive side messages as they are kmalloc objects
 *      in a different pool.
 */
-static inline struct i2o_message __iomem *i2o_msg_in_to_virt(struct i2o_controller *c,
+static inline struct i2o_message __iomem *i2o_msg_in_to_virt(struct
-                                                     u32 m)
+                                                             i2o_controller *c,
+                                                             u32 m)
 {
        return c->in_queue.virt + m;
 };
-/**
- *      i2o_dma_alloc - Allocate DMA memory
- *      @dev: struct device pointer to the PCI device of the I2O controller
- *      @addr: i2o_dma struct which should get the DMA buffer
- *      @len: length of the new DMA memory
- *      @gfp_mask: GFP mask
- *
- *      Allocate a coherent DMA memory and write the pointers into addr.
- *
- *      Returns 0 on success or -ENOMEM on failure.
- */
-static inline int i2o_dma_alloc(struct device *dev, struct i2o_dma *addr,
-                                size_t len, unsigned int gfp_mask)
-{
-        addr->virt = dma_alloc_coherent(dev, len, &addr->phys, gfp_mask);
-        if (!addr->virt)
-                return -ENOMEM;
-        memset(addr->virt, 0, len);
-        addr->len = len;
-        return 0;
-};
-/**
- *      i2o_dma_free - Free DMA memory
- *      @dev: struct device pointer to the PCI device of the I2O controller
- *      @addr: i2o_dma struct which contains the DMA buffer
- *
- *      Free a coherent DMA memory and set virtual address of addr to NULL.
- */
-static inline void i2o_dma_free(struct device *dev, struct i2o_dma *addr)
-{
-        if (addr->virt) {
-                if (addr->phys)
-                        dma_free_coherent(dev, addr->len, addr->virt,
-                                          addr->phys);
-                else
-                        kfree(addr->virt);
-                addr->virt = NULL;
-        }
-};
-/**
- *      i2o_dma_map - Map the memory to DMA
- *      @dev: struct device pointer to the PCI device of the I2O controller
- *      @addr: i2o_dma struct which should be mapped
- *
- *      Map the memory in addr->virt to coherent DMA memory and write the
- *      physical address into addr->phys.
- *
- *      Returns 0 on success or -ENOMEM on failure.
- */
-static inline int i2o_dma_map(struct device *dev, struct i2o_dma *addr)
-{
-        if (!addr->virt)
-                return -EFAULT;
-        if (!addr->phys)
-                addr->phys = dma_map_single(dev, addr->virt, addr->len,
-                                            DMA_BIDIRECTIONAL);
-        if (!addr->phys)
-                return -ENOMEM;
-        return 0;
-};
-/**
- *      i2o_dma_unmap - Unmap the DMA memory
- *      @dev: struct device pointer to the PCI device of the I2O controller
- *      @addr: i2o_dma struct which should be unmapped
- *
- *      Unmap the memory in addr->virt from DMA memory.
- */
-static inline void i2o_dma_unmap(struct device *dev, struct i2o_dma *addr)
-{
-        if (!addr->virt)
-                return;
-        if (addr->phys) {
-                dma_unmap_single(dev, addr->phys, addr->len, DMA_BIDIRECTIONAL);
-                addr->phys = 0;
-        }
-};
 /*
 *      Endian handling wrapped into the macro - keeps the core code
 *      cleaner.
@@ -773,6 +893,14 @@ extern void i2o_debug_state(struct i2o_controller *c);
 #define I2O_CMD_SCSI_BUSRESET           0x27
 /*
+ * Bus Adapter Class
+ */
+#define I2O_CMD_BUS_ADAPTER_RESET       0x85
+#define I2O_CMD_BUS_RESET               0x87
+#define I2O_CMD_BUS_SCAN                0x89
+#define I2O_CMD_BUS_QUIESCE             0x8b
+/*
 * Random Block Storage Class
 */
 #define I2O_CMD_BLOCK_READ              0x30
@@ -784,7 +912,7 @@ extern void i2o_debug_state(struct i2o_controller *c);
 #define I2O_CMD_BLOCK_MEJECT            0x43
 #define I2O_CMD_BLOCK_POWER             0x70
-#define I2O_PRIVATE_MSG                 0xFF
+#define I2O_CMD_PRIVATE                 0xFF
 /* Command status values  */
@@ -922,7 +1050,7 @@ extern void i2o_debug_state(struct i2o_controller *c);
 #define I2OVER15        0x0001
 #define I2OVER20        0x0002
-/* Default is 1.5, FIXME: Need support for both 1.5 and 2.0 */
+/* Default is 1.5 */
 #define I2OVERSION      I2OVER15
 #define SGL_OFFSET_0    I2OVERSION
@@ -933,9 +1061,9 @@ extern void i2o_debug_state(struct i2o_controller *c);
 #define SGL_OFFSET_8    (0x0080 | I2OVERSION)
 #define SGL_OFFSET_9    (0x0090 | I2OVERSION)
 #define SGL_OFFSET_10   (0x00A0 | I2OVERSION)
+#define SGL_OFFSET_11   (0x00B0 | I2OVERSION)
-#define TRL_OFFSET_5    (0x0050 | I2OVERSION)
+#define SGL_OFFSET_12   (0x00C0 | I2OVERSION)
-#define TRL_OFFSET_6    (0x0060 | I2OVERSION)
+#define SGL_OFFSET(x)   (((x)<<4) | I2OVERSION)
 /* Transaction Reply Lists (TRL) Control Word structure */
 #define TRL_SINGLE_FIXED_LENGTH         0x00
@@ -962,17 +1090,13 @@ extern void i2o_debug_state(struct i2o_controller *c);
 #define ELEVEN_WORD_MSG_SIZE    0x000B0000
 #define I2O_MESSAGE_SIZE(x)     ((x)<<16)
-/* Special TID Assignments */
+/* special TID assignments */
 #define ADAPTER_TID             0
 #define HOST_TID                1
-#define MSG_FRAME_SIZE          128     /* i2o_scsi assumes >= 32 */
+/* outbound queue defines */
-#define REPLY_FRAME_SIZE        17
+#define I2O_MAX_OUTBOUND_MSG_FRAMES     128
-#define SG_TABLESIZE            30
+#define I2O_OUTBOUND_MSG_FRAME_SIZE     128     /* in 32-bit words */
-#define NMBR_MSG_FRAMES         128
-#define MSG_POOL_SIZE           (MSG_FRAME_SIZE*NMBR_MSG_FRAMES*sizeof(u32))
 #define I2O_POST_WAIT_OK        0
 #define I2O_POST_WAIT_TIMEOUT   -ETIMEDOUT
@@ -993,11 +1117,10 @@ extern void i2o_debug_state(struct i2o_controller *c);
 #define I2O_HRT_GET_TRIES               3
 #define I2O_LCT_GET_TRIES               3
-/* request queue sizes */
+/* defines for max_sectors and max_phys_segments */
 #define I2O_MAX_SECTORS                 1024
-#define I2O_MAX_SEGMENTS                128
+#define I2O_MAX_SECTORS_LIMITED         256
+#define I2O_MAX_PHYS_SEGMENTS           MAX_PHYS_SEGMENTS
-#define I2O_REQ_MEMPOOL_SIZE            32
 #endif                          /* __KERNEL__ */
 #endif                          /* _I2O_H */
diff --git a/include/linux/ide.h b/include/linux/ide.h
index 336d6e509f59..a6dbb51ecd7b 100644
--- a/include/linux/ide.h
+++ b/include/linux/ide.h
@@ -917,7 +917,7 @@ typedef struct hwif_s {
        unsigned dma;
        void (*led_act)(void *data, int rw);
-} ide_hwif_t;
+} ____cacheline_maxaligned_in_smp ide_hwif_t;
 /*
 *  internal ide interrupt handler type
@@ -1501,4 +1501,10 @@ extern struct bus_type ide_bus_type;
 #define ide_id_has_flush_cache_ext(id)  \
        (((id)->cfs_enable_2 & 0x2400) == 0x2400)
+static inline int hwif_to_node(ide_hwif_t *hwif)
+{
+        struct pci_dev *dev = hwif->pci_dev;
+        return dev ? pcibus_to_node(dev->bus) : -1;
+}
 #endif /* _IDE_H */
diff --git a/include/linux/if_bonding.h b/include/linux/if_bonding.h
index 57024ce2c74f..84598fa2e9de 100644
--- a/include/linux/if_bonding.h
+++ b/include/linux/if_bonding.h
@@ -35,6 +35,9 @@
 *
 * 2003/12/01 - Shmulik Hen <shmulik.hen at intel dot com>
 *      - Code cleanup and style changes
+ *
+ * 2005/05/05 - Jason Gabler <jygabler at lbl dot gov>
+ *      - added definitions for various XOR hashing policies
 */
 #ifndef _LINUX_IF_BONDING_H
@@ -80,6 +83,10 @@
 #define BOND_DEFAULT_MAX_BONDS  1   /* Default maximum number of devices to support */
+/* hashing types */
+#define BOND_XMIT_POLICY_LAYER2         0 /* layer 2 (MAC only), default */
+#define BOND_XMIT_POLICY_LAYER34        1 /* layer 3+4 (IP ^ MAC) */
 typedef struct ifbond {
        __s32 bond_mode;
        __s32 num_slaves;
diff --git a/include/linux/if_shaper.h b/include/linux/if_shaper.h
index 004e6f09a6e2..68c896a36a34 100644
--- a/include/linux/if_shaper.h
+++ b/include/linux/if_shaper.h
@@ -23,7 +23,7 @@ struct shaper
        __u32 shapeclock;
        unsigned long recovery; /* Time we can next clock a packet out on
                                   an empty queue */
-        struct semaphore sem;
+        spinlock_t lock;
        struct net_device_stats stats;
        struct net_device *dev;
        int  (*hard_start_xmit) (struct sk_buff *skb,
diff --git a/include/linux/igmp.h b/include/linux/igmp.h
index 390e760a96d3..0c31ef0b5bad 100644
--- a/include/linux/igmp.h
+++ b/include/linux/igmp.h
@@ -148,7 +148,6 @@ struct ip_sf_socklist
 struct ip_mc_socklist
 {
        struct ip_mc_socklist   *next;
-        int                     count;
        struct ip_mreqn         multi;
        unsigned int            sfmode;         /* MCAST_{INCLUDE,EXCLUDE} */
        struct ip_sf_socklist   *sflist;
diff --git a/include/linux/in6.h b/include/linux/in6.h
index f8256c582845..dcf5720ffcbb 100644
--- a/include/linux/in6.h
+++ b/include/linux/in6.h
@@ -156,7 +156,7 @@ struct in6_flowlabel_req
 #define IPV6_CHECKSUM           7
 #define IPV6_HOPLIMIT           8
 #define IPV6_NEXTHOP            9
-#define IPV6_AUTHHDR            10
+#define IPV6_AUTHHDR            10      /* obsolete */
 #define IPV6_FLOWINFO           11
 #define IPV6_UNICAST_HOPS       16
diff --git a/include/linux/init.h b/include/linux/init.h
index 05c83e0521ca..59008c3826cf 100644
--- a/include/linux/init.h
+++ b/include/linux/init.h
@@ -229,6 +229,18 @@ void __init parse_early_param(void);
 #define __devexitdata __exitdata
 #endif
+#ifdef CONFIG_HOTPLUG_CPU
+#define __cpuinit
+#define __cpuinitdata
+#define __cpuexit
+#define __cpuexitdata
+#else
+#define __cpuinit       __init
+#define __cpuinitdata __initdata
+#define __cpuexit __exit
+#define __cpuexitdata   __exitdata
+#endif
 /* Functions marked as __devexit may be discarded at kernel link time, depending
   on config options.  Newer versions of binutils detect references from
   retained sections to discarded sections and flag an error.  Pointers to
diff --git a/include/linux/init_task.h b/include/linux/init_task.h
index a6a8c1a38d5e..c727c195a91a 100644
--- a/include/linux/init_task.h
+++ b/include/linux/init_task.h
@@ -81,6 +81,7 @@ extern struct group_info init_groups;
        .mm             = NULL,                                         \
        .active_mm      = &init_mm,                                     \
        .run_list       = LIST_HEAD_INIT(tsk.run_list),                 \
+        .ioprio         = 0,                                            \
        .time_slice     = HZ,                                           \
        .tasks          = LIST_HEAD_INIT(tsk.tasks),                    \
        .ptrace_children= LIST_HEAD_INIT(tsk.ptrace_children),          \
@@ -108,9 +109,9 @@ extern struct group_info init_groups;
        .blocked        = {{0}},                                        \
        .alloc_lock     = SPIN_LOCK_UNLOCKED,                           \
        .proc_lock      = SPIN_LOCK_UNLOCKED,                           \
-        .switch_lock    = SPIN_LOCK_UNLOCKED,                           \
        .journal_info   = NULL,                                         \
        .cpu_timers     = INIT_CPU_TIMERS(tsk.cpu_timers),              \
+        .fs_excl        = ATOMIC_INIT(0),                               \
 }
diff --git a/include/linux/inotify.h b/include/linux/inotify.h
new file mode 100644
index 000000000000..93bb3afe646b
--- /dev/null
+++ b/include/linux/inotify.h
@@ -0,0 +1,110 @@
+/*
+ * Inode based directory notification for Linux
+ *
+ * Copyright (C) 2005 John McCutchan
+ */
+#ifndef _LINUX_INOTIFY_H
+#define _LINUX_INOTIFY_H
+#include <linux/types.h>
+/*
+ * struct inotify_event - structure read from the inotify device for each event
+ *
+ * When you are watching a directory, you will receive the filename for events
+ * such as IN_CREATE, IN_DELETE, IN_OPEN, IN_CLOSE, ..., relative to the wd.
+ */
+struct inotify_event {
+        __s32           wd;             /* watch descriptor */
+        __u32           mask;           /* watch mask */
+        __u32           cookie;         /* cookie to synchronize two events */
+        __u32           len;            /* length (including nulls) of name */
+        char            name[0];        /* stub for possible name */
+};
+/* the following are legal, implemented events that user-space can watch for */
+#define IN_ACCESS               0x00000001      /* File was accessed */
+#define IN_MODIFY               0x00000002      /* File was modified */
+#define IN_ATTRIB               0x00000004      /* Metadata changed */
+#define IN_CLOSE_WRITE          0x00000008      /* Writtable file was closed */
+#define IN_CLOSE_NOWRITE        0x00000010      /* Unwrittable file closed */
+#define IN_OPEN                 0x00000020      /* File was opened */
+#define IN_MOVED_FROM           0x00000040      /* File was moved from X */
+#define IN_MOVED_TO             0x00000080      /* File was moved to Y */
+#define IN_CREATE               0x00000100      /* Subfile was created */
+#define IN_DELETE               0x00000200      /* Subfile was deleted */
+#define IN_DELETE_SELF          0x00000400      /* Self was deleted */
+#define IN_MOVE_SELF            0x00000800      /* Self was moved */
+/* the following are legal events.  they are sent as needed to any watch */
+#define IN_UNMOUNT              0x00002000      /* Backing fs was unmounted */
+#define IN_Q_OVERFLOW           0x00004000      /* Event queued overflowed */
+#define IN_IGNORED              0x00008000      /* File was ignored */
+/* helper events */
+#define IN_CLOSE                (IN_CLOSE_WRITE | IN_CLOSE_NOWRITE) /* close */
+#define IN_MOVE                 (IN_MOVED_FROM | IN_MOVED_TO) /* moves */
+/* special flags */
+#define IN_ISDIR                0x40000000      /* event occurred against dir */
+#define IN_ONESHOT              0x80000000      /* only send event once */
+/*
+ * All of the events - we build the list by hand so that we can add flags in
+ * the future and not break backward compatibility.  Apps will get only the
+ * events that they originally wanted.  Be sure to add new events here!
+ */
+#define IN_ALL_EVENTS   (IN_ACCESS | IN_MODIFY | IN_ATTRIB | IN_CLOSE_WRITE | \
+                         IN_CLOSE_NOWRITE | IN_OPEN | IN_MOVED_FROM | \
+                         IN_MOVED_TO | IN_DELETE | IN_CREATE | IN_DELETE_SELF | \
+                         IN_MOVE_SELF)
+#ifdef __KERNEL__
+#include <linux/dcache.h>
+#include <linux/fs.h>
+#include <linux/config.h>
+#ifdef CONFIG_INOTIFY
+extern void inotify_inode_queue_event(struct inode *, __u32, __u32,
+                                      const char *);
+extern void inotify_dentry_parent_queue_event(struct dentry *, __u32, __u32,
+                                              const char *);
+extern void inotify_unmount_inodes(struct list_head *);
+extern void inotify_inode_is_dead(struct inode *);
+extern u32 inotify_get_cookie(void);
+#else
+static inline void inotify_inode_queue_event(struct inode *inode,
+                                             __u32 mask, __u32 cookie,
+                                             const char *filename)
+{
+}
+static inline void inotify_dentry_parent_queue_event(struct dentry *dentry,
+                                                     __u32 mask, __u32 cookie,
+                                                     const char *filename)
+{
+}
+static inline void inotify_unmount_inodes(struct list_head *list)
+{
+}
+static inline void inotify_inode_is_dead(struct inode *inode)
+{
+}
+static inline u32 inotify_get_cookie(void)
+{
+        return 0;
+}
+#endif  /* CONFIG_INOTIFY */
+#endif  /* __KERNEL __ */
+#endif  /* _LINUX_INOTIFY_H */
diff --git a/include/linux/input.h b/include/linux/input.h
index 9d9598ed760d..bdc53c6cc962 100644
--- a/include/linux/input.h
+++ b/include/linux/input.h
@@ -811,9 +811,9 @@ struct input_dev {
        void *private;
-        char *name;
+        const char *name;
-        char *phys;
+        const char *phys;
-        char *uniq;
+        const char *uniq;
        struct input_id id;
        unsigned long evbit[NBITS(EV_MAX)];
@@ -859,6 +859,10 @@ struct input_dev {
        int (*erase_effect)(struct input_dev *dev, int effect_id);
        struct input_handle *grab;
+        struct semaphore sem;   /* serializes open and close operations */
+        unsigned int users;
        struct device *dev;
        struct list_head        h_list;
diff --git a/include/linux/ioprio.h b/include/linux/ioprio.h
new file mode 100644
index 000000000000..88d5961f7a3f
--- /dev/null
+++ b/include/linux/ioprio.h
@@ -0,0 +1,85 @@
+#ifndef IOPRIO_H
+#define IOPRIO_H
+#include <linux/sched.h>
+/*
+ * Gives us 8 prio classes with 13-bits of data for each class
+ */
+#define IOPRIO_BITS             (16)
+#define IOPRIO_CLASS_SHIFT      (13)
+#define IOPRIO_PRIO_MASK        ((1UL << IOPRIO_CLASS_SHIFT) - 1)
+#define IOPRIO_PRIO_CLASS(mask) ((mask) >> IOPRIO_CLASS_SHIFT)
+#define IOPRIO_PRIO_DATA(mask)  ((mask) & IOPRIO_PRIO_MASK)
+#define IOPRIO_PRIO_VALUE(class, data)  (((class) << IOPRIO_CLASS_SHIFT) | data)
+#define ioprio_valid(mask)      (IOPRIO_PRIO_CLASS((mask)) != IOPRIO_CLASS_NONE)
+/*
+ * These are the io priority groups as implemented by CFQ. RT is the realtime
+ * class, it always gets premium service. BE is the best-effort scheduling
+ * class, the default for any process. IDLE is the idle scheduling class, it
+ * is only served when no one else is using the disk.
+ */
+enum {
+        IOPRIO_CLASS_NONE,
+        IOPRIO_CLASS_RT,
+        IOPRIO_CLASS_BE,
+        IOPRIO_CLASS_IDLE,
+};
+/*
+ * 8 best effort priority levels are supported
+ */
+#define IOPRIO_BE_NR    (8)
+enum {
+        IOPRIO_WHO_PROCESS = 1,
+        IOPRIO_WHO_PGRP,
+        IOPRIO_WHO_USER,
+};
+/*
+ * if process has set io priority explicitly, use that. if not, convert
+ * the cpu scheduler nice value to an io priority
+ */
+#define IOPRIO_NORM     (4)
+static inline int task_ioprio(struct task_struct *task)
+{
+        WARN_ON(!ioprio_valid(task->ioprio));
+        return IOPRIO_PRIO_DATA(task->ioprio);
+}
+static inline int task_nice_ioprio(struct task_struct *task)
+{
+        return (task_nice(task) + 20) / 5;
+}
+/*
+ * For inheritance, return the highest of the two given priorities
+ */
+static inline int ioprio_best(unsigned short aprio, unsigned short bprio)
+{
+        unsigned short aclass = IOPRIO_PRIO_CLASS(aprio);
+        unsigned short bclass = IOPRIO_PRIO_CLASS(bprio);
+        if (!ioprio_valid(aprio))
+                return bprio;
+        if (!ioprio_valid(bprio))
+                return aprio;
+        if (aclass == IOPRIO_CLASS_NONE)
+                aclass = IOPRIO_CLASS_BE;
+        if (bclass == IOPRIO_CLASS_NONE)
+                bclass = IOPRIO_CLASS_BE;
+        if (aclass == bclass)
+                return min(aprio, bprio);
+        if (aclass > bclass)
+                return bprio;
+        else
+                return aprio;
+}
+#endif
diff --git a/include/linux/ipmi.h b/include/linux/ipmi.h
index 2ec265e1045f..596ca6130159 100644
--- a/include/linux/ipmi.h
+++ b/include/linux/ipmi.h
@@ -209,6 +209,11 @@ struct kernel_ipmi_msg
 #include <linux/list.h>
 #include <linux/module.h>
+#ifdef CONFIG_PROC_FS
+#include <linux/proc_fs.h>
+extern struct proc_dir_entry *proc_ipmi_root;
+#endif /* CONFIG_PROC_FS */
 /* Opaque type for a IPMI message user.  One of these is needed to
   send and receive messages. */
 typedef struct ipmi_user *ipmi_user_t;
diff --git a/include/linux/irq.h b/include/linux/irq.h
index 7fc1022be9ee..069d3b84d311 100644
--- a/include/linux/irq.h
+++ b/include/linux/irq.h
@@ -85,10 +85,10 @@ extern int no_irq_affinity;
 extern int noirqdebug_setup(char *str);
 extern fastcall int handle_IRQ_event(unsigned int irq, struct pt_regs *regs,
-                                       struct irqaction *action);
+                                        struct irqaction *action);
 extern fastcall unsigned int __do_IRQ(unsigned int irq, struct pt_regs *regs);
-extern void note_interrupt(unsigned int irq, irq_desc_t *desc, int action_ret);
+extern void note_interrupt(unsigned int irq, irq_desc_t *desc,
-extern void report_bad_irq(unsigned int irq, irq_desc_t *desc, int action_ret);
+                                        int action_ret, struct pt_regs *regs);
 extern int can_request_irq(unsigned int irq, unsigned long irqflags);
 extern void init_irq_proc(void);
diff --git a/include/linux/jffs2_fs_sb.h b/include/linux/jffs2_fs_sb.h
index 4afc8d8c2e9e..1e21546622de 100644
--- a/include/linux/jffs2_fs_sb.h
+++ b/include/linux/jffs2_fs_sb.h
@@ -1,4 +1,4 @@
-/* $Id: jffs2_fs_sb.h,v 1.48 2004/11/20 10:41:12 dwmw2 Exp $ */
+/* $Id: jffs2_fs_sb.h,v 1.52 2005/05/19 16:12:17 gleixner Exp $ */
 #ifndef _JFFS2_FS_SB
 #define _JFFS2_FS_SB
@@ -14,7 +14,8 @@
 #include <linux/rwsem.h>
 #define JFFS2_SB_FLAG_RO 1
-#define JFFS2_SB_FLAG_MOUNTING 2
+#define JFFS2_SB_FLAG_SCANNING 2 /* Flash scanning is in progress */
+#define JFFS2_SB_FLAG_BUILDING 4 /* File system building is in progress */
 struct jffs2_inodirty;
@@ -31,7 +32,7 @@ struct jffs2_sb_info {
        unsigned int flags;
        struct task_struct *gc_task;    /* GC task struct */
-        struct semaphore gc_thread_start; /* GC thread start mutex */
+        struct completion gc_thread_start; /* GC thread start completion */
        struct completion gc_thread_exit; /* GC thread exit completion port */
        struct semaphore alloc_sem;     /* Used to protect all the following 
@@ -94,7 +95,7 @@ struct jffs2_sb_info {
           to an obsoleted node. I don't like this. Alternatives welcomed. */
        struct semaphore erase_free_sem;
-#if defined CONFIG_JFFS2_FS_NAND || defined CONFIG_JFFS2_FS_NOR_ECC
+#ifdef CONFIG_JFFS2_FS_WRITEBUFFER
        /* Write-behind buffer for NAND flash */
        unsigned char *wbuf;
        uint32_t wbuf_ofs;
diff --git a/include/linux/joystick.h b/include/linux/joystick.h
index b7e0ab622cd7..06b9af77eb7f 100644
--- a/include/linux/joystick.h
+++ b/include/linux/joystick.h
@@ -111,18 +111,35 @@ struct js_corr {
 #define JS_SET_ALL              8
 struct JS_DATA_TYPE {
-        int buttons;
+        __s32 buttons;
-        int x;
+        __s32 x;
-        int y;
+        __s32 y;
 };
-struct JS_DATA_SAVE_TYPE {
+struct JS_DATA_SAVE_TYPE_32 {
-        int JS_TIMEOUT;
+        __s32 JS_TIMEOUT;
-        int BUSY;
+        __s32 BUSY;
-        long JS_EXPIRETIME;
+        __s32 JS_EXPIRETIME;
-        long JS_TIMELIMIT;
+        __s32 JS_TIMELIMIT;
        struct JS_DATA_TYPE JS_SAVE;
        struct JS_DATA_TYPE JS_CORR;
 };
+struct JS_DATA_SAVE_TYPE_64 {
+        __s32 JS_TIMEOUT;
+        __s32 BUSY;
+        __s64 JS_EXPIRETIME;
+        __s64 JS_TIMELIMIT;
+        struct JS_DATA_TYPE JS_SAVE;
+        struct JS_DATA_TYPE JS_CORR;
+};
+#if BITS_PER_LONG == 64
+#define JS_DATA_SAVE_TYPE JS_DATA_SAVE_TYPE_64
+#elif BITS_PER_LONG == 32
+#define JS_DATA_SAVE_TYPE JS_DATA_SAVE_TYPE_32
+#else
+#error Unexpected BITS_PER_LONG
+#endif
 #endif /* _LINUX_JOYSTICK_H */
diff --git a/include/linux/kernel.h b/include/linux/kernel.h
index e25b97062ce1..687ba8c9973d 100644
--- a/include/linux/kernel.h
+++ b/include/linux/kernel.h
@@ -58,15 +58,23 @@ struct completion;
 * be biten later when the calling function happens to sleep when it is not
 * supposed to.
 */
+#ifdef CONFIG_PREEMPT_VOLUNTARY
+extern int cond_resched(void);
+# define might_resched() cond_resched()
+#else
+# define might_resched() do { } while (0)
+#endif
 #ifdef CONFIG_DEBUG_SPINLOCK_SLEEP
-#define might_sleep() __might_sleep(__FILE__, __LINE__)
+  void __might_sleep(char *file, int line);
-#define might_sleep_if(cond) do { if (unlikely(cond)) might_sleep(); } while (0)
+# define might_sleep() \
-void __might_sleep(char *file, int line);
+        do { __might_sleep(__FILE__, __LINE__); might_resched(); } while (0)
 #else
-#define might_sleep() do {} while(0)
+# define might_sleep() do { might_resched(); } while (0)
-#define might_sleep_if(cond) do {} while (0)
 #endif
+#define might_sleep_if(cond) do { if (unlikely(cond)) might_sleep(); } while (0)
 #define abs(x) ({                               \
                int __x = (x);                  \
                (__x < 0) ? -__x : __x;         \
diff --git a/include/linux/kexec.h b/include/linux/kexec.h
new file mode 100644
index 000000000000..c8468472aec0
--- /dev/null
+++ b/include/linux/kexec.h
@@ -0,0 +1,135 @@
+#ifndef LINUX_KEXEC_H
+#define LINUX_KEXEC_H
+#ifdef CONFIG_KEXEC
+#include <linux/types.h>
+#include <linux/list.h>
+#include <linux/linkage.h>
+#include <linux/compat.h>
+#include <asm/kexec.h>
+/* Verify architecture specific macros are defined */
+#ifndef KEXEC_SOURCE_MEMORY_LIMIT
+#error KEXEC_SOURCE_MEMORY_LIMIT not defined
+#endif
+#ifndef KEXEC_DESTINATION_MEMORY_LIMIT
+#error KEXEC_DESTINATION_MEMORY_LIMIT not defined
+#endif
+#ifndef KEXEC_CONTROL_MEMORY_LIMIT
+#error KEXEC_CONTROL_MEMORY_LIMIT not defined
+#endif
+#ifndef KEXEC_CONTROL_CODE_SIZE
+#error KEXEC_CONTROL_CODE_SIZE not defined
+#endif
+#ifndef KEXEC_ARCH
+#error KEXEC_ARCH not defined
+#endif
+/*
+ * This structure is used to hold the arguments that are used when loading
+ * kernel binaries.
+ */
+typedef unsigned long kimage_entry_t;
+#define IND_DESTINATION  0x1
+#define IND_INDIRECTION  0x2
+#define IND_DONE         0x4
+#define IND_SOURCE       0x8
+#define KEXEC_SEGMENT_MAX 8
+struct kexec_segment {
+        void __user *buf;
+        size_t bufsz;
+        unsigned long mem;      /* User space sees this as a (void *) ... */
+        size_t memsz;
+};
+#ifdef CONFIG_COMPAT
+struct compat_kexec_segment {
+        compat_uptr_t buf;
+        compat_size_t bufsz;
+        compat_ulong_t mem;     /* User space sees this as a (void *) ... */
+        compat_size_t memsz;
+};
+#endif
+struct kimage {
+        kimage_entry_t head;
+        kimage_entry_t *entry;
+        kimage_entry_t *last_entry;
+        unsigned long destination;
+        unsigned long start;
+        struct page *control_code_page;
+        unsigned long nr_segments;
+        struct kexec_segment segment[KEXEC_SEGMENT_MAX];
+        struct list_head control_pages;
+        struct list_head dest_pages;
+        struct list_head unuseable_pages;
+        /* Address of next control page to allocate for crash kernels. */
+        unsigned long control_page;
+        /* Flags to indicate special processing */
+        unsigned int type : 1;
+#define KEXEC_TYPE_DEFAULT 0
+#define KEXEC_TYPE_CRASH   1
+};
+/* kexec interface functions */
+extern NORET_TYPE void machine_kexec(struct kimage *image) ATTRIB_NORET;
+extern int machine_kexec_prepare(struct kimage *image);
+extern void machine_kexec_cleanup(struct kimage *image);
+extern asmlinkage long sys_kexec_load(unsigned long entry,
+                                        unsigned long nr_segments,
+                                        struct kexec_segment __user *segments,
+                                        unsigned long flags);
+#ifdef CONFIG_COMPAT
+extern asmlinkage long compat_sys_kexec_load(unsigned long entry,
+                                unsigned long nr_segments,
+                                struct compat_kexec_segment __user *segments,
+                                unsigned long flags);
+#endif
+extern struct page *kimage_alloc_control_pages(struct kimage *image,
+                                                unsigned int order);
+extern void crash_kexec(struct pt_regs *);
+int kexec_should_crash(struct task_struct *);
+extern struct kimage *kexec_image;
+#define KEXEC_ON_CRASH  0x00000001
+#define KEXEC_ARCH_MASK 0xffff0000
+/* These values match the ELF architecture values.
+ * Unless there is a good reason that should continue to be the case.
+ */
+#define KEXEC_ARCH_DEFAULT ( 0 << 16)
+#define KEXEC_ARCH_386     ( 3 << 16)
+#define KEXEC_ARCH_X86_64  (62 << 16)
+#define KEXEC_ARCH_PPC     (20 << 16)
+#define KEXEC_ARCH_PPC64   (21 << 16)
+#define KEXEC_ARCH_IA_64   (50 << 16)
+#define KEXEC_ARCH_S390    (22 << 16)
+#define KEXEC_FLAGS    (KEXEC_ON_CRASH)  /* List of defined/legal kexec flags */
+/* Location of a reserved region to hold the crash kernel.
+ */
+extern struct resource crashk_res;
+#else /* !CONFIG_KEXEC */
+struct pt_regs;
+struct task_struct;
+static inline void crash_kexec(struct pt_regs *regs) { }
+static inline int kexec_should_crash(struct task_struct *p) { return 0; }
+#endif /* CONFIG_KEXEC */
+#endif /* LINUX_KEXEC_H */
diff --git a/include/linux/key-ui.h b/include/linux/key-ui.h
index 60cc7b762e78..cc326174a808 100644
--- a/include/linux/key-ui.h
+++ b/include/linux/key-ui.h
@@ -1,4 +1,4 @@
-/* key-ui.h: key userspace interface stuff for use by keyfs
+/* key-ui.h: key userspace interface stuff
 *
 * Copyright (C) 2004 Red Hat, Inc. All Rights Reserved.
 * Written by David Howells (dhowells@redhat.com)
@@ -31,8 +31,10 @@ extern spinlock_t key_serial_lock;
 * subscribed
 */
 struct keyring_list {
-        unsigned        maxkeys;        /* max keys this list can hold */
+        struct rcu_head rcu;            /* RCU deletion hook */
-        unsigned        nkeys;          /* number of keys currently held */
+        unsigned short  maxkeys;        /* max keys this list can hold */
+        unsigned short  nkeys;          /* number of keys currently held */
+        unsigned short  delkey;         /* key to be unlinked by RCU */
        struct key      *keys[0];
 };
@@ -82,8 +84,45 @@ static inline int key_any_permission(const struct key *key, key_perm_t perm)
        return kperm != 0;
 }
+static inline int key_task_groups_search(struct task_struct *tsk, gid_t gid)
+{
+        int ret;
+        task_lock(tsk);
+        ret = groups_search(tsk->group_info, gid);
+        task_unlock(tsk);
+        return ret;
+}
+static inline int key_task_permission(const struct key *key,
+                                      struct task_struct *context,
+                                      key_perm_t perm)
+{
+        key_perm_t kperm;
+        if (key->uid == context->fsuid) {
+                kperm = key->perm >> 16;
+        }
+        else if (key->gid != -1 &&
+                 key->perm & KEY_GRP_ALL && (
+                         key->gid == context->fsgid ||
+                         key_task_groups_search(context, key->gid)
+                         )
+                 ) {
+                kperm = key->perm >> 8;
+        }
+        else {
+                kperm = key->perm;
+        }
+        kperm = kperm & perm & KEY_ALL;
+        return kperm == perm;
+}
-extern struct key *lookup_user_key(key_serial_t id, int create, int part,
+extern struct key *lookup_user_key(struct task_struct *context,
+                                   key_serial_t id, int create, int partial,
                                   key_perm_t perm);
 extern long join_session_keyring(const char *name);
diff --git a/include/linux/key.h b/include/linux/key.h
index 6aa46d0e812f..970bbd916cf4 100644
--- a/include/linux/key.h
+++ b/include/linux/key.h
@@ -18,7 +18,7 @@
 #include <linux/types.h>
 #include <linux/list.h>
 #include <linux/rbtree.h>
-#include <linux/spinlock.h>
+#include <linux/rcupdate.h>
 #include <asm/atomic.h>
 #ifdef __KERNEL__
@@ -78,7 +78,6 @@ struct key {
        key_serial_t            serial;         /* key serial number */
        struct rb_node          serial_node;
        struct key_type         *type;          /* type of key */
-        rwlock_t                lock;           /* examination vs change lock */
        struct rw_semaphore     sem;            /* change vs change sem */
        struct key_user         *user;          /* owner of this key */
        time_t                  expiry;         /* time at which key expires (or 0) */
@@ -86,14 +85,10 @@ struct key {
        gid_t                   gid;
        key_perm_t              perm;           /* access permissions */
        unsigned short          quotalen;       /* length added to quota */
-        unsigned short          datalen;        /* payload data length */
+        unsigned short          datalen;        /* payload data length
-        unsigned short          flags;          /* status flags (change with lock writelocked) */
+                                                 * - may not match RCU dereferenced payload
-#define KEY_FLAG_INSTANTIATED   0x00000001      /* set if key has been instantiated */
+                                                 * - payload should contain own length
-#define KEY_FLAG_DEAD           0x00000002      /* set if key type has been deleted */
+                                                 */
-#define KEY_FLAG_REVOKED        0x00000004      /* set if key had been revoked */
-#define KEY_FLAG_IN_QUOTA       0x00000008      /* set if key consumes quota */
-#define KEY_FLAG_USER_CONSTRUCT 0x00000010      /* set if key is being constructed in userspace */
-#define KEY_FLAG_NEGATIVE       0x00000020      /* set if key is negative */
 #ifdef KEY_DEBUGGING
        unsigned                magic;
@@ -101,6 +96,14 @@ struct key {
 #define KEY_DEBUG_MAGIC_X       0xf8e9dacbu
 #endif
+        unsigned long           flags;          /* status flags (change with bitops) */
+#define KEY_FLAG_INSTANTIATED   0       /* set if key has been instantiated */
+#define KEY_FLAG_DEAD           1       /* set if key type has been deleted */
+#define KEY_FLAG_REVOKED        2       /* set if key had been revoked */
+#define KEY_FLAG_IN_QUOTA       3       /* set if key consumes quota */
+#define KEY_FLAG_USER_CONSTRUCT 4       /* set if key is being constructed in userspace */
+#define KEY_FLAG_NEGATIVE       5       /* set if key is negative */
        /* the description string
         * - this is used to match a key against search criteria
         * - this should be a printable string
@@ -196,10 +199,12 @@ extern int key_payload_reserve(struct key *key, size_t datalen);
 extern int key_instantiate_and_link(struct key *key,
                                    const void *data,
                                    size_t datalen,
-                                    struct key *keyring);
+                                    struct key *keyring,
+                                    struct key *instkey);
 extern int key_negate_and_link(struct key *key,
                               unsigned timeout,
-                               struct key *keyring);
+                               struct key *keyring,
+                               struct key *instkey);
 extern void key_revoke(struct key *key);
 extern void key_put(struct key *key);
@@ -242,14 +247,13 @@ extern struct key *keyring_search(struct key *keyring,
                                  struct key_type *type,
                                  const char *description);
-extern struct key *search_process_keyrings(struct key_type *type,
-                                           const char *description);
 extern int keyring_add_key(struct key *keyring,
                           struct key *key);
 extern struct key *key_lookup(key_serial_t id);
+extern void keyring_replace_payload(struct key *key, void *replacement);
 #define key_serial(key) ((key) ? (key)->serial : 0)
 /*
@@ -268,14 +272,22 @@ extern void key_fsuid_changed(struct task_struct *tsk);
 extern void key_fsgid_changed(struct task_struct *tsk);
 extern void key_init(void);
+#define __install_session_keyring(tsk, keyring)                 \
+({                                                              \
+        struct key *old_session = tsk->signal->session_keyring; \
+        tsk->signal->session_keyring = keyring;                 \
+        old_session;                                            \
+})
 #else /* CONFIG_KEYS */
 #define key_validate(k)                 0
 #define key_serial(k)                   0
-#define key_get(k)                      NULL
+#define key_get(k)                      ({ NULL; })
 #define key_put(k)                      do { } while(0)
 #define alloc_uid_keyring(u)            0
 #define switch_uid_keyring(u)           do { } while(0)
+#define __install_session_keyring(t, k) ({ NULL; })
 #define copy_keys(f,t)                  0
 #define copy_thread_group_keys(t)       0
 #define exit_keys(t)                    do { } while(0)
diff --git a/include/linux/keyctl.h b/include/linux/keyctl.h
index 381dedc370a3..8d7c59a29e09 100644
--- a/include/linux/keyctl.h
+++ b/include/linux/keyctl.h
@@ -20,6 +20,16 @@
 #define KEY_SPEC_USER_SESSION_KEYRING   -5      /* - key ID for UID-session keyring */
 #define KEY_SPEC_GROUP_KEYRING          -6      /* - key ID for GID-specific keyring */
+/* request-key default keyrings */
+#define KEY_REQKEY_DEFL_NO_CHANGE               -1
+#define KEY_REQKEY_DEFL_DEFAULT                 0
+#define KEY_REQKEY_DEFL_THREAD_KEYRING          1
+#define KEY_REQKEY_DEFL_PROCESS_KEYRING         2
+#define KEY_REQKEY_DEFL_SESSION_KEYRING         3
+#define KEY_REQKEY_DEFL_USER_KEYRING            4
+#define KEY_REQKEY_DEFL_USER_SESSION_KEYRING    5
+#define KEY_REQKEY_DEFL_GROUP_KEYRING           6
 /* keyctl commands */
 #define KEYCTL_GET_KEYRING_ID           0       /* ask for a keyring's ID */
 #define KEYCTL_JOIN_SESSION_KEYRING     1       /* join or start named session keyring */
@@ -35,5 +45,6 @@
 #define KEYCTL_READ                     11      /* read a key or keyring's contents */
 #define KEYCTL_INSTANTIATE              12      /* instantiate a partially constructed key */
 #define KEYCTL_NEGATE                   13      /* negate a partially constructed key */
+#define KEYCTL_SET_REQKEY_KEYRING       14      /* set default request-key keyring */
 #endif /*  _LINUX_KEYCTL_H */
diff --git a/include/linux/kmod.h b/include/linux/kmod.h
index 95d0e4b0814d..e4a231549407 100644
--- a/include/linux/kmod.h
+++ b/include/linux/kmod.h
@@ -19,6 +19,7 @@
 *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
+#include <linux/stddef.h>
 #include <linux/config.h>
 #include <linux/errno.h>
 #include <linux/compiler.h>
@@ -34,7 +35,17 @@ static inline int request_module(const char * name, ...) { return -ENOSYS; }
 #endif
 #define try_then_request_module(x, mod...) ((x) ?: (request_module(mod), (x)))
-extern int call_usermodehelper(char *path, char *argv[], char *envp[], int wait);
+struct key;
+extern int call_usermodehelper_keys(char *path, char *argv[], char *envp[],
+                                    struct key *session_keyring, int wait);
+static inline int
+call_usermodehelper(char *path, char **argv, char **envp, int wait)
+{
+        return call_usermodehelper_keys(path, argv, envp, NULL, wait);
+}
 extern void usermodehelper_init(void);
 #endif /* __LINUX_KMOD_H__ */
diff --git a/include/linux/kprobes.h b/include/linux/kprobes.h
index 99ddba5a4e00..e050fc2d4c26 100644
--- a/include/linux/kprobes.h
+++ b/include/linux/kprobes.h
@@ -25,27 +25,45 @@
 *              Rusty Russell).
 * 2004-July    Suparna Bhattacharya <suparna@in.ibm.com> added jumper probes
 *              interface to access function arguments.
+ * 2005-May     Hien Nguyen <hien@us.ibm.com> and Jim Keniston
+ *              <jkenisto@us.ibm.com>  and Prasanna S Panchamukhi
+ *              <prasanna@in.ibm.com> added function-return probes.
 */
 #include <linux/config.h>
 #include <linux/list.h>
 #include <linux/notifier.h>
 #include <linux/smp.h>
 #include <asm/kprobes.h>
+/* kprobe_status settings */
+#define KPROBE_HIT_ACTIVE       0x00000001
+#define KPROBE_HIT_SS           0x00000002
+#define KPROBE_REENTER          0x00000004
+#define KPROBE_HIT_SSDONE       0x00000008
 struct kprobe;
 struct pt_regs;
+struct kretprobe;
+struct kretprobe_instance;
 typedef int (*kprobe_pre_handler_t) (struct kprobe *, struct pt_regs *);
 typedef int (*kprobe_break_handler_t) (struct kprobe *, struct pt_regs *);
 typedef void (*kprobe_post_handler_t) (struct kprobe *, struct pt_regs *,
                                       unsigned long flags);
 typedef int (*kprobe_fault_handler_t) (struct kprobe *, struct pt_regs *,
                                       int trapnr);
+typedef int (*kretprobe_handler_t) (struct kretprobe_instance *,
+                                    struct pt_regs *);
 struct kprobe {
        struct hlist_node hlist;
        /* list of kprobes for multi-handler support */
        struct list_head list;
+        /*count the number of times this probe was temporarily disarmed */
+        unsigned long nmissed;
        /* location of the probe point */
        kprobe_opcode_t *addr;
@@ -85,6 +103,41 @@ struct jprobe {
        kprobe_opcode_t *entry; /* probe handling code to jump to */
 };
+#ifdef ARCH_SUPPORTS_KRETPROBES
+extern void arch_prepare_kretprobe(struct kretprobe *rp, struct pt_regs *regs);
+#else /* ARCH_SUPPORTS_KRETPROBES */
+static inline void arch_prepare_kretprobe(struct kretprobe *rp,
+                                        struct pt_regs *regs)
+{
+}
+#endif /* ARCH_SUPPORTS_KRETPROBES */
+/*
+ * Function-return probe -
+ * Note:
+ * User needs to provide a handler function, and initialize maxactive.
+ * maxactive - The maximum number of instances of the probed function that
+ * can be active concurrently.
+ * nmissed - tracks the number of times the probed function's return was
+ * ignored, due to maxactive being too low.
+ *
+ */
+struct kretprobe {
+        struct kprobe kp;
+        kretprobe_handler_t handler;
+        int maxactive;
+        int nmissed;
+        struct hlist_head free_instances;
+        struct hlist_head used_instances;
+};
+struct kretprobe_instance {
+        struct hlist_node uflist; /* either on free list or used list */
+        struct hlist_node hlist;
+        struct kretprobe *rp;
+        kprobe_opcode_t *ret_addr;
+        struct task_struct *task;
+};
 #ifdef CONFIG_KPROBES
 /* Locks kprobe: irq must be disabled */
 void lock_kprobes(void);
@@ -99,11 +152,17 @@ static inline int kprobe_running(void)
 extern int arch_prepare_kprobe(struct kprobe *p);
 extern void arch_copy_kprobe(struct kprobe *p);
+extern void arch_arm_kprobe(struct kprobe *p);
+extern void arch_disarm_kprobe(struct kprobe *p);
 extern void arch_remove_kprobe(struct kprobe *p);
+extern int arch_init_kprobes(void);
 extern void show_registers(struct pt_regs *regs);
+extern kprobe_opcode_t *get_insn_slot(void);
+extern void free_insn_slot(kprobe_opcode_t *slot);
 /* Get the kprobe at this addr (if any).  Must have called lock_kprobes */
 struct kprobe *get_kprobe(void *addr);
+struct hlist_head * kretprobe_inst_table_head(struct task_struct *tsk);
 int register_kprobe(struct kprobe *p);
 void unregister_kprobe(struct kprobe *p);
@@ -113,7 +172,14 @@ int register_jprobe(struct jprobe *p);
 void unregister_jprobe(struct jprobe *p);
 void jprobe_return(void);
-#else
+int register_kretprobe(struct kretprobe *rp);
+void unregister_kretprobe(struct kretprobe *rp);
+struct kretprobe_instance *get_free_rp_inst(struct kretprobe *rp);
+void add_rp_inst(struct kretprobe_instance *ri);
+void kprobe_flush_task(struct task_struct *tk);
+void recycle_rp_inst(struct kretprobe_instance *ri);
+#else /* CONFIG_KPROBES */
 static inline int kprobe_running(void)
 {
        return 0;
@@ -135,5 +201,15 @@ static inline void unregister_jprobe(struct jprobe *p)
 static inline void jprobe_return(void)
 {
 }
-#endif
+static inline int register_kretprobe(struct kretprobe *rp)
+{
+        return -ENOSYS;
+}
+static inline void unregister_kretprobe(struct kretprobe *rp)
+{
+}
+static inline void kprobe_flush_task(struct task_struct *tk)
+{
+}
+#endif                          /* CONFIG_KPROBES */
 #endif                          /* _LINUX_KPROBES_H */
diff --git a/include/linux/libps2.h b/include/linux/libps2.h
index 923bdbc6d9e4..a710bddda4eb 100644
--- a/include/linux/libps2.h
+++ b/include/linux/libps2.h
@@ -41,6 +41,7 @@ struct ps2dev {
 void ps2_init(struct ps2dev *ps2dev, struct serio *serio);
 int ps2_sendbyte(struct ps2dev *ps2dev, unsigned char byte, int timeout);
+void ps2_drain(struct ps2dev *ps2dev, int maxbytes, int timeout);
 int ps2_command(struct ps2dev *ps2dev, unsigned char *param, int command);
 int ps2_schedule_command(struct ps2dev *ps2dev, unsigned char *param, int command);
 int ps2_handle_ack(struct ps2dev *ps2dev, unsigned char data);
diff --git a/include/linux/list.h b/include/linux/list.h
index 399b51d17218..aab2db21b013 100644
--- a/include/linux/list.h
+++ b/include/linux/list.h
@@ -185,7 +185,7 @@ static inline void list_del(struct list_head *entry)
 * list_for_each_entry_rcu().
 *
 * Note that the caller is not permitted to immediately free
- * the newly deleted entry.  Instead, either synchronize_kernel()
+ * the newly deleted entry.  Instead, either synchronize_rcu()
 * or call_rcu() must be used to defer freeing until an RCU
 * grace period has elapsed.
 */
diff --git a/include/linux/lockd/lockd.h b/include/linux/lockd/lockd.h
index 0d9d22578212..16d4e5a08e1d 100644
--- a/include/linux/lockd/lockd.h
+++ b/include/linux/lockd/lockd.h
@@ -72,6 +72,8 @@ struct nlm_lockowner {
        uint32_t pid;
 };
+struct nlm_wait;
 /*
 * Memory chunk for NLM client RPC request.
 */
@@ -81,6 +83,7 @@ struct nlm_rqst {
        struct nlm_host *       a_host;         /* host handle */
        struct nlm_args         a_args;         /* arguments */
        struct nlm_res          a_res;          /* result */
+        struct nlm_wait *       a_block;
        char                    a_owner[NLMCLNT_OHSIZE];
 };
@@ -142,7 +145,9 @@ extern unsigned long		nlmsvc_timeout;
 * Lockd client functions
 */
 struct nlm_rqst * nlmclnt_alloc_call(void);
-int               nlmclnt_block(struct nlm_host *, struct file_lock *, u32 *);
+int               nlmclnt_prepare_block(struct nlm_rqst *req, struct nlm_host *host, struct file_lock *fl);
+void              nlmclnt_finish_block(struct nlm_rqst *req);
+long              nlmclnt_block(struct nlm_rqst *req, long timeout);
 int               nlmclnt_cancel(struct nlm_host *, struct file_lock *);
 u32               nlmclnt_grant(struct nlm_lock *);
 void              nlmclnt_recovery(struct nlm_host *, u32);
diff --git a/include/linux/loop.h b/include/linux/loop.h
index 8220d9c9da00..53fa51595443 100644
--- a/include/linux/loop.h
+++ b/include/linux/loop.h
@@ -61,7 +61,7 @@ struct loop_device {
        struct semaphore        lo_sem;
        struct semaphore        lo_ctl_mutex;
        struct semaphore        lo_bh_mutex;
-        atomic_t                lo_pending;
+        int                     lo_pending;
        request_queue_t         *lo_queue;
 };
diff --git a/include/linux/mbcache.h b/include/linux/mbcache.h
index 8e5a10410a30..9263d2db2d67 100644
--- a/include/linux/mbcache.h
+++ b/include/linux/mbcache.h
@@ -29,7 +29,7 @@ struct mb_cache_op {
 struct mb_cache * mb_cache_create(const char *, struct mb_cache_op *, size_t,
                                  int, int);
-void mb_cache_shrink(struct mb_cache *, struct block_device *);
+void mb_cache_shrink(struct block_device *);
 void mb_cache_destroy(struct mb_cache *);
 /* Functions on cache entries */
diff --git a/include/linux/mempool.h b/include/linux/mempool.h
index 4a36edf1c974..796220ce47cc 100644
--- a/include/linux/mempool.h
+++ b/include/linux/mempool.h
@@ -20,9 +20,14 @@ typedef struct mempool_s {
        mempool_free_t *free;
        wait_queue_head_t wait;
 } mempool_t;
-extern mempool_t * mempool_create(int min_nr, mempool_alloc_t *alloc_fn,
-                                 mempool_free_t *free_fn, void *pool_data);
+extern mempool_t *mempool_create(int min_nr, mempool_alloc_t *alloc_fn,
-extern int mempool_resize(mempool_t *pool, int new_min_nr, unsigned int __nocast gfp_mask);
+                        mempool_free_t *free_fn, void *pool_data);
+extern mempool_t *mempool_create_node(int min_nr, mempool_alloc_t *alloc_fn,
+                        mempool_free_t *free_fn, void *pool_data, int nid);
+extern int mempool_resize(mempool_t *pool, int new_min_nr,
+                        unsigned int __nocast gfp_mask);
 extern void mempool_destroy(mempool_t *pool);
 extern void * mempool_alloc(mempool_t *pool, unsigned int __nocast gfp_mask);
 extern void mempool_free(void *element, mempool_t *pool);
diff --git a/include/linux/mm.h b/include/linux/mm.h
index 1813b162b0a8..82d7024f0765 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -395,19 +395,81 @@ static inline void put_page(struct page *page)
 /*
 * The zone field is never updated after free_area_init_core()
 * sets it, so none of the operations on it need to be atomic.
- * We'll have up to (MAX_NUMNODES * MAX_NR_ZONES) zones total,
- * so we use (MAX_NODES_SHIFT + MAX_ZONES_SHIFT) here to get enough bits.
 */
-#define NODEZONE_SHIFT (sizeof(page_flags_t)*8 - MAX_NODES_SHIFT - MAX_ZONES_SHIFT)
-#define NODEZONE(node, zone)    ((node << ZONES_SHIFT) | zone)
+/*
+ * page->flags layout:
+ *
+ * There are three possibilities for how page->flags get
+ * laid out.  The first is for the normal case, without
+ * sparsemem.  The second is for sparsemem when there is
+ * plenty of space for node and section.  The last is when
+ * we have run out of space and have to fall back to an
+ * alternate (slower) way of determining the node.
+ *
+ *        No sparsemem: |       NODE     | ZONE | ... | FLAGS |
+ * with space for node: | SECTION | NODE | ZONE | ... | FLAGS |
+ *   no space for node: | SECTION |     ZONE    | ... | FLAGS |
+ */
+#ifdef CONFIG_SPARSEMEM
+#define SECTIONS_WIDTH          SECTIONS_SHIFT
+#else
+#define SECTIONS_WIDTH          0
+#endif
+#define ZONES_WIDTH             ZONES_SHIFT
+#if SECTIONS_WIDTH+ZONES_WIDTH+NODES_SHIFT <= FLAGS_RESERVED
+#define NODES_WIDTH             NODES_SHIFT
+#else
+#define NODES_WIDTH             0
+#endif
+/* Page flags: | [SECTION] | [NODE] | ZONE | ... | FLAGS | */
+#define SECTIONS_PGOFF          ((sizeof(page_flags_t)*8) - SECTIONS_WIDTH)
+#define NODES_PGOFF             (SECTIONS_PGOFF - NODES_WIDTH)
+#define ZONES_PGOFF             (NODES_PGOFF - ZONES_WIDTH)
+/*
+ * We are going to use the flags for the page to node mapping if its in
+ * there.  This includes the case where there is no node, so it is implicit.
+ */
+#define FLAGS_HAS_NODE          (NODES_WIDTH > 0 || NODES_SHIFT == 0)
+#ifndef PFN_SECTION_SHIFT
+#define PFN_SECTION_SHIFT 0
+#endif
+/*
+ * Define the bit shifts to access each section.  For non-existant
+ * sections we define the shift as 0; that plus a 0 mask ensures
+ * the compiler will optimise away reference to them.
+ */
+#define SECTIONS_PGSHIFT        (SECTIONS_PGOFF * (SECTIONS_WIDTH != 0))
+#define NODES_PGSHIFT           (NODES_PGOFF * (NODES_WIDTH != 0))
+#define ZONES_PGSHIFT           (ZONES_PGOFF * (ZONES_WIDTH != 0))
+/* NODE:ZONE or SECTION:ZONE is used to lookup the zone from a page. */
+#if FLAGS_HAS_NODE
+#define ZONETABLE_SHIFT         (NODES_SHIFT + ZONES_SHIFT)
+#else
+#define ZONETABLE_SHIFT         (SECTIONS_SHIFT + ZONES_SHIFT)
+#endif
+#define ZONETABLE_PGSHIFT       ZONES_PGSHIFT
+#if SECTIONS_WIDTH+NODES_WIDTH+ZONES_WIDTH > FLAGS_RESERVED
+#error SECTIONS_WIDTH+NODES_WIDTH+ZONES_WIDTH > FLAGS_RESERVED
+#endif
+#define ZONES_MASK              ((1UL << ZONES_WIDTH) - 1)
+#define NODES_MASK              ((1UL << NODES_WIDTH) - 1)
+#define SECTIONS_MASK           ((1UL << SECTIONS_WIDTH) - 1)
+#define ZONETABLE_MASK          ((1UL << ZONETABLE_SHIFT) - 1)
 static inline unsigned long page_zonenum(struct page *page)
 {
-        return (page->flags >> NODEZONE_SHIFT) & (~(~0UL << ZONES_SHIFT));
+        return (page->flags >> ZONES_PGSHIFT) & ZONES_MASK;
-}
-static inline unsigned long page_to_nid(struct page *page)
-{
-        return (page->flags >> (NODEZONE_SHIFT + ZONES_SHIFT));
 }
 struct zone;
@@ -415,13 +477,44 @@ extern struct zone *zone_table[];
 static inline struct zone *page_zone(struct page *page)
 {
-        return zone_table[page->flags >> NODEZONE_SHIFT];
+        return zone_table[(page->flags >> ZONETABLE_PGSHIFT) &
+                        ZONETABLE_MASK];
+}
+static inline unsigned long page_to_nid(struct page *page)
+{
+        if (FLAGS_HAS_NODE)
+                return (page->flags >> NODES_PGSHIFT) & NODES_MASK;
+        else
+                return page_zone(page)->zone_pgdat->node_id;
+}
+static inline unsigned long page_to_section(struct page *page)
+{
+        return (page->flags >> SECTIONS_PGSHIFT) & SECTIONS_MASK;
 }
-static inline void set_page_zone(struct page *page, unsigned long nodezone_num)
+static inline void set_page_zone(struct page *page, unsigned long zone)
 {
-        page->flags &= ~(~0UL << NODEZONE_SHIFT);
+        page->flags &= ~(ZONES_MASK << ZONES_PGSHIFT);
-        page->flags |= nodezone_num << NODEZONE_SHIFT;
+        page->flags |= (zone & ZONES_MASK) << ZONES_PGSHIFT;
+}
+static inline void set_page_node(struct page *page, unsigned long node)
+{
+        page->flags &= ~(NODES_MASK << NODES_PGSHIFT);
+        page->flags |= (node & NODES_MASK) << NODES_PGSHIFT;
+}
+static inline void set_page_section(struct page *page, unsigned long section)
+{
+        page->flags &= ~(SECTIONS_MASK << SECTIONS_PGSHIFT);
+        page->flags |= (section & SECTIONS_MASK) << SECTIONS_PGSHIFT;
+}
+static inline void set_page_links(struct page *page, unsigned long zone,
+        unsigned long node, unsigned long pfn)
+{
+        set_page_zone(page, zone);
+        set_page_node(page, node);
+        set_page_section(page, pfn_to_section_nr(pfn));
 }
 #ifndef CONFIG_DISCONTIGMEM
@@ -532,10 +625,16 @@ static inline int page_mapped(struct page *page)
 * Used to decide whether a process gets delivered SIGBUS or
 * just gets major/minor fault counters bumped up.
 */
-#define VM_FAULT_OOM    (-1)
+#define VM_FAULT_OOM    0x00
-#define VM_FAULT_SIGBUS 0
+#define VM_FAULT_SIGBUS 0x01
-#define VM_FAULT_MINOR  1
+#define VM_FAULT_MINOR  0x02
-#define VM_FAULT_MAJOR  2
+#define VM_FAULT_MAJOR  0x03
+/* 
+ * Special case for get_user_pages.
+ * Must be in a distinct bit from the above VM_FAULT_ flags.
+ */
+#define VM_FAULT_WRITE  0x10
 #define offset_in_page(p)       ((unsigned long)(p) & ~PAGE_MASK)
@@ -611,7 +710,13 @@ extern pte_t *FASTCALL(pte_alloc_kernel(struct mm_struct *mm, pmd_t *pmd, unsign
 extern pte_t *FASTCALL(pte_alloc_map(struct mm_struct *mm, pmd_t *pmd, unsigned long address));
 extern int install_page(struct mm_struct *mm, struct vm_area_struct *vma, unsigned long addr, struct page *page, pgprot_t prot);
 extern int install_file_pte(struct mm_struct *mm, struct vm_area_struct *vma, unsigned long addr, unsigned long pgoff, pgprot_t prot);
-extern int handle_mm_fault(struct mm_struct *mm,struct vm_area_struct *vma, unsigned long address, int write_access);
+extern int __handle_mm_fault(struct mm_struct *mm,struct vm_area_struct *vma, unsigned long address, int write_access);
+static inline int handle_mm_fault(struct mm_struct *mm, struct vm_area_struct *vma, unsigned long address, int write_access)
+{
+        return __handle_mm_fault(mm, vma, address, write_access) & (~VM_FAULT_WRITE);
+}
 extern int make_pages_present(unsigned long addr, unsigned long end);
 extern int access_process_vm(struct task_struct *tsk, unsigned long addr, void *buf, int len, int write);
 void install_arg_page(struct vm_area_struct *, struct page *, unsigned long);
diff --git a/include/linux/mmzone.h b/include/linux/mmzone.h
index 4733d35d8223..6c90461ed99f 100644
--- a/include/linux/mmzone.h
+++ b/include/linux/mmzone.h
@@ -269,7 +269,9 @@ typedef struct pglist_data {
        struct zone node_zones[MAX_NR_ZONES];
        struct zonelist node_zonelists[GFP_ZONETYPES];
        int nr_zones;
+#ifdef CONFIG_FLAT_NODE_MEM_MAP
        struct page *node_mem_map;
+#endif
        struct bootmem_data *bdata;
        unsigned long node_start_pfn;
        unsigned long node_present_pages; /* total number of physical pages */
@@ -284,6 +286,12 @@ typedef struct pglist_data {
 #define node_present_pages(nid) (NODE_DATA(nid)->node_present_pages)
 #define node_spanned_pages(nid) (NODE_DATA(nid)->node_spanned_pages)
+#ifdef CONFIG_FLAT_NODE_MEM_MAP
+#define pgdat_page_nr(pgdat, pagenr)    ((pgdat)->node_mem_map + (pagenr))
+#else
+#define pgdat_page_nr(pgdat, pagenr)    pfn_to_page((pgdat)->node_start_pfn + (pagenr))
+#endif
+#define nid_page_nr(nid, pagenr)        pgdat_page_nr(NODE_DATA(nid),(pagenr))
 extern struct pglist_data *pgdat_list;
@@ -400,7 +408,7 @@ int lowmem_reserve_ratio_sysctl_handler(struct ctl_table *, int, struct file *,
 /* Returns the number of the current Node. */
 #define numa_node_id()          (cpu_to_node(raw_smp_processor_id()))
-#ifndef CONFIG_DISCONTIGMEM
+#ifndef CONFIG_NEED_MULTIPLE_NODES
 extern struct pglist_data contig_page_data;
 #define NODE_DATA(nid)          (&contig_page_data)
@@ -408,36 +416,177 @@ extern struct pglist_data contig_page_data;
 #define MAX_NODES_SHIFT         1
 #define pfn_to_nid(pfn)         (0)
-#else /* CONFIG_DISCONTIGMEM */
+#else /* CONFIG_NEED_MULTIPLE_NODES */
 #include <asm/mmzone.h>
+#endif /* !CONFIG_NEED_MULTIPLE_NODES */
+#ifdef CONFIG_SPARSEMEM
+#include <asm/sparsemem.h>
+#endif
 #if BITS_PER_LONG == 32 || defined(ARCH_HAS_ATOMIC_UNSIGNED)
 /*
 * with 32 bit page->flags field, we reserve 8 bits for node/zone info.
 * there are 3 zones (2 bits) and this leaves 8-2=6 bits for nodes.
 */
-#define MAX_NODES_SHIFT         6
+#define FLAGS_RESERVED          8
 #elif BITS_PER_LONG == 64
 /*
 * with 64 bit flags field, there's plenty of room.
 */
-#define MAX_NODES_SHIFT         10
+#define FLAGS_RESERVED          32
+#else
+#error BITS_PER_LONG not defined
+#endif
+#ifndef CONFIG_HAVE_ARCH_EARLY_PFN_TO_NID
+#define early_pfn_to_nid(nid)  (0UL)
 #endif
-#endif /* !CONFIG_DISCONTIGMEM */
+#define pfn_to_section_nr(pfn) ((pfn) >> PFN_SECTION_SHIFT)
+#define section_nr_to_pfn(sec) ((sec) << PFN_SECTION_SHIFT)
+#ifdef CONFIG_SPARSEMEM
+/*
+ * SECTION_SHIFT                #bits space required to store a section #
+ *
+ * PA_SECTION_SHIFT             physical address to/from section number
+ * PFN_SECTION_SHIFT            pfn to/from section number
+ */
+#define SECTIONS_SHIFT          (MAX_PHYSMEM_BITS - SECTION_SIZE_BITS)
+#define PA_SECTION_SHIFT        (SECTION_SIZE_BITS)
+#define PFN_SECTION_SHIFT       (SECTION_SIZE_BITS - PAGE_SHIFT)
+#define NR_MEM_SECTIONS         (1UL << SECTIONS_SHIFT)
-#if NODES_SHIFT > MAX_NODES_SHIFT
+#define PAGES_PER_SECTION       (1UL << PFN_SECTION_SHIFT)
-#error NODES_SHIFT > MAX_NODES_SHIFT
+#define PAGE_SECTION_MASK       (~(PAGES_PER_SECTION-1))
+#if (MAX_ORDER - 1 + PAGE_SHIFT) > SECTION_SIZE_BITS
+#error Allocator MAX_ORDER exceeds SECTION_SIZE
 #endif
-/* There are currently 3 zones: DMA, Normal & Highmem, thus we need 2 bits */
+struct page;
-#define MAX_ZONES_SHIFT         2
+struct mem_section {
+        /*
+         * This is, logically, a pointer to an array of struct
+         * pages.  However, it is stored with some other magic.
+         * (see sparse.c::sparse_init_one_section())
+         *
+         * Making it a UL at least makes someone do a cast
+         * before using it wrong.
+         */
+        unsigned long section_mem_map;
+};
+extern struct mem_section mem_section[NR_MEM_SECTIONS];
-#if ZONES_SHIFT > MAX_ZONES_SHIFT
+static inline struct mem_section *__nr_to_section(unsigned long nr)
-#error ZONES_SHIFT > MAX_ZONES_SHIFT
+{
+        return &mem_section[nr];
+}
+/*
+ * We use the lower bits of the mem_map pointer to store
+ * a little bit of information.  There should be at least
+ * 3 bits here due to 32-bit alignment.
+ */
+#define SECTION_MARKED_PRESENT  (1UL<<0)
+#define SECTION_HAS_MEM_MAP     (1UL<<1)
+#define SECTION_MAP_LAST_BIT    (1UL<<2)
+#define SECTION_MAP_MASK        (~(SECTION_MAP_LAST_BIT-1))
+static inline struct page *__section_mem_map_addr(struct mem_section *section)
+{
+        unsigned long map = section->section_mem_map;
+        map &= SECTION_MAP_MASK;
+        return (struct page *)map;
+}
+static inline int valid_section(struct mem_section *section)
+{
+        return (section->section_mem_map & SECTION_MARKED_PRESENT);
+}
+static inline int section_has_mem_map(struct mem_section *section)
+{
+        return (section->section_mem_map & SECTION_HAS_MEM_MAP);
+}
+static inline int valid_section_nr(unsigned long nr)
+{
+        return valid_section(__nr_to_section(nr));
+}
+/*
+ * Given a kernel address, find the home node of the underlying memory.
+ */
+#define kvaddr_to_nid(kaddr)    pfn_to_nid(__pa(kaddr) >> PAGE_SHIFT)
+static inline struct mem_section *__pfn_to_section(unsigned long pfn)
+{
+        return __nr_to_section(pfn_to_section_nr(pfn));
+}
+#define pfn_to_page(pfn)                                                \
+({                                                                      \
+        unsigned long __pfn = (pfn);                                    \
+        __section_mem_map_addr(__pfn_to_section(__pfn)) + __pfn;        \
+})
+#define page_to_pfn(page)                                               \
+({                                                                      \
+        page - __section_mem_map_addr(__nr_to_section(                  \
+                page_to_section(page)));                                \
+})
+static inline int pfn_valid(unsigned long pfn)
+{
+        if (pfn_to_section_nr(pfn) >= NR_MEM_SECTIONS)
+                return 0;
+        return valid_section(__nr_to_section(pfn_to_section_nr(pfn)));
+}
+/*
+ * These are _only_ used during initialisation, therefore they
+ * can use __initdata ...  They could have names to indicate
+ * this restriction.
+ */
+#ifdef CONFIG_NUMA
+#define pfn_to_nid              early_pfn_to_nid
+#endif
+#define pfn_to_pgdat(pfn)                                               \
+({                                                                      \
+        NODE_DATA(pfn_to_nid(pfn));                                     \
+})
+#define early_pfn_valid(pfn)    pfn_valid(pfn)
+void sparse_init(void);
+#else
+#define sparse_init()   do {} while (0)
+#endif /* CONFIG_SPARSEMEM */
+#ifdef CONFIG_NODES_SPAN_OTHER_NODES
+#define early_pfn_in_nid(pfn, nid)      (early_pfn_to_nid(pfn) == (nid))
+#else
+#define early_pfn_in_nid(pfn, nid)      (1)
+#endif
+#ifndef early_pfn_valid
+#define early_pfn_valid(pfn)    (1)
 #endif
+void memory_present(int nid, unsigned long start, unsigned long end);
+unsigned long __init node_memmap_size_bytes(int, unsigned long, unsigned long);
 #endif /* !__ASSEMBLY__ */
 #endif /* __KERNEL__ */
 #endif /* _LINUX_MMZONE_H */
diff --git a/include/linux/mod_devicetable.h b/include/linux/mod_devicetable.h
index d6eb7b2efc04..dce53ac1625d 100644
--- a/include/linux/mod_devicetable.h
+++ b/include/linux/mod_devicetable.h
@@ -174,5 +174,62 @@ struct serio_device_id {
        __u8 proto;
 };
+/*
+ * Struct used for matching a device
+ */
+struct of_device_id
+{
+        char    name[32];
+        char    type[32];
+        char    compatible[128];
+        void    *data;
+};
+/* PCMCIA */
+struct pcmcia_device_id {
+        __u16           match_flags;
+        __u16           manf_id;
+        __u16           card_id;
+        __u8            func_id;
+        /* for real multi-function devices */
+        __u8            function;
+        /* for pseude multi-function devices */
+        __u8            device_no;
+        __u32           prod_id_hash[4];
+        /* not matched against in kernelspace*/
+#ifdef __KERNEL__
+        const char *    prod_id[4];
+#else
+        kernel_ulong_t  prod_id[4];
+#endif
+        /* not matched against */
+        kernel_ulong_t  driver_info;
+#ifdef __KERNEL__
+        char *          cisfile;
+#else
+        kernel_ulong_t  cisfile;
+#endif
+};
+#define PCMCIA_DEV_ID_MATCH_MANF_ID     0x0001
+#define PCMCIA_DEV_ID_MATCH_CARD_ID     0x0002
+#define PCMCIA_DEV_ID_MATCH_FUNC_ID     0x0004
+#define PCMCIA_DEV_ID_MATCH_FUNCTION    0x0008
+#define PCMCIA_DEV_ID_MATCH_PROD_ID1    0x0010
+#define PCMCIA_DEV_ID_MATCH_PROD_ID2    0x0020
+#define PCMCIA_DEV_ID_MATCH_PROD_ID3    0x0040
+#define PCMCIA_DEV_ID_MATCH_PROD_ID4    0x0080
+#define PCMCIA_DEV_ID_MATCH_DEVICE_NO   0x0100
+#define PCMCIA_DEV_ID_MATCH_FAKE_CIS    0x0200
+#define PCMCIA_DEV_ID_MATCH_ANONYMOUS   0x0400
 #endif /* LINUX_MOD_DEVICETABLE_H */
diff --git a/include/linux/module.h b/include/linux/module.h
index 0e432a0f4aee..f05372b7fe77 100644
--- a/include/linux/module.h
+++ b/include/linux/module.h
@@ -51,6 +51,9 @@ struct module_attribute {
        ssize_t (*show)(struct module_attribute *, struct module *, char *);
        ssize_t (*store)(struct module_attribute *, struct module *,
                         const char *, size_t count);
+        void (*setup)(struct module *, const char *);
+        int (*test)(struct module *);
+        void (*free)(struct module *);
 };
 struct module_kobject
@@ -239,6 +242,8 @@ struct module
        /* Sysfs stuff. */
        struct module_kobject mkobj;
        struct module_param_attrs *param_attrs;
+        const char *version;
+        const char *srcversion;
        /* Exported symbols */
        const struct kernel_symbol *syms;
diff --git a/include/linux/mount.h b/include/linux/mount.h
index 8b8d3b9beefd..f8f39937e301 100644
--- a/include/linux/mount.h
+++ b/include/linux/mount.h
@@ -12,6 +12,7 @@
 #define _LINUX_MOUNT_H
 #ifdef __KERNEL__
+#include <linux/types.h>
 #include <linux/list.h>
 #include <linux/spinlock.h>
 #include <asm/atomic.h>
@@ -34,7 +35,7 @@ struct vfsmount
        int mnt_expiry_mark;            /* true if marked for expiry */
        char *mnt_devname;              /* Name of device e.g. /dev/dsk/hda1 */
        struct list_head mnt_list;
-        struct list_head mnt_fslink;    /* link in fs-specific expiry list */
+        struct list_head mnt_expire;    /* link in fs-specific expiry list */
        struct namespace *mnt_namespace; /* containing namespace */
 };
@@ -47,7 +48,7 @@ static inline struct vfsmount *mntget(struct vfsmount *mnt)
 extern void __mntput(struct vfsmount *mnt);
-static inline void _mntput(struct vfsmount *mnt)
+static inline void mntput_no_expire(struct vfsmount *mnt)
 {
        if (mnt) {
                if (atomic_dec_and_test(&mnt->mnt_count))
@@ -59,7 +60,7 @@ static inline void mntput(struct vfsmount *mnt)
 {
        if (mnt) {
                mnt->mnt_expiry_mark = 0;
-                _mntput(mnt);
+                mntput_no_expire(mnt);
        }
 }
@@ -76,6 +77,7 @@ extern int do_add_mount(struct vfsmount *newmnt, struct nameidata *nd,
 extern void mark_mounts_for_expiry(struct list_head *mounts);
 extern spinlock_t vfsmount_lock;
+extern dev_t name_to_dev_t(char *name);
 #endif
 #endif /* _LINUX_MOUNT_H */
diff --git a/include/linux/mtd/cfi.h b/include/linux/mtd/cfi.h
index 2ed8c585021e..e6b6a1c66bd5 100644
--- a/include/linux/mtd/cfi.h
+++ b/include/linux/mtd/cfi.h
@@ -1,7 +1,7 @@
 /* Common Flash Interface structures 
 * See http://support.intel.com/design/flash/technote/index.htm
- * $Id: cfi.h,v 1.50 2004/11/20 12:46:51 dwmw2 Exp $
+ * $Id: cfi.h,v 1.54 2005/06/06 23:04:36 tpoynor Exp $
 */
 #ifndef __MTD_CFI_H__
@@ -148,6 +148,14 @@ struct cfi_pri_intelext {
        uint8_t  extra[0];
 } __attribute__((packed));
+struct cfi_intelext_otpinfo {
+        uint32_t ProtRegAddr;
+        uint16_t FactGroups;
+        uint8_t  FactProtRegSize;
+        uint16_t UserGroups;
+        uint8_t  UserProtRegSize;
+} __attribute__((packed));
 struct cfi_intelext_blockinfo {
        uint16_t NumIdentBlocks;
        uint16_t BlockSize;
@@ -244,7 +252,7 @@ static inline uint32_t cfi_build_cmd_addr(uint32_t cmd_ofs, int interleave, int
 * It looks too long to be inline, but in the common case it should almost all
 * get optimised away. 
 */
-static inline map_word cfi_build_cmd(u_char cmd, struct map_info *map, struct cfi_private *cfi)
+static inline map_word cfi_build_cmd(u_long cmd, struct map_info *map, struct cfi_private *cfi)
 {
        map_word val = { {0} };
        int wordwidth, words_per_bus, chip_mode, chips_per_word;
@@ -307,6 +315,69 @@ static inline map_word cfi_build_cmd(u_char cmd, struct map_info *map, struct cf
 }
 #define CMD(x)  cfi_build_cmd((x), map, cfi)
+static inline unsigned char cfi_merge_status(map_word val, struct map_info *map, 
+                                           struct cfi_private *cfi)
+{
+        int wordwidth, words_per_bus, chip_mode, chips_per_word;
+        unsigned long onestat, res = 0;
+        int i;
+        /* We do it this way to give the compiler a fighting chance 
+           of optimising away all the crap for 'bankwidth' larger than
+           an unsigned long, in the common case where that support is
+           disabled */
+        if (map_bankwidth_is_large(map)) {
+                wordwidth = sizeof(unsigned long);
+                words_per_bus = (map_bankwidth(map)) / wordwidth; // i.e. normally 1
+        } else {
+                wordwidth = map_bankwidth(map);
+                words_per_bus = 1;
+        }
+        
+        chip_mode = map_bankwidth(map) / cfi_interleave(cfi);
+        chips_per_word = wordwidth * cfi_interleave(cfi) / map_bankwidth(map);
+        onestat = val.x[0];
+        /* Or all status words together */
+        for (i=1; i < words_per_bus; i++) {
+                onestat |= val.x[i];
+        }
+        res = onestat;
+        switch(chips_per_word) {
+        default: BUG();
+#if BITS_PER_LONG >= 64
+        case 8:
+                res |= (onestat >> (chip_mode * 32));
+#endif
+        case 4:
+                res |= (onestat >> (chip_mode * 16));
+        case 2:
+                res |= (onestat >> (chip_mode * 8));
+        case 1:
+                ;
+        }
+        /* Last, determine what the bit-pattern should be for a single
+           device, according to chip mode and endianness... */
+        switch (chip_mode) {
+        case 1:
+                break;
+        case 2:
+                res = cfi16_to_cpu(res);
+                break;
+        case 4:
+                res = cfi32_to_cpu(res);
+                break;
+        default: BUG();
+        }
+        return res;
+}
+#define MERGESTATUS(x) cfi_merge_status((x), map, cfi)
 /*
 * Sends a CFI command to a bank of flash for the given geometry.
 *
@@ -357,16 +428,6 @@ static inline void cfi_udelay(int us)
        }
 }
-static inline void cfi_spin_lock(spinlock_t *mutex)
-{
-        spin_lock_bh(mutex);
-}
-static inline void cfi_spin_unlock(spinlock_t *mutex)
-{
-        spin_unlock_bh(mutex);
-}
 struct cfi_extquery *cfi_read_pri(struct map_info *map, uint16_t adr, uint16_t size,
                             const char* name);
 struct cfi_fixup {
diff --git a/include/linux/mtd/flashchip.h b/include/linux/mtd/flashchip.h
index c66ba812bf90..675776fa3e27 100644
--- a/include/linux/mtd/flashchip.h
+++ b/include/linux/mtd/flashchip.h
@@ -6,7 +6,7 @@
 *
 * (C) 2000 Red Hat. GPLd.
 *
- * $Id: flashchip.h,v 1.15 2004/11/05 22:41:06 nico Exp $
+ * $Id: flashchip.h,v 1.17 2005/03/14 18:27:15 bjd Exp $
 *
 */
@@ -29,6 +29,7 @@ typedef enum {
        FL_ERASE_SUSPENDED,
        FL_WRITING,
        FL_WRITING_TO_BUFFER,
+        FL_OTP_WRITE,
        FL_WRITE_SUSPENDING,
        FL_WRITE_SUSPENDED,
        FL_PM_SUSPENDED,
@@ -62,8 +63,8 @@ struct flchip {
        flstate_t state;
        flstate_t oldstate;
-        int write_suspended:1;
+        unsigned int write_suspended:1;
-        int erase_suspended:1;
+        unsigned int erase_suspended:1;
        unsigned long in_progress_block_addr;
        spinlock_t *mutex;
diff --git a/include/linux/mtd/inftl.h b/include/linux/mtd/inftl.h
index b52c8cbd235c..0268125a6271 100644
--- a/include/linux/mtd/inftl.h
+++ b/include/linux/mtd/inftl.h
@@ -3,7 +3,7 @@
 *
 *      (C) Copyright 2002, Greg Ungerer (gerg@snapgear.com)
 *
- *      $Id: inftl.h,v 1.6 2004/06/30 14:49:00 dbrown Exp $
+ *      $Id: inftl.h,v 1.7 2005/06/13 13:08:45 sean Exp $
 */
 #ifndef __MTD_INFTL_H__
@@ -20,7 +20,7 @@
 #include <mtd/inftl-user.h>
 #ifndef INFTL_MAJOR
-#define INFTL_MAJOR 94
+#define INFTL_MAJOR 96
 #endif
 #define INFTL_PARTN_BITS 4
diff --git a/include/linux/mtd/map.h b/include/linux/mtd/map.h
index f0268b99c900..142963f01d29 100644
--- a/include/linux/mtd/map.h
+++ b/include/linux/mtd/map.h
@@ -1,6 +1,6 @@
 /* Overhauled routines for dealing with different mmap regions of flash */
-/* $Id: map.h,v 1.46 2005/01/05 17:09:44 dwmw2 Exp $ */
+/* $Id: map.h,v 1.52 2005/05/25 10:29:41 gleixner Exp $ */
 #ifndef __LINUX_MTD_MAP_H__
 #define __LINUX_MTD_MAP_H__
@@ -263,6 +263,17 @@ static inline map_word map_word_and(struct map_info *map, map_word val1, map_wor
        return r;
 }
+static inline map_word map_word_clr(struct map_info *map, map_word val1, map_word val2)
+{
+        map_word r;
+        int i;
+        for (i=0; i<map_words(map); i++) {
+                r.x[i] = val1.x[i] & ~val2.x[i];
+        }
+        return r;
+}
 static inline map_word map_word_or(struct map_info *map, map_word val1, map_word val2)
 {
        map_word r;
@@ -273,6 +284,7 @@ static inline map_word map_word_or(struct map_info *map, map_word val1, map_word
        }
        return r;
 }
 #define map_word_andequal(m, a, b, z) map_word_equal(m, z, map_word_and(m, a, b))
 static inline int map_word_bitsset(struct map_info *map, map_word val1, map_word val2)
@@ -328,16 +340,27 @@ static inline map_word map_word_load_partial(struct map_info *map, map_word orig
        return orig;
 }
+#if BITS_PER_LONG < 64
+#define MAP_FF_LIMIT 4
+#else
+#define MAP_FF_LIMIT 8
+#endif
 static inline map_word map_word_ff(struct map_info *map)
 {
        map_word r;
        int i;
+        
-        for (i=0; i<map_words(map); i++) {
+        if (map_bankwidth(map) < MAP_FF_LIMIT) {
-                r.x[i] = ~0UL;
+                int bw = 8 * map_bankwidth(map);
+                r.x[0] = (1 << bw) - 1;
+        } else {
+                for (i=0; i<map_words(map); i++)
+                        r.x[i] = ~0UL;
        }
        return r;
 }
 static inline map_word inline_map_read(struct map_info *map, unsigned long ofs)
 {
        map_word r;
@@ -405,7 +428,7 @@ extern void simple_map_init(struct map_info *);
 #define simple_map_init(map) BUG_ON(!map_bankwidth_supported((map)->bankwidth))
-#define map_is_linear(map) (1)
+#define map_is_linear(map) ({ (void)(map); 1; })
 #endif /* !CONFIG_MTD_COMPLEX_MAPPINGS */
diff --git a/include/linux/mtd/mtd.h b/include/linux/mtd/mtd.h
index b3d134392b31..c50c3f3927d9 100644
--- a/include/linux/mtd/mtd.h
+++ b/include/linux/mtd/mtd.h
@@ -1,5 +1,5 @@
 /* 
- * $Id: mtd.h,v 1.56 2004/08/09 18:46:04 dmarlin Exp $
+ * $Id: mtd.h,v 1.59 2005/04/11 10:19:02 gleixner Exp $
 *
 * Copyright (C) 1999-2003 David Woodhouse <dwmw2@infradead.org> et al.
 *
@@ -18,6 +18,7 @@
 #include <linux/types.h>
 #include <linux/module.h>
 #include <linux/uio.h>
+#include <linux/notifier.h>
 #include <linux/mtd/compatmac.h>
 #include <mtd/mtd-abi.h>
@@ -69,7 +70,6 @@ struct mtd_info {
        u_int32_t oobblock;  // Size of OOB blocks (e.g. 512)
        u_int32_t oobsize;   // Amount of OOB data per block (e.g. 16)
-        u_int32_t oobavail;  // Number of bytes in OOB area available for fs 
        u_int32_t ecctype;
        u_int32_t eccsize;
        
@@ -80,6 +80,7 @@ struct mtd_info {
        // oobinfo is a nand_oobinfo structure, which can be set by iotcl (MEMSETOOBINFO)
        struct nand_oobinfo oobinfo;
+        u_int32_t oobavail;  // Number of bytes in OOB area available for fs 
        /* Data for variable erase regions. If numeraseregions is zero,
         * it means that the whole device has erasesize as given above. 
@@ -113,12 +114,12 @@ struct mtd_info {
         * flash devices. The user data is one time programmable but the
         * factory data is read only. 
         */
-        int (*read_user_prot_reg) (struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, u_char *buf);
+        int (*get_fact_prot_info) (struct mtd_info *mtd, struct otp_info *buf, size_t len);
        int (*read_fact_prot_reg) (struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, u_char *buf);
+        int (*get_user_prot_info) (struct mtd_info *mtd, struct otp_info *buf, size_t len);
-        /* This function is not yet implemented */
+        int (*read_user_prot_reg) (struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, u_char *buf);
        int (*write_user_prot_reg) (struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, u_char *buf);
+        int (*lock_user_prot_reg) (struct mtd_info *mtd, loff_t from, size_t len);
        /* kvec-based read/write methods. We need these especially for NAND flash,
           with its limited number of write cycles per erase.
@@ -147,6 +148,8 @@ struct mtd_info {
        int (*block_isbad) (struct mtd_info *mtd, loff_t ofs);
        int (*block_markbad) (struct mtd_info *mtd, loff_t ofs);
+        struct notifier_block reboot_notifier;  /* default mode before reboot */
        void *priv;
        struct module *owner;
diff --git a/include/linux/mtd/nand.h b/include/linux/mtd/nand.h
index 9a19c65abd74..9b5b76217584 100644
--- a/include/linux/mtd/nand.h
+++ b/include/linux/mtd/nand.h
@@ -5,7 +5,7 @@
 *                     Steven J. Hill <sjhill@realitydiluted.com>
 *                     Thomas Gleixner <tglx@linutronix.de>
 *
- * $Id: nand.h,v 1.68 2004/11/12 10:40:37 gleixner Exp $
+ * $Id: nand.h,v 1.73 2005/05/31 19:39:17 gleixner Exp $
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
@@ -48,6 +48,10 @@
 *  02-08-2004 tglx     added option field to nand structure for chip anomalities
 *  05-25-2004 tglx     added bad block table support, ST-MICRO manufacturer id
 *                      update of nand_chip structure description
+ *  01-17-2005 dmarlin  added extended commands for AG-AND device and added option 
+ *                      for BBT_AUTO_REFRESH.
+ *  01-20-2005 dmarlin  added optional pointer to hardware specific callback for 
+ *                      extra error status checks.
 */
 #ifndef __LINUX_MTD_NAND_H
 #define __LINUX_MTD_NAND_H
@@ -115,6 +119,25 @@ extern int nand_read_raw (struct mtd_info *mtd, uint8_t *buf, loff_t from, size_
 #define NAND_CMD_READSTART      0x30
 #define NAND_CMD_CACHEDPROG     0x15
+/* Extended commands for AG-AND device */
+/* 
+ * Note: the command for NAND_CMD_DEPLETE1 is really 0x00 but 
+ *       there is no way to distinguish that from NAND_CMD_READ0
+ *       until the remaining sequence of commands has been completed
+ *       so add a high order bit and mask it off in the command.
+ */
+#define NAND_CMD_DEPLETE1       0x100
+#define NAND_CMD_DEPLETE2       0x38
+#define NAND_CMD_STATUS_MULTI   0x71
+#define NAND_CMD_STATUS_ERROR   0x72
+/* multi-bank error status (banks 0-3) */
+#define NAND_CMD_STATUS_ERROR0  0x73
+#define NAND_CMD_STATUS_ERROR1  0x74
+#define NAND_CMD_STATUS_ERROR2  0x75
+#define NAND_CMD_STATUS_ERROR3  0x76
+#define NAND_CMD_STATUS_RESET   0x7f
+#define NAND_CMD_STATUS_CLEAR   0xff
 /* Status bits */
 #define NAND_STATUS_FAIL        0x01
 #define NAND_STATUS_FAIL_N1     0x02
@@ -143,7 +166,7 @@ extern int nand_read_raw (struct mtd_info *mtd, uint8_t *buf, loff_t from, size_
 /*
 * Constants for Hardware ECC
-*/
+ */
 /* Reset Hardware ECC for read */
 #define NAND_ECC_READ           0
 /* Reset Hardware ECC for write */
@@ -151,6 +174,10 @@ extern int nand_read_raw (struct mtd_info *mtd, uint8_t *buf, loff_t from, size_
 /* Enable Hardware ECC before syndrom is read back from flash */
 #define NAND_ECC_READSYN        2
+/* Bit mask for flags passed to do_nand_read_ecc */
+#define NAND_GET_DEVICE         0x80
 /* Option constants for bizarre disfunctionality and real
 *  features
 */
@@ -170,6 +197,10 @@ extern int nand_read_raw (struct mtd_info *mtd, uint8_t *buf, loff_t from, size_
 /* Chip has a array of 4 pages which can be read without
 * additional ready /busy waits */
 #define NAND_4PAGE_ARRAY        0x00000040 
+/* Chip requires that BBT is periodically rewritten to prevent
+ * bits from adjacent blocks from 'leaking' in altering data.
+ * This happens with the Renesas AG-AND chips, possibly others.  */
+#define BBT_AUTO_REFRESH        0x00000080
 /* Options valid for Samsung large page devices */
 #define NAND_SAMSUNG_LP_OPTIONS \
@@ -192,7 +223,8 @@ extern int nand_read_raw (struct mtd_info *mtd, uint8_t *buf, loff_t from, size_
 * This can only work if we have the ecc bytes directly behind the 
 * data bytes. Applies for DOC and AG-AND Renesas HW Reed Solomon generators */
 #define NAND_HWECC_SYNDROME     0x00020000
+/* This option skips the bbt scan during initialization. */
+#define NAND_SKIP_BBTSCAN       0x00040000
 /* Options set by nand scan */
 /* Nand scan has allocated oob_buf */
@@ -221,10 +253,13 @@ struct nand_chip;
 * struct nand_hw_control - Control structure for hardware controller (e.g ECC generator) shared among independend devices
 * @lock:               protection lock  
 * @active:             the mtd device which holds the controller currently
+ * @wq:                 wait queue to sleep on if a NAND operation is in progress
+ *                      used instead of the per chip wait queue when a hw controller is available
 */
 struct nand_hw_control {
        spinlock_t       lock;
        struct nand_chip *active;
+        wait_queue_head_t wq;
 };
 /**
@@ -283,6 +318,8 @@ struct nand_hw_control {
 * @badblock_pattern:   [REPLACEABLE] bad block scan pattern used for initial bad block scan 
 * @controller:         [OPTIONAL] a pointer to a hardware controller structure which is shared among multiple independend devices
 * @priv:               [OPTIONAL] pointer to private chip date
+ * @errstat:            [OPTIONAL] hardware specific function to perform additional error status checks 
+ *                      (determine if errors are correctable)
 */
 
 struct nand_chip {
@@ -338,6 +375,7 @@ struct nand_chip {
        struct nand_bbt_descr   *badblock_pattern;
        struct nand_hw_control  *controller;
        void            *priv;
+        int             (*errstat)(struct mtd_info *mtd, struct nand_chip *this, int state, int status, int page);
 };
 /*
@@ -349,6 +387,7 @@ struct nand_chip {
 #define NAND_MFR_NATIONAL       0x8f
 #define NAND_MFR_RENESAS        0x07
 #define NAND_MFR_STMICRO        0x20
+#define NAND_MFR_HYNIX          0xad
 /**
 * struct nand_flash_dev - NAND Flash Device ID Structure
@@ -459,6 +498,9 @@ extern int nand_update_bbt (struct mtd_info *mtd, loff_t offs);
 extern int nand_default_bbt (struct mtd_info *mtd);
 extern int nand_isbad_bbt (struct mtd_info *mtd, loff_t offs, int allowbbt);
 extern int nand_erase_nand (struct mtd_info *mtd, struct erase_info *instr, int allowbbt);
+extern int nand_do_read_ecc (struct mtd_info *mtd, loff_t from, size_t len,
+                             size_t * retlen, u_char * buf, u_char * oob_buf,
+                             struct nand_oobinfo *oobsel, int flags);
 /*
 * Constants for oob configuration
diff --git a/include/linux/mtd/plat-ram.h b/include/linux/mtd/plat-ram.h
new file mode 100644
index 000000000000..2332eda07e0e
--- /dev/null
+++ b/include/linux/mtd/plat-ram.h
@@ -0,0 +1,35 @@
+/* linux/include/mtd/plat-ram.h
+ *
+ * (c) 2004 Simtec Electronics
+ *      http://www.simtec.co.uk/products/SWLINUX/
+ *      Ben Dooks <ben@simtec.co.uk>
+ *
+ * Generic platform device based RAM map
+ *
+ * $Id: plat-ram.h,v 1.2 2005/01/24 00:37:40 bjd Exp $
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ */
+#ifndef __LINUX_MTD_PLATRAM_H
+#define __LINUX_MTD_PLATRAM_H __FILE__
+#define PLATRAM_RO (0)
+#define PLATRAM_RW (1)
+struct platdata_mtd_ram {
+        char                    *mapname;
+        char                   **probes;
+        struct mtd_partition    *partitions;
+        int                      nr_partitions;
+        int                      bankwidth;
+        /* control callbacks */
+        void    (*set_rw)(struct device *dev, int to);
+};
+#endif /* __LINUX_MTD_PLATRAM_H */
diff --git a/include/linux/mtd/xip.h b/include/linux/mtd/xip.h
index fc071125cbcc..7b7deef6b180 100644
--- a/include/linux/mtd/xip.h
+++ b/include/linux/mtd/xip.h
@@ -58,22 +58,16 @@
 *              returned value is <= the real elapsed time.
 *      note 2: this should be able to cope with a few seconds without
 *              overflowing.
+ *
+ * xip_iprefetch()
+ *  
+ *      Macro to fill instruction prefetch
+ *      e.g. a series of nops:  asm volatile (".rep 8; nop; .endr"); 
 */
-#if defined(CONFIG_ARCH_SA1100) || defined(CONFIG_ARCH_PXA)
+#include <asm/mtd-xip.h>
-#include <asm/hardware.h>
-#ifdef CONFIG_ARCH_PXA
-#include <asm/arch/pxa-regs.h>
-#endif
-#define xip_irqpending()        (ICIP & ICMR)
-/* we sample OSCR and convert desired delta to usec (1/4 ~= 1000000/3686400) */
-#define xip_currtime()          (OSCR)
-#define xip_elapsed_since(x)    (signed)((OSCR - (x)) / 4)
-#else
+#ifndef xip_irqpending
 #warning "missing IRQ and timer primitives for XIP MTD support"
 #warning "some of the XIP MTD support code will be disabled"
@@ -85,16 +79,17 @@
 #endif
+#ifndef xip_iprefetch
+#define xip_iprefetch()         do { } while (0)
+#endif
 /*
 * xip_cpu_idle() is used when waiting for a delay equal or larger than
 * the system timer tick period.  This should put the CPU into idle mode
 * to save power and to be woken up only when some interrupts are pending.
- * As above, this should not rely upon standard kernel code.
+ * This should not rely upon standard kernel code.
 */
+#ifndef xip_cpu_idle
-#if defined(CONFIG_CPU_XSCALE)
-#define xip_cpu_idle()  asm volatile ("mcr p14, 0, %0, c7, c0, 0" :: "r" (1))
-#else
 #define xip_cpu_idle()  do { } while (0)
 #endif
diff --git a/include/linux/namespace.h b/include/linux/namespace.h
index 9eca1558d72f..0e5a86f13b2f 100644
--- a/include/linux/namespace.h
+++ b/include/linux/namespace.h
@@ -12,13 +12,13 @@ struct namespace {
        struct rw_semaphore     sem;
 };
-extern void umount_tree(struct vfsmount *);
 extern int copy_namespace(int, struct task_struct *);
 extern void __put_namespace(struct namespace *namespace);
 static inline void put_namespace(struct namespace *namespace)
 {
-        if (atomic_dec_and_test(&namespace->count))
+        if (atomic_dec_and_lock(&namespace->count, &vfsmount_lock))
+                /* releases vfsmount_lock */
                __put_namespace(namespace);
 }
diff --git a/include/linux/netdevice.h b/include/linux/netdevice.h
index ba5d1236aa17..3a0ed7f9e801 100644
--- a/include/linux/netdevice.h
+++ b/include/linux/netdevice.h
@@ -41,7 +41,7 @@
 struct divert_blk;
 struct vlan_group;
 struct ethtool_ops;
-struct netpoll;
+struct netpoll_info;
                                        /* source back-compat hooks */
 #define SET_ETHTOOL_OPS(netdev,ops) \
        ( (netdev)->ethtool_ops = (ops) )
@@ -164,12 +164,6 @@ struct netif_rx_stats
        unsigned total;
        unsigned dropped;
        unsigned time_squeeze;
-        unsigned throttled;
-        unsigned fastroute_hit;
-        unsigned fastroute_success;
-        unsigned fastroute_defer;
-        unsigned fastroute_deferred_out;
-        unsigned fastroute_latency_reduction;
        unsigned cpu_collision;
 };
@@ -468,7 +462,7 @@ struct net_device
                                                     unsigned char *haddr);
        int                     (*neigh_setup)(struct net_device *dev, struct neigh_parms *);
 #ifdef CONFIG_NETPOLL
-        struct netpoll          *np;
+        struct netpoll_info     *npinfo;
 #endif
 #ifdef CONFIG_NET_POLL_CONTROLLER
        void                    (*poll_controller)(struct net_device *dev);
@@ -562,12 +556,9 @@ static inline int unregister_gifconf(unsigned int family)
 struct softnet_data
 {
-        int                     throttle;
+        struct net_device       *output_queue;
-        int                     cng_level;
-        int                     avg_blog;
        struct sk_buff_head     input_pkt_queue;
        struct list_head        poll_list;
-        struct net_device       *output_queue;
        struct sk_buff          *completion_queue;
        struct net_device       backlog_dev;    /* Sorry. 8) */
@@ -925,10 +916,6 @@ extern int skb_checksum_help(struct sk_buff *skb, int inward);
 extern void             net_enable_timestamp(void);
 extern void             net_disable_timestamp(void);
-#ifdef CONFIG_SYSCTL
-extern char *net_sysctl_strdup(const char *s);
-#endif
 #endif /* __KERNEL__ */
 #endif  /* _LINUX_DEV_H */
diff --git a/include/linux/netfilter_ipv4/ip_conntrack.h b/include/linux/netfilter_ipv4/ip_conntrack.h
index 3781192ce159..08fe5f7d14a0 100644
--- a/include/linux/netfilter_ipv4/ip_conntrack.h
+++ b/include/linux/netfilter_ipv4/ip_conntrack.h
@@ -197,6 +197,9 @@ struct ip_conntrack_expect
        /* Timer function; deletes the expectation. */
        struct timer_list timeout;
+        /* Usage count. */
+        atomic_t use;
 #ifdef CONFIG_IP_NF_NAT_NEEDED
        /* This is the original per-proto part, used to map the
         * expected connection the way the recipient expects. */
@@ -236,7 +239,7 @@ ip_conntrack_get(const struct sk_buff *skb, enum ip_conntrack_info *ctinfo)
 }
 /* decrement reference count on a conntrack */
-extern inline void ip_conntrack_put(struct ip_conntrack *ct);
+extern void ip_conntrack_put(struct ip_conntrack *ct);
 /* call to create an explicit dependency on ip_conntrack. */
 extern void need_ip_conntrack(void);
diff --git a/include/linux/netfilter_ipv4/ip_conntrack_helper.h b/include/linux/netfilter_ipv4/ip_conntrack_helper.h
index b1bbba0a12cb..3692daa93dec 100644
--- a/include/linux/netfilter_ipv4/ip_conntrack_helper.h
+++ b/include/linux/netfilter_ipv4/ip_conntrack_helper.h
@@ -30,9 +30,10 @@ extern int ip_conntrack_helper_register(struct ip_conntrack_helper *);
 extern void ip_conntrack_helper_unregister(struct ip_conntrack_helper *);
 /* Allocate space for an expectation: this is mandatory before calling 
-   ip_conntrack_expect_related. */
+   ip_conntrack_expect_related.  You will have to call put afterwards. */
-extern struct ip_conntrack_expect *ip_conntrack_expect_alloc(void);
+extern struct ip_conntrack_expect *
-extern void ip_conntrack_expect_free(struct ip_conntrack_expect *exp);
+ip_conntrack_expect_alloc(struct ip_conntrack *master);
+extern void ip_conntrack_expect_put(struct ip_conntrack_expect *exp);
 /* Add an expected connection: can have more than one per connection */
 extern int ip_conntrack_expect_related(struct ip_conntrack_expect *exp);
diff --git a/include/linux/netfilter_ipv4/ipt_CLUSTERIP.h b/include/linux/netfilter_ipv4/ipt_CLUSTERIP.h
index baa83e757156..d9bceedfb3dc 100644
--- a/include/linux/netfilter_ipv4/ipt_CLUSTERIP.h
+++ b/include/linux/netfilter_ipv4/ipt_CLUSTERIP.h
@@ -18,7 +18,6 @@ struct clusterip_config;
 struct ipt_clusterip_tgt_info {
        u_int32_t flags;
-        struct clusterip_config *config;
        
        /* only relevant for new ones */
        u_int8_t clustermac[6];
@@ -27,6 +26,8 @@ struct ipt_clusterip_tgt_info {
        u_int16_t local_nodes[CLUSTERIP_MAX_NODES];
        enum clusterip_hashmode hash_mode;
        u_int32_t hash_initval;
+        struct clusterip_config *config;
 };
 #endif /*_IPT_CLUSTERIP_H_target*/
diff --git a/include/linux/netlink.h b/include/linux/netlink.h
index 3029cad63a01..6552b71bfa73 100644
--- a/include/linux/netlink.h
+++ b/include/linux/netlink.h
@@ -5,21 +5,20 @@
 #include <linux/types.h>
 #define NETLINK_ROUTE           0       /* Routing/device hook                          */
-#define NETLINK_SKIP            1       /* Reserved for ENskip                          */
+#define NETLINK_W1              1       /* 1-wire subsystem                             */
 #define NETLINK_USERSOCK        2       /* Reserved for user mode socket protocols      */
 #define NETLINK_FIREWALL        3       /* Firewalling hook                             */
 #define NETLINK_TCPDIAG         4       /* TCP socket monitoring                        */
 #define NETLINK_NFLOG           5       /* netfilter/iptables ULOG */
 #define NETLINK_XFRM            6       /* ipsec */
 #define NETLINK_SELINUX         7       /* SELinux event notifications */
-#define NETLINK_ARPD            8
+#define NETLINK_ISCSI           8       /* Open-iSCSI */
 #define NETLINK_AUDIT           9       /* auditing */
 #define NETLINK_FIB_LOOKUP      10      
-#define NETLINK_ROUTE6          11      /* af_inet6 route comm channel */
+#define NETLINK_NETFILTER       12      /* netfilter subsystem */
 #define NETLINK_IP6_FW          13
 #define NETLINK_DNRTMSG         14      /* DECnet routing messages */
 #define NETLINK_KOBJECT_UEVENT  15      /* Kernel messages to userspace */
-#define NETLINK_TAPBASE         16      /* 16 to 31 are ethertap */
 #define MAX_LINKS 32            
@@ -168,6 +167,7 @@ __nlmsg_put(struct sk_buff *skb, u32 pid, u32 seq, int type, int len, int flags)
        nlh->nlmsg_flags = flags;
        nlh->nlmsg_pid = pid;
        nlh->nlmsg_seq = seq;
+        memset(NLMSG_DATA(nlh) + len, 0, NLMSG_ALIGN(size) - size);
        return nlh;
 }
diff --git a/include/linux/netpoll.h b/include/linux/netpoll.h
index c0d8b90c5202..5ade54a78dbb 100644
--- a/include/linux/netpoll.h
+++ b/include/linux/netpoll.h
@@ -9,6 +9,7 @@
 #include <linux/netdevice.h>
 #include <linux/interrupt.h>
+#include <linux/rcupdate.h>
 #include <linux/list.h>
 struct netpoll;
@@ -16,14 +17,20 @@ struct netpoll;
 struct netpoll {
        struct net_device *dev;
        char dev_name[16], *name;
-        int rx_flags;
        void (*rx_hook)(struct netpoll *, int, char *, int);
        void (*drop)(struct sk_buff *skb);
        u32 local_ip, remote_ip;
        u16 local_port, remote_port;
        unsigned char local_mac[6], remote_mac[6];
+};
+struct netpoll_info {
        spinlock_t poll_lock;
        int poll_owner;
+        int tries;
+        int rx_flags;
+        spinlock_t rx_lock;
+        struct netpoll *rx_np; /* netpoll that registered an rx_hook */
 };
 void netpoll_poll(struct netpoll *np);
@@ -39,28 +46,47 @@ void netpoll_queue(struct sk_buff *skb);
 #ifdef CONFIG_NETPOLL
 static inline int netpoll_rx(struct sk_buff *skb)
 {
-        return skb->dev->np && skb->dev->np->rx_flags && __netpoll_rx(skb);
+        struct netpoll_info *npinfo = skb->dev->npinfo;
+        unsigned long flags;
+        int ret = 0;
+        if (!npinfo || (!npinfo->rx_np && !npinfo->rx_flags))
+                return 0;
+        spin_lock_irqsave(&npinfo->rx_lock, flags);
+        /* check rx_flags again with the lock held */
+        if (npinfo->rx_flags && __netpoll_rx(skb))
+                ret = 1;
+        spin_unlock_irqrestore(&npinfo->rx_lock, flags);
+        return ret;
 }
-static inline void netpoll_poll_lock(struct net_device *dev)
+static inline void *netpoll_poll_lock(struct net_device *dev)
 {
-        if (dev->np) {
+        rcu_read_lock(); /* deal with race on ->npinfo */
-                spin_lock(&dev->np->poll_lock);
+        if (dev->npinfo) {
-                dev->np->poll_owner = smp_processor_id();
+                spin_lock(&dev->npinfo->poll_lock);
+                dev->npinfo->poll_owner = smp_processor_id();
+                return dev->npinfo;
        }
+        return NULL;
 }
-static inline void netpoll_poll_unlock(struct net_device *dev)
+static inline void netpoll_poll_unlock(void *have)
 {
-        if (dev->np) {
+        struct netpoll_info *npi = have;
-                spin_unlock(&dev->np->poll_lock);
-                dev->np->poll_owner = -1;
+        if (npi) {
+                npi->poll_owner = -1;
+                spin_unlock(&npi->poll_lock);
        }
+        rcu_read_unlock();
 }
 #else
 #define netpoll_rx(a) 0
-#define netpoll_poll_lock(a)
+#define netpoll_poll_lock(a) 0
 #define netpoll_poll_unlock(a)
 #endif
diff --git a/include/linux/nfs4.h b/include/linux/nfs4.h
index 5ca8a8d8ccdf..0c1c306cdaec 100644
--- a/include/linux/nfs4.h
+++ b/include/linux/nfs4.h
@@ -28,7 +28,7 @@
 #define NFS4_ACCESS_DELETE      0x0010
 #define NFS4_ACCESS_EXECUTE     0x0020
-#define NFS4_FH_PERISTENT               0x0000
+#define NFS4_FH_PERSISTENT              0x0000
 #define NFS4_FH_NOEXPIRE_WITH_OPEN      0x0001
 #define NFS4_FH_VOLATILE_ANY            0x0002
 #define NFS4_FH_VOL_MIGRATION           0x0004
@@ -382,6 +382,8 @@ enum {
        NFSPROC4_CLNT_READDIR,
        NFSPROC4_CLNT_SERVER_CAPS,
        NFSPROC4_CLNT_DELEGRETURN,
+        NFSPROC4_CLNT_GETACL,
+        NFSPROC4_CLNT_SETACL,
 };
 #endif
diff --git a/include/linux/nfs_fs.h b/include/linux/nfs_fs.h
index dbac7f363e5d..9a6047ff1b25 100644
--- a/include/linux/nfs_fs.h
+++ b/include/linux/nfs_fs.h
@@ -15,7 +15,6 @@
 #include <linux/pagemap.h>
 #include <linux/rwsem.h>
 #include <linux/wait.h>
-#include <linux/uio.h>
 #include <linux/nfs_fs_sb.h>
@@ -29,7 +28,6 @@
 #include <linux/nfs4.h>
 #include <linux/nfs_xdr.h>
 #include <linux/rwsem.h>
-#include <linux/workqueue.h>
 #include <linux/mempool.h>
 /*
@@ -44,13 +42,6 @@
 #define NFS_DEF_FILE_IO_BUFFER_SIZE     4096
 /*
- * The upper limit on timeouts for the exponential backoff algorithm.
- */
-#define NFS_WRITEBACK_DELAY             (5*HZ)
-#define NFS_WRITEBACK_LOCKDELAY         (60*HZ)
-#define NFS_COMMIT_DELAY                (5*HZ)
-/*
 * superblock magic number for NFS
 */
 #define NFS_SUPER_MAGIC                 0x6969
@@ -60,9 +51,6 @@
 */
 #define NFS_RPC_SWAPFLAGS               (RPC_TASK_SWAPPER|RPC_TASK_ROOTCREDS)
-#define NFS_RW_SYNC             0x0001  /* O_SYNC handling */
-#define NFS_RW_SWAP             0x0002  /* This is a swap request */
 /*
 * When flushing a cluster of dirty pages, there can be different
 * strategies:
@@ -96,7 +84,8 @@ struct nfs_open_context {
        int error;
        struct list_head list;
-        wait_queue_head_t waitq;
+        __u64 dir_cookie;
 };
 /*
@@ -104,6 +93,8 @@ struct nfs_open_context {
 */
 struct nfs_delegation;
+struct posix_acl;
 /*
 * nfs fs inode data in memory
 */
@@ -121,7 +112,8 @@ struct nfs_inode {
        /*
         * Various flags
         */
-        unsigned int            flags;
+        unsigned long           flags;                  /* atomic bit ops */
+        unsigned long           cache_validity;         /* bit mask */
        /*
         * read_cache_jiffies is when we started read-caching this inode,
@@ -140,7 +132,6 @@ struct nfs_inode {
         *
         *      mtime != read_cache_mtime
         */
-        unsigned long           readdir_timestamp;
        unsigned long           read_cache_jiffies;
        unsigned long           attrtimeo;
        unsigned long           attrtimeo_timestamp;
@@ -158,6 +149,10 @@ struct nfs_inode {
        atomic_t                data_updates;
        struct nfs_access_entry cache_access;
+#ifdef CONFIG_NFS_V3_ACL
+        struct posix_acl        *acl_access;
+        struct posix_acl        *acl_default;
+#endif
        /*
         * This is the cookie verifier used for NFSv3 readdir
@@ -180,29 +175,33 @@ struct nfs_inode {
        /* Open contexts for shared mmap writes */
        struct list_head        open_files;
-        wait_queue_head_t       nfs_i_wait;
 #ifdef CONFIG_NFS_V4
+        struct nfs4_cached_acl  *nfs4_acl;
        /* NFSv4 state */
        struct list_head        open_states;
        struct nfs_delegation   *delegation;
        int                      delegation_state;
        struct rw_semaphore     rwsem;
 #endif /* CONFIG_NFS_V4*/
        struct inode            vfs_inode;
 };
 /*
- * Legal inode flag values
+ * Cache validity bit flags
+ */
+#define NFS_INO_INVALID_ATTR    0x0001          /* cached attrs are invalid */
+#define NFS_INO_INVALID_DATA    0x0002          /* cached data is invalid */
+#define NFS_INO_INVALID_ATIME   0x0004          /* cached atime is invalid */
+#define NFS_INO_INVALID_ACCESS  0x0008          /* cached access cred invalid */
+#define NFS_INO_INVALID_ACL     0x0010          /* cached acls are invalid */
+#define NFS_INO_REVAL_PAGECACHE 0x0020          /* must revalidate pagecache */
+/*
+ * Bit offsets in flags field
 */
-#define NFS_INO_STALE           0x0001          /* possible stale inode */
+#define NFS_INO_REVALIDATING    (0)             /* revalidating attrs */
-#define NFS_INO_ADVISE_RDPLUS   0x0002          /* advise readdirplus */
+#define NFS_INO_ADVISE_RDPLUS   (1)             /* advise readdirplus */
-#define NFS_INO_REVALIDATING    0x0004          /* revalidating attrs */
+#define NFS_INO_STALE           (2)             /* possible stale inode */
-#define NFS_INO_INVALID_ATTR    0x0008          /* cached attrs are invalid */
-#define NFS_INO_INVALID_DATA    0x0010          /* cached data is invalid */
-#define NFS_INO_INVALID_ATIME   0x0020          /* cached atime is invalid */
-#define NFS_INO_INVALID_ACCESS  0x0040          /* cached access cred invalid */
 static inline struct nfs_inode *NFS_I(struct inode *inode)
 {
@@ -228,8 +227,7 @@ static inline struct nfs_inode *NFS_I(struct inode *inode)
 #define NFS_ATTRTIMEO_UPDATE(inode)     (NFS_I(inode)->attrtimeo_timestamp)
 #define NFS_FLAGS(inode)                (NFS_I(inode)->flags)
-#define NFS_REVALIDATING(inode)         (NFS_FLAGS(inode) & NFS_INO_REVALIDATING)
+#define NFS_STALE(inode)                (test_bit(NFS_INO_STALE, &NFS_FLAGS(inode)))
-#define NFS_STALE(inode)                (NFS_FLAGS(inode) & NFS_INO_STALE)
 #define NFS_FILEID(inode)               (NFS_I(inode)->fileid)
@@ -240,8 +238,11 @@ static inline int nfs_caches_unstable(struct inode *inode)
 static inline void NFS_CACHEINV(struct inode *inode)
 {
-        if (!nfs_caches_unstable(inode))
+        if (!nfs_caches_unstable(inode)) {
-                NFS_FLAGS(inode) |= NFS_INO_INVALID_ATTR | NFS_INO_INVALID_ACCESS;
+                spin_lock(&inode->i_lock);
+                NFS_I(inode)->cache_validity |= NFS_INO_INVALID_ATTR | NFS_INO_INVALID_ACCESS;
+                spin_unlock(&inode->i_lock);
+        }
 }
 static inline int nfs_server_capable(struct inode *inode, int cap)
@@ -251,7 +252,7 @@ static inline int nfs_server_capable(struct inode *inode, int cap)
 static inline int NFS_USE_READDIRPLUS(struct inode *inode)
 {
-        return NFS_FLAGS(inode) & NFS_INO_ADVISE_RDPLUS;
+        return test_bit(NFS_INO_ADVISE_RDPLUS, &NFS_FLAGS(inode));
 }
 /**
@@ -294,12 +295,13 @@ extern int nfs_release(struct inode *, struct file *);
 extern int nfs_attribute_timeout(struct inode *inode);
 extern int nfs_revalidate_inode(struct nfs_server *server, struct inode *inode);
 extern int __nfs_revalidate_inode(struct nfs_server *, struct inode *);
+extern void nfs_revalidate_mapping(struct inode *inode, struct address_space *mapping);
 extern int nfs_setattr(struct dentry *, struct iattr *);
+extern void nfs_setattr_update_inode(struct inode *inode, struct iattr *attr);
 extern void nfs_begin_attr_update(struct inode *);
 extern void nfs_end_attr_update(struct inode *);
 extern void nfs_begin_data_update(struct inode *);
 extern void nfs_end_data_update(struct inode *);
-extern void nfs_end_data_update_defer(struct inode *);
 extern struct nfs_open_context *alloc_nfs_open_context(struct dentry *dentry, struct rpc_cred *cred);
 extern struct nfs_open_context *get_nfs_open_context(struct nfs_open_context *ctx);
 extern void put_nfs_open_context(struct nfs_open_context *ctx);
@@ -314,6 +316,9 @@ extern u32 root_nfs_parse_addr(char *name); /*__init*/
 * linux/fs/nfs/file.c
 */
 extern struct inode_operations nfs_file_inode_operations;
+#ifdef CONFIG_NFS_V3
+extern struct inode_operations nfs3_file_inode_operations;
+#endif /* CONFIG_NFS_V3 */
 extern struct file_operations nfs_file_operations;
 extern struct address_space_operations nfs_file_aops;
@@ -329,6 +334,22 @@ static inline struct rpc_cred *nfs_file_cred(struct file *file)
 }
 /*
+ * linux/fs/nfs/xattr.c
+ */
+#ifdef CONFIG_NFS_V3_ACL
+extern ssize_t nfs3_listxattr(struct dentry *, char *, size_t);
+extern ssize_t nfs3_getxattr(struct dentry *, const char *, void *, size_t);
+extern int nfs3_setxattr(struct dentry *, const char *,
+                        const void *, size_t, int);
+extern int nfs3_removexattr (struct dentry *, const char *name);
+#else
+# define nfs3_listxattr NULL
+# define nfs3_getxattr NULL
+# define nfs3_setxattr NULL
+# define nfs3_removexattr NULL
+#endif
+/*
 * linux/fs/nfs/direct.c
 */
 extern ssize_t nfs_direct_IO(int, struct kiocb *, const struct iovec *, loff_t,
@@ -342,6 +363,9 @@ extern ssize_t nfs_file_direct_write(struct kiocb *iocb, const char __user *buf,
 * linux/fs/nfs/dir.c
 */
 extern struct inode_operations nfs_dir_inode_operations;
+#ifdef CONFIG_NFS_V3
+extern struct inode_operations nfs3_dir_inode_operations;
+#endif /* CONFIG_NFS_V3 */
 extern struct file_operations nfs_dir_operations;
 extern struct dentry_operations nfs_dentry_operations;
@@ -377,10 +401,10 @@ extern void nfs_commit_done(struct rpc_task *);
 */
 extern int  nfs_sync_inode(struct inode *, unsigned long, unsigned int, int);
 #if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4)
-extern int  nfs_commit_inode(struct inode *, unsigned long, unsigned int, int);
+extern int  nfs_commit_inode(struct inode *, int);
 #else
 static inline int
-nfs_commit_inode(struct inode *inode, unsigned long idx_start, unsigned int npages, int how)
+nfs_commit_inode(struct inode *inode, int how)
 {
        return 0;
 }
@@ -434,11 +458,6 @@ static inline void nfs_writedata_free(struct nfs_write_data *p)
        mempool_free(p, nfs_wdata_mempool);
 }
-/* Hack for future NFS swap support */
-#ifndef IS_SWAPFILE
-# define IS_SWAPFILE(inode)     (0)
-#endif
 /*
 * linux/fs/nfs/read.c
 */
@@ -468,6 +487,29 @@ static inline void nfs_readdata_free(struct nfs_read_data *p)
 extern void  nfs_readdata_release(struct rpc_task *task);
 /*
+ * linux/fs/nfs3proc.c
+ */
+#ifdef CONFIG_NFS_V3_ACL
+extern struct posix_acl *nfs3_proc_getacl(struct inode *inode, int type);
+extern int nfs3_proc_setacl(struct inode *inode, int type,
+                            struct posix_acl *acl);
+extern int nfs3_proc_set_default_acl(struct inode *dir, struct inode *inode,
+                mode_t mode);
+extern void nfs3_forget_cached_acls(struct inode *inode);
+#else
+static inline int nfs3_proc_set_default_acl(struct inode *dir,
+                                            struct inode *inode,
+                                            mode_t mode)
+{
+        return 0;
+}
+static inline void nfs3_forget_cached_acls(struct inode *inode)
+{
+}
+#endif /* CONFIG_NFS_V3_ACL */
+/*
 * linux/fs/mount_clnt.c
 * (Used only by nfsroot module)
 */
@@ -515,230 +557,6 @@ extern void * nfs_root_data(void);
 #define NFS_JUKEBOX_RETRY_TIME (5 * HZ)
-#ifdef CONFIG_NFS_V4
-struct idmap;
-/*
- * In a seqid-mutating op, this macro controls which error return
- * values trigger incrementation of the seqid.
- *
- * from rfc 3010:
- * The client MUST monotonically increment the sequence number for the
- * CLOSE, LOCK, LOCKU, OPEN, OPEN_CONFIRM, and OPEN_DOWNGRADE
- * operations.  This is true even in the event that the previous
- * operation that used the sequence number received an error.  The only
- * exception to this rule is if the previous operation received one of
- * the following errors: NFSERR_STALE_CLIENTID, NFSERR_STALE_STATEID,
- * NFSERR_BAD_STATEID, NFSERR_BAD_SEQID, NFSERR_BADXDR,
- * NFSERR_RESOURCE, NFSERR_NOFILEHANDLE.
- *
- */
-#define seqid_mutating_err(err)       \
-(((err) != NFSERR_STALE_CLIENTID) &&  \
- ((err) != NFSERR_STALE_STATEID)  &&  \
- ((err) != NFSERR_BAD_STATEID)    &&  \
- ((err) != NFSERR_BAD_SEQID)      &&  \
- ((err) != NFSERR_BAD_XDR)        &&  \
- ((err) != NFSERR_RESOURCE)       &&  \
- ((err) != NFSERR_NOFILEHANDLE))
-enum nfs4_client_state {
-        NFS4CLNT_OK  = 0,
-};
-/*
- * The nfs4_client identifies our client state to the server.
- */
-struct nfs4_client {
-        struct list_head        cl_servers;     /* Global list of servers */
-        struct in_addr          cl_addr;        /* Server identifier */
-        u64                     cl_clientid;    /* constant */
-        nfs4_verifier           cl_confirm;
-        unsigned long           cl_state;
-        u32                     cl_lockowner_id;
-        /*
-         * The following rwsem ensures exclusive access to the server
-         * while we recover the state following a lease expiration.
-         */
-        struct rw_semaphore     cl_sem;
-        struct list_head        cl_delegations;
-        struct list_head        cl_state_owners;
-        struct list_head        cl_unused;
-        int                     cl_nunused;
-        spinlock_t              cl_lock;
-        atomic_t                cl_count;
-        struct rpc_clnt *       cl_rpcclient;
-        struct rpc_cred *       cl_cred;
-        struct list_head        cl_superblocks; /* List of nfs_server structs */
-        unsigned long           cl_lease_time;
-        unsigned long           cl_last_renewal;
-        struct work_struct      cl_renewd;
-        struct work_struct      cl_recoverd;
-        wait_queue_head_t       cl_waitq;
-        struct rpc_wait_queue   cl_rpcwaitq;
-        /* used for the setclientid verifier */
-        struct timespec         cl_boot_time;
-        /* idmapper */
-        struct idmap *          cl_idmap;
-        /* Our own IP address, as a null-terminated string.
-         * This is used to generate the clientid, and the callback address.
-         */
-        char                    cl_ipaddr[16];
-        unsigned char           cl_id_uniquifier;
-};
-/*
- * NFS4 state_owners and lock_owners are simply labels for ordered
- * sequences of RPC calls. Their sole purpose is to provide once-only
- * semantics by allowing the server to identify replayed requests.
- *
- * The ->so_sema is held during all state_owner seqid-mutating operations:
- * OPEN, OPEN_DOWNGRADE, and CLOSE. Its purpose is to properly serialize
- * so_seqid.
- */
-struct nfs4_state_owner {
-        struct list_head     so_list;    /* per-clientid list of state_owners */
-        struct nfs4_client   *so_client;
-        u32                  so_id;      /* 32-bit identifier, unique */
-        struct semaphore     so_sema;
-        u32                  so_seqid;   /* protected by so_sema */
-        atomic_t             so_count;
-        struct rpc_cred      *so_cred;   /* Associated cred */
-        struct list_head     so_states;
-        struct list_head     so_delegations;
-};
-/*
- * struct nfs4_state maintains the client-side state for a given
- * (state_owner,inode) tuple (OPEN) or state_owner (LOCK).
- *
- * OPEN:
- * In order to know when to OPEN_DOWNGRADE or CLOSE the state on the server,
- * we need to know how many files are open for reading or writing on a
- * given inode. This information too is stored here.
- *
- * LOCK: one nfs4_state (LOCK) to hold the lock stateid nfs4_state(OPEN)
- */
-struct nfs4_lock_state {
-        struct list_head        ls_locks;       /* Other lock stateids */
-        fl_owner_t              ls_owner;       /* POSIX lock owner */
-#define NFS_LOCK_INITIALIZED 1
-        int                     ls_flags;
-        u32                     ls_seqid;
-        u32                     ls_id;
-        nfs4_stateid            ls_stateid;
-        atomic_t                ls_count;
-};
-/* bits for nfs4_state->flags */
-enum {
-        LK_STATE_IN_USE,
-        NFS_DELEGATED_STATE,
-};
-struct nfs4_state {
-        struct list_head open_states;   /* List of states for the same state_owner */
-        struct list_head inode_states;  /* List of states for the same inode */
-        struct list_head lock_states;   /* List of subservient lock stateids */
-        struct nfs4_state_owner *owner; /* Pointer to the open owner */
-        struct inode *inode;            /* Pointer to the inode */
-        unsigned long flags;            /* Do we hold any locks? */
-        struct semaphore lock_sema;     /* Serializes file locking operations */
-        rwlock_t state_lock;            /* Protects the lock_states list */
-        nfs4_stateid stateid;
-        unsigned int nreaders;
-        unsigned int nwriters;
-        int state;                      /* State on the server (R,W, or RW) */
-        atomic_t count;
-};
-struct nfs4_exception {
-        long timeout;
-        int retry;
-};
-struct nfs4_state_recovery_ops {
-        int (*recover_open)(struct nfs4_state_owner *, struct nfs4_state *);
-        int (*recover_lock)(struct nfs4_state *, struct file_lock *);
-};
-extern struct dentry_operations nfs4_dentry_operations;
-extern struct inode_operations nfs4_dir_inode_operations;
-/* nfs4proc.c */
-extern int nfs4_map_errors(int err);
-extern int nfs4_proc_setclientid(struct nfs4_client *, u32, unsigned short);
-extern int nfs4_proc_setclientid_confirm(struct nfs4_client *);
-extern int nfs4_proc_async_renew(struct nfs4_client *);
-extern int nfs4_proc_renew(struct nfs4_client *);
-extern int nfs4_do_close(struct inode *inode, struct nfs4_state *state, mode_t mode);
-extern struct inode *nfs4_atomic_open(struct inode *, struct dentry *, struct nameidata *);
-extern int nfs4_open_revalidate(struct inode *, struct dentry *, int);
-extern struct nfs4_state_recovery_ops nfs4_reboot_recovery_ops;
-extern struct nfs4_state_recovery_ops nfs4_network_partition_recovery_ops;
-/* nfs4renewd.c */
-extern void nfs4_schedule_state_renewal(struct nfs4_client *);
-extern void nfs4_renewd_prepare_shutdown(struct nfs_server *);
-extern void nfs4_kill_renewd(struct nfs4_client *);
-/* nfs4state.c */
-extern void init_nfsv4_state(struct nfs_server *);
-extern void destroy_nfsv4_state(struct nfs_server *);
-extern struct nfs4_client *nfs4_get_client(struct in_addr *);
-extern void nfs4_put_client(struct nfs4_client *clp);
-extern int nfs4_init_client(struct nfs4_client *clp);
-extern struct nfs4_client *nfs4_find_client(struct in_addr *);
-extern u32 nfs4_alloc_lockowner_id(struct nfs4_client *);
-extern struct nfs4_state_owner * nfs4_get_state_owner(struct nfs_server *, struct rpc_cred *);
-extern void nfs4_put_state_owner(struct nfs4_state_owner *);
-extern void nfs4_drop_state_owner(struct nfs4_state_owner *);
-extern struct nfs4_state * nfs4_get_open_state(struct inode *, struct nfs4_state_owner *);
-extern void nfs4_put_open_state(struct nfs4_state *);
-extern void nfs4_close_state(struct nfs4_state *, mode_t);
-extern struct nfs4_state *nfs4_find_state(struct inode *, struct rpc_cred *, mode_t mode);
-extern void nfs4_increment_seqid(int status, struct nfs4_state_owner *sp);
-extern void nfs4_schedule_state_recovery(struct nfs4_client *);
-extern struct nfs4_lock_state *nfs4_find_lock_state(struct nfs4_state *state, fl_owner_t);
-extern struct nfs4_lock_state *nfs4_get_lock_state(struct nfs4_state *state, fl_owner_t);
-extern void nfs4_put_lock_state(struct nfs4_lock_state *state);
-extern void nfs4_increment_lock_seqid(int status, struct nfs4_lock_state *ls);
-extern void nfs4_notify_setlk(struct nfs4_state *, struct file_lock *, struct nfs4_lock_state *);
-extern void nfs4_notify_unlck(struct nfs4_state *, struct file_lock *, struct nfs4_lock_state *);
-extern void nfs4_copy_stateid(nfs4_stateid *, struct nfs4_state *, fl_owner_t);
-struct nfs4_mount_data;
-#else
-#define init_nfsv4_state(server)  do { } while (0)
-#define destroy_nfsv4_state(server)       do { } while (0)
-#define nfs4_put_state_owner(inode, owner) do { } while (0)
-#define nfs4_put_open_state(state) do { } while (0)
-#define nfs4_close_state(a, b) do { } while (0)
-#define nfs4_renewd_prepare_shutdown(server) do { } while (0)
-#endif
 #endif /* __KERNEL__ */
 /*
diff --git a/include/linux/nfs_fs_i.h b/include/linux/nfs_fs_i.h
index e9a749588a7b..e2c18dabff86 100644
--- a/include/linux/nfs_fs_i.h
+++ b/include/linux/nfs_fs_i.h
@@ -16,6 +16,11 @@ struct nfs_lock_info {
        struct nlm_lockowner *owner;
 };
+struct nfs4_lock_state;
+struct nfs4_lock_info {
+        struct nfs4_lock_state *owner;
+};
 /*
 * Lock flag values
 */
diff --git a/include/linux/nfs_fs_sb.h b/include/linux/nfs_fs_sb.h
index fc51645d61ee..3d3a305488cf 100644
--- a/include/linux/nfs_fs_sb.h
+++ b/include/linux/nfs_fs_sb.h
@@ -10,6 +10,7 @@
 struct nfs_server {
        struct rpc_clnt *       client;         /* RPC client handle */
        struct rpc_clnt *       client_sys;     /* 2nd handle for FSINFO */
+        struct rpc_clnt *       client_acl;     /* ACL RPC client handle */
        struct nfs_rpc_ops *    rpc_ops;        /* NFS protocol vector */
        struct backing_dev_info backing_dev_info;
        int                     flags;          /* various flags */
diff --git a/include/linux/nfs_mount.h b/include/linux/nfs_mount.h
index 0071428231f9..659c75438454 100644
--- a/include/linux/nfs_mount.h
+++ b/include/linux/nfs_mount.h
@@ -58,6 +58,7 @@ struct nfs_mount_data {
 #define NFS_MOUNT_KERBEROS      0x0100  /* 3 */
 #define NFS_MOUNT_NONLM         0x0200  /* 3 */
 #define NFS_MOUNT_BROKEN_SUID   0x0400  /* 4 */
+#define NFS_MOUNT_NOACL         0x0800  /* 4 */
 #define NFS_MOUNT_STRICTLOCK    0x1000  /* reserved for NFSv4 */
 #define NFS_MOUNT_SECFLAVOUR    0x2000  /* 5 */
 #define NFS_MOUNT_FLAGMASK      0xFFFF
diff --git a/include/linux/nfs_page.h b/include/linux/nfs_page.h
index 39e4895bcdb4..da2e077b65e2 100644
--- a/include/linux/nfs_page.h
+++ b/include/linux/nfs_page.h
@@ -20,12 +20,19 @@
 #include <asm/atomic.h>
 /*
+ * Valid flags for the radix tree
+ */
+#define NFS_PAGE_TAG_DIRTY      0
+#define NFS_PAGE_TAG_WRITEBACK  1
+/*
 * Valid flags for a dirty buffer
 */
 #define PG_BUSY                 0
 #define PG_NEED_COMMIT          1
 #define PG_NEED_RESCHED         2
+struct nfs_inode;
 struct nfs_page {
        struct list_head        wb_list,        /* Defines state of page: */
                                *wb_list_head;  /*      read/write/commit */
@@ -54,14 +61,17 @@ extern	void nfs_clear_request(struct nfs_page *req);
 extern  void nfs_release_request(struct nfs_page *req);
-extern  void nfs_list_add_request(struct nfs_page *, struct list_head *);
+extern  int nfs_scan_lock_dirty(struct nfs_inode *nfsi, struct list_head *dst,
+                                unsigned long idx_start, unsigned int npages);
 extern  int nfs_scan_list(struct list_head *, struct list_head *,
                          unsigned long, unsigned int);
 extern  int nfs_coalesce_requests(struct list_head *, struct list_head *,
                                  unsigned int);
 extern  int nfs_wait_on_request(struct nfs_page *);
 extern  void nfs_unlock_request(struct nfs_page *req);
+extern  int nfs_set_page_writeback_locked(struct nfs_page *req);
+extern  void nfs_clear_page_writeback(struct nfs_page *req);
 /*
 * Lock the page of an asynchronous request without incrementing the wb_count
@@ -86,6 +96,18 @@ nfs_lock_request(struct nfs_page *req)
        return 1;
 }
+/**
+ * nfs_list_add_request - Insert a request into a list
+ * @req: request
+ * @head: head of list into which to insert the request.
+ */
+static inline void
+nfs_list_add_request(struct nfs_page *req, struct list_head *head)
+{
+        list_add_tail(&req->wb_list, head);
+        req->wb_list_head = head;
+}
 /**
 * nfs_list_remove_request - Remove a request from its wb_list
@@ -96,10 +118,6 @@ nfs_list_remove_request(struct nfs_page *req)
 {
        if (list_empty(&req->wb_list))
                return;
-        if (!NFS_WBACK_BUSY(req)) {
-                printk(KERN_ERR "NFS: unlocked request attempted removed from list!\n");
-                BUG();
-        }
        list_del_init(&req->wb_list);
        req->wb_list_head = NULL;
 }
diff --git a/include/linux/nfs_xdr.h b/include/linux/nfs_xdr.h
index 47037d9521cb..a2bf6914ff1b 100644
--- a/include/linux/nfs_xdr.h
+++ b/include/linux/nfs_xdr.h
@@ -2,6 +2,7 @@
 #define _LINUX_NFS_XDR_H
 #include <linux/sunrpc/xprt.h>
+#include <linux/nfsacl.h>
 struct nfs4_fsid {
        __u64 major;
@@ -326,6 +327,20 @@ struct nfs_setattrargs {
        const u32 *                     bitmask;
 };
+struct nfs_setaclargs {
+        struct nfs_fh *                 fh;
+        size_t                          acl_len;
+        unsigned int                    acl_pgbase;
+        struct page **                  acl_pages;
+};
+struct nfs_getaclargs {
+        struct nfs_fh *                 fh;
+        size_t                          acl_len;
+        unsigned int                    acl_pgbase;
+        struct page **                  acl_pages;
+};
 struct nfs_setattrres {
        struct nfs_fattr *              fattr;
        const struct nfs_server *       server;
@@ -354,6 +369,20 @@ struct nfs_readdirargs {
        struct page **          pages;
 };
+struct nfs3_getaclargs {
+        struct nfs_fh *         fh;
+        int                     mask;
+        struct page **          pages;
+};
+struct nfs3_setaclargs {
+        struct inode *          inode;
+        int                     mask;
+        struct posix_acl *      acl_access;
+        struct posix_acl *      acl_default;
+        struct page **          pages;
+};
 struct nfs_diropok {
        struct nfs_fh *         fh;
        struct nfs_fattr *      fattr;
@@ -477,6 +506,15 @@ struct nfs3_readdirres {
        int                     plus;
 };
+struct nfs3_getaclres {
+        struct nfs_fattr *      fattr;
+        int                     mask;
+        unsigned int            acl_access_count;
+        unsigned int            acl_default_count;
+        struct posix_acl *      acl_access;
+        struct posix_acl *      acl_default;
+};
 #ifdef CONFIG_NFS_V4
 typedef u64 clientid4;
@@ -667,6 +705,7 @@ struct nfs_rpc_ops {
        int     version;                /* Protocol version */
        struct dentry_operations *dentry_ops;
        struct inode_operations *dir_inode_ops;
+        struct inode_operations *file_inode_ops;
        int     (*getroot) (struct nfs_server *, struct nfs_fh *,
                            struct nfs_fsinfo *);
@@ -713,6 +752,7 @@ struct nfs_rpc_ops {
        int     (*file_open)   (struct inode *, struct file *);
        int     (*file_release) (struct inode *, struct file *);
        int     (*lock)(struct file *, int, struct file_lock *);
+        void    (*clear_acl_cache)(struct inode *);
 };
 /*
@@ -732,4 +772,7 @@ extern struct rpc_version	nfs_version2;
 extern struct rpc_version       nfs_version3;
 extern struct rpc_version       nfs_version4;
+extern struct rpc_version       nfsacl_version3;
+extern struct rpc_program       nfsacl_program;
 #endif
diff --git a/include/linux/nfsacl.h b/include/linux/nfsacl.h
new file mode 100644
index 000000000000..54487a99beb8
--- /dev/null
+++ b/include/linux/nfsacl.h
@@ -0,0 +1,58 @@
+/*
+ * File: linux/nfsacl.h
+ *
+ * (C) 2003 Andreas Gruenbacher <agruen@suse.de>
+ */
+#ifndef __LINUX_NFSACL_H
+#define __LINUX_NFSACL_H
+#define NFS_ACL_PROGRAM 100227
+#define ACLPROC2_GETACL         1
+#define ACLPROC2_SETACL         2
+#define ACLPROC2_GETATTR        3
+#define ACLPROC2_ACCESS         4
+#define ACLPROC3_GETACL         1
+#define ACLPROC3_SETACL         2
+/* Flags for the getacl/setacl mode */
+#define NFS_ACL                 0x0001
+#define NFS_ACLCNT              0x0002
+#define NFS_DFACL               0x0004
+#define NFS_DFACLCNT            0x0008
+/* Flag for Default ACL entries */
+#define NFS_ACL_DEFAULT         0x1000
+#ifdef __KERNEL__
+#include <linux/posix_acl.h>
+/* Maximum number of ACL entries over NFS */
+#define NFS_ACL_MAX_ENTRIES     1024
+#define NFSACL_MAXWORDS         (2*(2+3*NFS_ACL_MAX_ENTRIES))
+#define NFSACL_MAXPAGES         ((2*(8+12*NFS_ACL_MAX_ENTRIES) + PAGE_SIZE-1) \
+                                 >> PAGE_SHIFT)
+static inline unsigned int
+nfsacl_size(struct posix_acl *acl_access, struct posix_acl *acl_default)
+{
+        unsigned int w = 16;
+        w += max(acl_access ? (int)acl_access->a_count : 3, 4) * 12;
+        if (acl_default)
+                w += max((int)acl_default->a_count, 4) * 12;
+        return w;
+}
+extern unsigned int
+nfsacl_encode(struct xdr_buf *buf, unsigned int base, struct inode *inode,
+              struct posix_acl *acl, int encode_entries, int typeflag);
+extern unsigned int
+nfsacl_decode(struct xdr_buf *buf, unsigned int base, unsigned int *aclcnt,
+              struct posix_acl **pacl);
+#endif /* __KERNEL__ */
+#endif  /* __LINUX_NFSACL_H */
diff --git a/include/linux/nfsd/nfsd.h b/include/linux/nfsd/nfsd.h
index 8f85d9a59607..6d5a24f3fc6d 100644
--- a/include/linux/nfsd/nfsd.h
+++ b/include/linux/nfsd/nfsd.h
@@ -15,6 +15,7 @@
 #include <linux/unistd.h>
 #include <linux/dirent.h>
 #include <linux/fs.h>
+#include <linux/posix_acl.h>
 #include <linux/mount.h>
 #include <linux/nfsd/debug.h>
@@ -123,21 +124,41 @@ int		nfsd_statfs(struct svc_rqst *, struct svc_fh *,
 int             nfsd_notify_change(struct inode *, struct iattr *);
 int             nfsd_permission(struct svc_export *, struct dentry *, int);
+void            nfsd_sync_dir(struct dentry *dp);
+#if defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL)
+#ifdef CONFIG_NFSD_V2_ACL
+extern struct svc_version nfsd_acl_version2;
+#else
+#define nfsd_acl_version2 NULL
+#endif
+#ifdef CONFIG_NFSD_V3_ACL
+extern struct svc_version nfsd_acl_version3;
+#else
+#define nfsd_acl_version3 NULL
+#endif
+struct posix_acl *nfsd_get_posix_acl(struct svc_fh *, int);
+int nfsd_set_posix_acl(struct svc_fh *, int, struct posix_acl *);
+#endif
 /* 
 * NFSv4 State
 */
 #ifdef CONFIG_NFSD_V4
-int nfs4_state_init(void);
+void nfs4_state_init(void);
+int nfs4_state_start(void);
 void nfs4_state_shutdown(void);
 time_t nfs4_lease_time(void);
 void nfs4_reset_lease(time_t leasetime);
+int nfs4_reset_recoverydir(char *recdir);
 #else
-static inline int nfs4_state_init(void){return 0;}
+static inline void nfs4_state_init(void){};
+static inline int nfs4_state_start(void){return 0;}
 static inline void nfs4_state_shutdown(void){}
 static inline time_t nfs4_lease_time(void){return 0;}
 static inline void nfs4_reset_lease(time_t leasetime){}
+static inline int nfs4_reset_recoverydir(char *recdir) {return 0;}
 #endif
 /*
@@ -210,6 +231,7 @@ void		nfsd_lockd_shutdown(void);
 #define nfserr_reclaim_bad      __constant_htonl(NFSERR_RECLAIM_BAD)
 #define nfserr_badname          __constant_htonl(NFSERR_BADNAME)
 #define nfserr_cb_path_down     __constant_htonl(NFSERR_CB_PATH_DOWN)
+#define nfserr_locked           __constant_htonl(NFSERR_LOCKED)
 /* error codes for internal use */
 /* if a request fails due to kmalloc failure, it gets dropped.
diff --git a/include/linux/nfsd/state.h b/include/linux/nfsd/state.h
index b6b2fe1e7c63..8bf23cf8b603 100644
--- a/include/linux/nfsd/state.h
+++ b/include/linux/nfsd/state.h
@@ -61,11 +61,6 @@ typedef struct {
 #define si_stateownerid   si_opaque.so_stateownerid
 #define si_fileid         si_opaque.so_fileid
-extern stateid_t zerostateid;
-extern stateid_t onestateid;
-#define ZERO_STATEID(stateid)       (!memcmp((stateid), &zerostateid, sizeof(stateid_t)))
-#define ONE_STATEID(stateid)        (!memcmp((stateid), &onestateid, sizeof(stateid_t)))
 struct nfs4_cb_recall {
        u32                     cbr_ident;
@@ -77,8 +72,8 @@ struct nfs4_cb_recall {
 };
 struct nfs4_delegation {
-        struct list_head        dl_del_perfile; /* nfs4_file->fi_del_perfile */
+        struct list_head        dl_perfile;
-        struct list_head        dl_del_perclnt; /* nfs4_client->cl_del_perclnt*/
+        struct list_head        dl_perclnt;
        struct list_head        dl_recall_lru;  /* delegation recalled */
        atomic_t                dl_count;       /* ref count */
        struct nfs4_client      *dl_client;
@@ -97,7 +92,6 @@ struct nfs4_delegation {
 /* client delegation callback info */
 struct nfs4_callback {
        /* SETCLIENTID info */
-        u32                     cb_parsed;  /* addr parsed */
        u32                     cb_addr;
        unsigned short          cb_port;
        u32                     cb_prog;
@@ -109,6 +103,8 @@ struct nfs4_callback {
        struct rpc_clnt *       cb_client;
 };
+#define HEXDIR_LEN     33 /* hex version of 16 byte md5 of cl_name plus '\0' */
 /*
 * struct nfs4_client - one per client.  Clientids live here.
 *      o Each nfs4_client is hashed by clientid.
@@ -122,10 +118,11 @@ struct nfs4_callback {
 struct nfs4_client {
        struct list_head        cl_idhash;      /* hash by cl_clientid.id */
        struct list_head        cl_strhash;     /* hash by cl_name */
-        struct list_head        cl_perclient;   /* list: stateowners */
+        struct list_head        cl_openowners;
-        struct list_head        cl_del_perclnt; /* list: delegations */
+        struct list_head        cl_delegations;
        struct list_head        cl_lru;         /* tail queue */
        struct xdr_netobj       cl_name;        /* id generated by client */
+        char                    cl_recdir[HEXDIR_LEN]; /* recovery dir */
        nfs4_verifier           cl_verifier;    /* generated by client */
        time_t                  cl_time;        /* time of last lease renewal */
        u32                     cl_addr;        /* client ipaddress */
@@ -134,6 +131,7 @@ struct nfs4_client {
        nfs4_verifier           cl_confirm;     /* generated by server */
        struct nfs4_callback    cl_callback;    /* callback info */
        atomic_t                cl_count;       /* ref count */
+        u32                     cl_firststate;  /* recovery dir creation */
 };
 /* struct nfs4_client_reset
@@ -143,7 +141,7 @@ struct nfs4_client {
 */
 struct nfs4_client_reclaim {
        struct list_head        cr_strhash;     /* hash by cr_name */
-        struct xdr_netobj       cr_name;        /* id generated by client */
+        char                    cr_recdir[HEXDIR_LEN]; /* recover dir */
 };
 static inline void
@@ -197,15 +195,17 @@ struct nfs4_stateowner {
        struct kref             so_ref;
        struct list_head        so_idhash;   /* hash by so_id */
        struct list_head        so_strhash;   /* hash by op_name */
-        struct list_head        so_perclient; /* nfs4_client->cl_perclient */
+        struct list_head        so_perclient;
-        struct list_head        so_perfilestate; /* list: nfs4_stateid */
+        struct list_head        so_stateids;
-        struct list_head        so_perlockowner; /* nfs4_stateid->st_perlockowner */
+        struct list_head        so_perstateid; /* for lockowners only */
        struct list_head        so_close_lru; /* tail queue */
        time_t                  so_time; /* time of placement on so_close_lru */
        int                     so_is_open_owner; /* 1=openowner,0=lockowner */
        u32                     so_id;
        struct nfs4_client *    so_client;
-        u32                     so_seqid;    
+        /* after increment in ENCODE_SEQID_OP_TAIL, represents the next
+         * sequence id expected from the client: */
+        u32                     so_seqid;
        struct xdr_netobj       so_owner;     /* open owner name */
        int                     so_confirmed; /* successful OPEN_CONFIRM? */
        struct nfs4_replay      so_replay;
@@ -217,9 +217,10 @@ struct nfs4_stateowner {
 *      share_acces, share_deny on the file.
 */
 struct nfs4_file {
+        struct kref             fi_ref;
        struct list_head        fi_hash;    /* hash by "struct inode *" */
-        struct list_head        fi_perfile; /* list: nfs4_stateid */
+        struct list_head        fi_stateids;
-        struct list_head        fi_del_perfile; /* list: nfs4_delegation */
+        struct list_head        fi_delegations;
        struct inode            *fi_inode;
        u32                     fi_id;      /* used with stateowner->so_id 
                                             * for stateid_hashtbl hash */
@@ -236,19 +237,24 @@ struct nfs4_file {
 *       st_perlockowner: (open stateid) list of lock nfs4_stateowners
 *       st_access_bmap: used only for open stateid
 *       st_deny_bmap: used only for open stateid
+*       st_openstp: open stateid lock stateid was derived from
+*
+* XXX: open stateids and lock stateids have diverged sufficiently that
+* we should consider defining separate structs for the two cases.
 */
 struct nfs4_stateid {
        struct list_head              st_hash; 
        struct list_head              st_perfile;
-        struct list_head              st_perfilestate; 
+        struct list_head              st_perstateowner;
-        struct list_head              st_perlockowner;
+        struct list_head              st_lockowners;
        struct nfs4_stateowner      * st_stateowner;
        struct nfs4_file            * st_file;
        stateid_t                     st_stateid;
        struct file                 * st_vfs_file;
        unsigned long                 st_access_bmap;
        unsigned long                 st_deny_bmap;
+        struct nfs4_stateid         * st_openstp;
 };
 /* flags for preprocess_seqid_op() */
@@ -267,12 +273,9 @@ struct nfs4_stateid {
        ((err) != nfserr_stale_stateid) &&      \
        ((err) != nfserr_bad_stateid))
-extern time_t nfs4_laundromat(void);
 extern int nfsd4_renew(clientid_t *clid);
 extern int nfs4_preprocess_stateid_op(struct svc_fh *current_fh, 
                stateid_t *stateid, int flags, struct file **filp);
-extern int nfs4_share_conflict(struct svc_fh *current_fh, 
-                unsigned int deny_type);
 extern void nfs4_lock_state(void);
 extern void nfs4_unlock_state(void);
 extern int nfs4_in_grace(void);
@@ -282,6 +285,15 @@ extern void nfs4_free_stateowner(struct kref *kref);
 extern void nfsd4_probe_callback(struct nfs4_client *clp);
 extern void nfsd4_cb_recall(struct nfs4_delegation *dp);
 extern void nfs4_put_delegation(struct nfs4_delegation *dp);
+extern int nfs4_make_rec_clidname(char *clidname, struct xdr_netobj *clname);
+extern void nfsd4_init_recdir(char *recdir_name);
+extern int nfsd4_recdir_load(void);
+extern void nfsd4_shutdown_recdir(void);
+extern int nfs4_client_to_reclaim(const char *name);
+extern int nfs4_has_reclaimed_state(const char *name);
+extern void nfsd4_recdir_purge_old(void);
+extern int nfsd4_create_clid_dir(struct nfs4_client *clp);
+extern void nfsd4_remove_clid_dir(struct nfs4_client *clp);
 static inline void
 nfs4_put_stateowner(struct nfs4_stateowner *so)
diff --git a/include/linux/nfsd/xdr.h b/include/linux/nfsd/xdr.h
index ecccef777dae..130d4f588a37 100644
--- a/include/linux/nfsd/xdr.h
+++ b/include/linux/nfsd/xdr.h
@@ -169,4 +169,8 @@ int nfssvc_encode_entry(struct readdir_cd *, const char *name,
 int nfssvc_release_fhandle(struct svc_rqst *, u32 *, struct nfsd_fhandle *);
+/* Helper functions for NFSv2 ACL code */
+u32 *nfs2svc_encode_fattr(struct svc_rqst *rqstp, u32 *p, struct svc_fh *fhp);
+u32 *nfs2svc_decode_fh(u32 *p, struct svc_fh *fhp);
 #endif /* LINUX_NFSD_H */
diff --git a/include/linux/nfsd/xdr3.h b/include/linux/nfsd/xdr3.h
index 0ae9e0ef5f68..21e18ce7ca63 100644
--- a/include/linux/nfsd/xdr3.h
+++ b/include/linux/nfsd/xdr3.h
@@ -110,6 +110,19 @@ struct nfsd3_commitargs {
        __u32                   count;
 };
+struct nfsd3_getaclargs {
+        struct svc_fh           fh;
+        int                     mask;
+};
+struct posix_acl;
+struct nfsd3_setaclargs {
+        struct svc_fh           fh;
+        int                     mask;
+        struct posix_acl        *acl_access;
+        struct posix_acl        *acl_default;
+};
 struct nfsd3_attrstat {
        __u32                   status;
        struct svc_fh           fh;
@@ -209,6 +222,14 @@ struct nfsd3_commitres {
        struct svc_fh           fh;
 };
+struct nfsd3_getaclres {
+        __u32                   status;
+        struct svc_fh           fh;
+        int                     mask;
+        struct posix_acl        *acl_access;
+        struct posix_acl        *acl_default;
+};
 /* dummy type for release */
 struct nfsd3_fhandle_pair {
        __u32                   dummy;
@@ -241,6 +262,7 @@ union nfsd3_xdrstore {
        struct nfsd3_fsinfores          fsinfores;
        struct nfsd3_pathconfres        pathconfres;
        struct nfsd3_commitres          commitres;
+        struct nfsd3_getaclres          getaclres;
 };
 #define NFS3_SVC_XDRSIZE                sizeof(union nfsd3_xdrstore)
@@ -316,6 +338,10 @@ int nfs3svc_encode_entry(struct readdir_cd *, const char *name,
 int nfs3svc_encode_entry_plus(struct readdir_cd *, const char *name,
                                int namlen, loff_t offset, ino_t ino,
                                unsigned int);
+/* Helper functions for NFSv3 ACL code */
+u32 *nfs3svc_encode_post_op_attr(struct svc_rqst *rqstp, u32 *p,
+                                struct svc_fh *fhp);
+u32 *nfs3svc_decode_fh(u32 *p, struct svc_fh *fhp);
 #endif /* _LINUX_NFSD_XDR3_H */
diff --git a/include/linux/nfsd/xdr4.h b/include/linux/nfsd/xdr4.h
index a1f5ad0be1bf..4d24d65c0e88 100644
--- a/include/linux/nfsd/xdr4.h
+++ b/include/linux/nfsd/xdr4.h
@@ -210,6 +210,7 @@ struct nfsd4_open {
        u32             op_share_access;    /* request */
        u32             op_share_deny;      /* request */
        stateid_t       op_stateid;         /* response */
+        u32             op_recall;          /* recall */
        struct nfsd4_change_info  op_cinfo; /* response */
        u32             op_rflags;          /* response */
        int             op_truncate;        /* used during processing */
diff --git a/include/linux/nfsd_idmap.h b/include/linux/nfsd_idmap.h
index 9bb7f30e923b..e82746fcad14 100644
--- a/include/linux/nfsd_idmap.h
+++ b/include/linux/nfsd_idmap.h
@@ -43,8 +43,13 @@
 /* XXX from linux/nfs_idmap.h */
 #define IDMAP_NAMESZ 128
+#ifdef CONFIG_NFSD_V4
 void nfsd_idmap_init(void);
 void nfsd_idmap_shutdown(void);
+#else
+static inline void nfsd_idmap_init(void) {};
+static inline void nfsd_idmap_shutdown(void) {};
+#endif
 int nfsd_map_name_to_uid(struct svc_rqst *, const char *, size_t, __u32 *);
 int nfsd_map_name_to_gid(struct svc_rqst *, const char *, size_t, __u32 *);
diff --git a/include/linux/numa.h b/include/linux/numa.h
index bd0c8c4e9a95..f0c539bd3cfc 100644
--- a/include/linux/numa.h
+++ b/include/linux/numa.h
@@ -3,7 +3,7 @@
 #include <linux/config.h>
-#ifdef CONFIG_DISCONTIGMEM
+#ifndef CONFIG_FLATMEM
 #include <asm/numnodes.h>
 #endif
diff --git a/include/linux/nvram.h b/include/linux/nvram.h
index b031e41b5e0d..9189829c131c 100644
--- a/include/linux/nvram.h
+++ b/include/linux/nvram.h
@@ -20,8 +20,6 @@ extern void __nvram_write_byte(unsigned char c, int i);
 extern void nvram_write_byte(unsigned char c, int i);
 extern int __nvram_check_checksum(void);
 extern int nvram_check_checksum(void);
-extern void __nvram_set_checksum(void);
-extern void nvram_set_checksum(void);
 #endif
 #endif  /* _LINUX_NVRAM_H */
diff --git a/include/linux/pci-dynids.h b/include/linux/pci-dynids.h
deleted file mode 100644
index 183b6b0de81c..000000000000
--- a/include/linux/pci-dynids.h
+++ /dev/null
@@ -1,18 +0,0 @@
-/*
- *      PCI defines and function prototypes
- *      Copyright 2003 Dell Inc.
- *        by Matt Domsch <Matt_Domsch@dell.com>
- */
-#ifndef LINUX_PCI_DYNIDS_H
-#define LINUX_PCI_DYNIDS_H
-#include <linux/list.h>
-#include <linux/mod_devicetable.h>
-struct dynid {
-        struct list_head        node;
-        struct pci_device_id    id;
-};
-#endif
diff --git a/include/linux/pci.h b/include/linux/pci.h
index b5238bd18830..bc4c40000c0d 100644
--- a/include/linux/pci.h
+++ b/include/linux/pci.h
@@ -556,7 +556,8 @@ struct pci_dev {
        /* keep track of device state */
        unsigned int    is_enabled:1;   /* pci_enable_device has been called */
        unsigned int    is_busmaster:1; /* device is busmaster */
-        
+        unsigned int    no_msi:1;       /* device may not use msi */
        u32             saved_config_space[16]; /* config space saved at suspend time */
        struct bin_attribute *rom_attr; /* attribute descriptor for sysfs ROM entry */
        int rom_attr_enabled;           /* has display of the rom attribute been enabled? */
@@ -586,7 +587,7 @@ struct pci_dev {
 #define PCI_NUM_RESOURCES 11
 #ifndef PCI_BUS_NUM_RESOURCES
-#define PCI_BUS_NUM_RESOURCES 4
+#define PCI_BUS_NUM_RESOURCES 8
 #endif
  
 #define PCI_REGION_FLAG_MASK 0x0fU      /* These bits of resource flags tell us the PCI region flags */
@@ -734,16 +735,20 @@ void pcibios_update_irq(struct pci_dev *, int irq);
 /* Generic PCI functions used internally */
 extern struct pci_bus *pci_find_bus(int domain, int busnr);
+void pci_bus_add_devices(struct pci_bus *bus);
 struct pci_bus *pci_scan_bus_parented(struct device *parent, int bus, struct pci_ops *ops, void *sysdata);
 static inline struct pci_bus *pci_scan_bus(int bus, struct pci_ops *ops, void *sysdata)
 {
-        return pci_scan_bus_parented(NULL, bus, ops, sysdata);
+        struct pci_bus *root_bus;
+        root_bus = pci_scan_bus_parented(NULL, bus, ops, sysdata);
+        if (root_bus)
+                pci_bus_add_devices(root_bus);
+        return root_bus;
 }
 int pci_scan_slot(struct pci_bus *bus, int devfn);
 struct pci_dev * pci_scan_single_device(struct pci_bus *bus, int devfn);
 unsigned int pci_scan_child_bus(struct pci_bus *bus);
 void pci_bus_add_device(struct pci_dev *dev);
-void pci_bus_add_devices(struct pci_bus *bus);
 void pci_name_device(struct pci_dev *dev);
 char *pci_class_name(u32 class);
 void pci_read_bridge_bases(struct pci_bus *child);
@@ -856,7 +861,8 @@ int pci_register_driver(struct pci_driver *);
 void pci_unregister_driver(struct pci_driver *);
 void pci_remove_behind_bridge(struct pci_dev *);
 struct pci_driver *pci_dev_driver(const struct pci_dev *);
-const struct pci_device_id *pci_match_device(const struct pci_device_id *ids, const struct pci_dev *dev);
+const struct pci_device_id *pci_match_device(struct pci_driver *drv, struct pci_dev *dev);
+const struct pci_device_id *pci_match_id(const struct pci_device_id *ids, struct pci_dev *dev);
 int pci_scan_bridge(struct pci_bus *bus, struct pci_dev * dev, int max, int pass);
 /* kmem_cache style wrapper around pci_alloc_consistent() */
@@ -870,6 +876,15 @@ int pci_scan_bridge(struct pci_bus *bus, struct pci_dev * dev, int max, int pass
 #define pci_pool_alloc(pool, flags, handle) dma_pool_alloc(pool, flags, handle)
 #define pci_pool_free(pool, vaddr, addr) dma_pool_free(pool, vaddr, addr)
+enum pci_dma_burst_strategy {
+        PCI_DMA_BURST_INFINITY, /* make bursts as large as possible,
+                                   strategy_parameter is N/A */
+        PCI_DMA_BURST_BOUNDARY, /* disconnect at every strategy_parameter
+                                   byte boundaries */
+        PCI_DMA_BURST_MULTIPLE, /* disconnect at some multiple of
+                                   strategy_parameter byte boundaries */
+};
 #if defined(CONFIG_ISA) || defined(CONFIG_EISA)
 extern struct pci_dev *isa_bridge;
 #endif
@@ -957,6 +972,8 @@ static inline int pci_enable_wake(struct pci_dev *dev, pci_power_t state, int en
 #define isa_bridge      ((struct pci_dev *)NULL)
+#define pci_dma_burst_advice(pdev, strat, strategy_parameter) do { } while (0)
 #else
 /*
@@ -971,7 +988,6 @@ static inline int pci_proc_domain(struct pci_bus *bus)
        return 0;
 }
 #endif
 #endif /* !CONFIG_PCI */
 /* these helpers provide future and backwards compatibility
@@ -1016,6 +1032,20 @@ static inline char *pci_name(struct pci_dev *pdev)
 #define pci_pretty_name(dev) ""
 #endif
+/* Some archs don't want to expose struct resource to userland as-is
+ * in sysfs and /proc
+ */
+#ifndef HAVE_ARCH_PCI_RESOURCE_TO_USER
+static inline void pci_resource_to_user(const struct pci_dev *dev, int bar,
+                const struct resource *rsrc, u64 *start, u64 *end)
+{
+        *start = rsrc->start;
+        *end = rsrc->end;
+}
+#endif /* HAVE_ARCH_PCI_RESOURCE_TO_USER */
 /*
 *  The world is not perfect and supplies us with broken PCI devices.
 *  For at least a part of these bugs we need a work-around, so both
diff --git a/include/linux/pci_ids.h b/include/linux/pci_ids.h
index 63e89e47b8e9..927ed487630d 100644
--- a/include/linux/pci_ids.h
+++ b/include/linux/pci_ids.h
@@ -62,6 +62,8 @@
 #define PCI_BASE_CLASS_SYSTEM           0x08
 #define PCI_CLASS_SYSTEM_PIC            0x0800
+#define PCI_CLASS_SYSTEM_PIC_IOAPIC     0x080010
+#define PCI_CLASS_SYSTEM_PIC_IOXAPIC    0x080020
 #define PCI_CLASS_SYSTEM_DMA            0x0801
 #define PCI_CLASS_SYSTEM_TIMER          0x0802
 #define PCI_CLASS_SYSTEM_RTC            0x0803
@@ -712,8 +714,9 @@
 #define PCI_DEVICE_ID_HP_DIVA_AUX       0x1290
 #define PCI_DEVICE_ID_HP_DIVA_RMP3      0x1301
 #define PCI_DEVICE_ID_HP_CISSA          0x3220
-#define PCI_DEVICE_ID_HP_CISSB          0x3230
+#define PCI_DEVICE_ID_HP_CISSB          0x3222
 #define PCI_DEVICE_ID_HP_ZX2_IOC        0x4031
+#define PCI_DEVICE_ID_HP_CISSC          0x3230
 #define PCI_VENDOR_ID_PCTECH            0x1042
 #define PCI_DEVICE_ID_PCTECH_RZ1000     0x1000
@@ -878,7 +881,7 @@
 #define PCI_DEVICE_ID_APPLE_UNI_N_PCI15 0x002e
 #define PCI_DEVICE_ID_APPLE_UNI_N_FW2   0x0030
 #define PCI_DEVICE_ID_APPLE_UNI_N_GMAC2 0x0032
-#define PCI_DEVIEC_ID_APPLE_UNI_N_ATA   0x0033
+#define PCI_DEVICE_ID_APPLE_UNI_N_ATA   0x0033
 #define PCI_DEVICE_ID_APPLE_UNI_N_AGP2  0x0034
 #define PCI_DEVICE_ID_APPLE_IPID_ATA100 0x003b
 #define PCI_DEVICE_ID_APPLE_KEYLARGO_I  0x003e
@@ -908,6 +911,15 @@
 #define PCI_DEVICE_ID_QLOGIC_ISP1022    0x1022
 #define PCI_DEVICE_ID_QLOGIC_ISP2100    0x2100
 #define PCI_DEVICE_ID_QLOGIC_ISP2200    0x2200
+#define PCI_DEVICE_ID_QLOGIC_ISP2300    0x2300
+#define PCI_DEVICE_ID_QLOGIC_ISP2312    0x2312
+#define PCI_DEVICE_ID_QLOGIC_ISP2322    0x2322
+#define PCI_DEVICE_ID_QLOGIC_ISP6312    0x6312
+#define PCI_DEVICE_ID_QLOGIC_ISP6322    0x6322
+#define PCI_DEVICE_ID_QLOGIC_ISP2422    0x2422
+#define PCI_DEVICE_ID_QLOGIC_ISP2432    0x2432
+#define PCI_DEVICE_ID_QLOGIC_ISP2512    0x2512
+#define PCI_DEVICE_ID_QLOGIC_ISP2522    0x2522
 #define PCI_VENDOR_ID_CYRIX             0x1078
 #define PCI_DEVICE_ID_CYRIX_5510        0x0000
@@ -1008,6 +1020,7 @@
 #define PCI_DEVICE_ID_PLX_SPCOM200      0x1103
 #define PCI_DEVICE_ID_PLX_DJINN_ITOO    0x1151
 #define PCI_DEVICE_ID_PLX_R753          0x1152
+#define PCI_DEVICE_ID_PLX_OLITEC        0x1187
 #define PCI_DEVICE_ID_PLX_9030          0x9030
 #define PCI_DEVICE_ID_PLX_9050          0x9050
 #define PCI_DEVICE_ID_PLX_9060          0x9060
@@ -1235,6 +1248,7 @@
 #define PCI_DEVICE_ID_NVIDIA_NFORCE_MCP51_IDE   0x0265
 #define PCI_DEVICE_ID_NVIDIA_NFORCE_MCP51_SATA  0x0266
 #define PCI_DEVICE_ID_NVIDIA_NFORCE_MCP51_SATA2 0x0267
+#define PCI_DEVICE_ID_NVIDIA_NFORCE_MCP55_IDE   0x036E
 #define PCI_DEVICE_ID_NVIDIA_NVENET_12          0x0268
 #define PCI_DEVICE_ID_NVIDIA_NVENET_13          0x0269
 #define PCI_DEVICE_ID_NVIDIA_MCP51_AUDIO        0x026B
@@ -1284,6 +1298,8 @@
 #define PCI_DEVICE_ID_NVIDIA_GEFORCE_FX_GO5700_2    0x0348
 #define PCI_DEVICE_ID_NVIDIA_QUADRO_FX_GO1000       0x034C
 #define PCI_DEVICE_ID_NVIDIA_QUADRO_FX_1100         0x034E
+#define PCI_DEVICE_ID_NVIDIA_NVENET_14              0x0372
+#define PCI_DEVICE_ID_NVIDIA_NVENET_15              0x0373
 #define PCI_VENDOR_ID_IMS               0x10e0
 #define PCI_DEVICE_ID_IMS_8849          0x8849
@@ -1564,10 +1580,12 @@
 #define PCI_DEVICE_ID_SERVERWORKS_OSB4IDE 0x0211
 #define PCI_DEVICE_ID_SERVERWORKS_CSB5IDE 0x0212
 #define PCI_DEVICE_ID_SERVERWORKS_CSB6IDE 0x0213
+#define PCI_DEVICE_ID_SERVERWORKS_HT1000IDE 0x0214
 #define PCI_DEVICE_ID_SERVERWORKS_CSB6IDE2 0x0217
 #define PCI_DEVICE_ID_SERVERWORKS_OSB4USB 0x0220
 #define PCI_DEVICE_ID_SERVERWORKS_CSB5USB PCI_DEVICE_ID_SERVERWORKS_OSB4USB
 #define PCI_DEVICE_ID_SERVERWORKS_CSB6USB 0x0221
+#define PCI_DEVICE_ID_SERVERWORKS_CSB6LPC 0x0227
 #define PCI_DEVICE_ID_SERVERWORKS_GCLE    0x0225
 #define PCI_DEVICE_ID_SERVERWORKS_GCLE2   0x0227
 #define PCI_DEVICE_ID_SERVERWORKS_CSB5ISA 0x0230
@@ -1811,6 +1829,8 @@
 #define PCI_VENDOR_ID_ITE               0x1283
 #define PCI_DEVICE_ID_ITE_IT8172G       0x8172
 #define PCI_DEVICE_ID_ITE_IT8172G_AUDIO 0x0801
+#define PCI_DEVICE_ID_ITE_8211          0x8211
+#define PCI_DEVICE_ID_ITE_8212          0x8212
 #define PCI_DEVICE_ID_ITE_8872          0x8872
 #define PCI_DEVICE_ID_ITE_IT8330G_0     0xe886
@@ -1863,6 +1883,7 @@
 #define PCI_DEVICE_ID_CBOARDS_DAS1602_16 0x0001
 #define PCI_VENDOR_ID_SIIG              0x131f
+#define PCI_SUBVENDOR_ID_SIIG           0x131f
 #define PCI_DEVICE_ID_SIIG_1S_10x_550   0x1000
 #define PCI_DEVICE_ID_SIIG_1S_10x_650   0x1001
 #define PCI_DEVICE_ID_SIIG_1S_10x_850   0x1002
@@ -1900,6 +1921,7 @@
 #define PCI_DEVICE_ID_SIIG_2S1P_20x_550 0x2060
 #define PCI_DEVICE_ID_SIIG_2S1P_20x_650 0x2061
 #define PCI_DEVICE_ID_SIIG_2S1P_20x_850 0x2062
+#define PCI_SUBDEVICE_ID_SIIG_QUARTET_SERIAL    0x2050
 #define PCI_VENDOR_ID_RADISYS           0x1331
 #define PCI_DEVICE_ID_RADISYS_ENP2611   0x0030
@@ -2087,6 +2109,8 @@
 #define PCI_DEVICE_ID_TIGON3_5721       0x1659
 #define PCI_DEVICE_ID_TIGON3_5705M      0x165d
 #define PCI_DEVICE_ID_TIGON3_5705M_2    0x165e
+#define PCI_DEVICE_ID_TIGON3_5780       0x166a
+#define PCI_DEVICE_ID_TIGON3_5780S      0x166b
 #define PCI_DEVICE_ID_TIGON3_5705F      0x166e
 #define PCI_DEVICE_ID_TIGON3_5750       0x1676
 #define PCI_DEVICE_ID_TIGON3_5751       0x1677
@@ -2161,6 +2185,9 @@
 #define PCI_VENDOR_ID_SIBYTE            0x166d
 #define PCI_DEVICE_ID_BCM1250_HT        0x0002
+#define PCI_VENDOR_ID_NETCELL           0x169c
+#define PCI_DEVICE_ID_REVOLUTION        0x0044
 #define PCI_VENDOR_ID_LINKSYS           0x1737
 #define PCI_DEVICE_ID_LINKSYS_EG1032    0x1032
 #define PCI_DEVICE_ID_LINKSYS_EG1064    0x1064
@@ -2258,6 +2285,11 @@
 #define PCI_VENDOR_ID_INTEL             0x8086
 #define PCI_DEVICE_ID_INTEL_EESSC       0x0008
 #define PCI_DEVICE_ID_INTEL_21145       0x0039
+#define PCI_DEVICE_ID_INTEL_PXHD_0      0x0320
+#define PCI_DEVICE_ID_INTEL_PXHD_1      0x0321
+#define PCI_DEVICE_ID_INTEL_PXH_0       0x0329
+#define PCI_DEVICE_ID_INTEL_PXH_1       0x032A
+#define PCI_DEVICE_ID_INTEL_PXHV        0x032C
 #define PCI_DEVICE_ID_INTEL_82375       0x0482
 #define PCI_DEVICE_ID_INTEL_82424       0x0483
 #define PCI_DEVICE_ID_INTEL_82378       0x0484
diff --git a/include/linux/pkt_cls.h b/include/linux/pkt_cls.h
index d2aa214d6803..bd2c5a2bbbf5 100644
--- a/include/linux/pkt_cls.h
+++ b/include/linux/pkt_cls.h
@@ -276,6 +276,7 @@ struct tc_rsvp_pinfo
        __u8    protocol;
        __u8    tunnelid;
        __u8    tunnelhdr;
+        __u8    pad;
 };
 /* ROUTE filter */
@@ -408,6 +409,7 @@ enum
        TCF_EM_NBYTE,
        TCF_EM_U32,
        TCF_EM_META,
+        TCF_EM_TEXT,
        __TCF_EM_MAX
 };
diff --git a/include/linux/pkt_sched.h b/include/linux/pkt_sched.h
index 1d9da36eb9db..60ffcb9c5791 100644
--- a/include/linux/pkt_sched.h
+++ b/include/linux/pkt_sched.h
@@ -221,9 +221,11 @@ struct tc_gred_qopt
 /* gred setup */
 struct tc_gred_sopt
 {
-       __u32           DPs;
+       __u32            DPs;
-       __u32           def_DP;
+       __u32            def_DP;
-       __u8            grio;
+       __u8             grio;
+       __u8             pad1;
+       __u16            pad2;
 };
 /* HTB section */
@@ -351,6 +353,7 @@ struct tc_cbq_ovl
 #define TC_CBQ_OVL_DROP         3
 #define TC_CBQ_OVL_RCLASSIC     4
        unsigned char   priority2;
+        __u16           pad;
        __u32           penalty;
 };
diff --git a/include/linux/pktcdvd.h b/include/linux/pktcdvd.h
index 4e2d2a942ecb..4b32bce9a289 100644
--- a/include/linux/pktcdvd.h
+++ b/include/linux/pktcdvd.h
@@ -159,7 +159,7 @@ struct packet_iosched
        struct bio              *read_queue_tail;
        struct bio              *write_queue;
        struct bio              *write_queue_tail;
-        int                     high_prio_read; /* An important read request has been queued */
+        sector_t                last_write;     /* The sector where the last write ended */
        int                     successive_reads;
 };
diff --git a/include/linux/pm.h b/include/linux/pm.h
index ed2b76e75199..7aeb208ed713 100644
--- a/include/linux/pm.h
+++ b/include/linux/pm.h
@@ -103,7 +103,8 @@ extern int pm_active;
 /*
 * Register a device with power management
 */
-struct pm_dev __deprecated *pm_register(pm_dev_t type, unsigned long id, pm_callback callback);
+struct pm_dev __deprecated *
+pm_register(pm_dev_t type, unsigned long id, pm_callback callback);
 /*
 * Unregister a device with power management
@@ -175,7 +176,7 @@ struct pm_ops {
 };
 extern void pm_set_ops(struct pm_ops *);
+extern struct pm_ops *pm_ops;
 extern int pm_suspend(suspend_state_t state);
@@ -190,17 +191,18 @@ typedef u32 __bitwise pm_message_t;
 /*
 * There are 4 important states driver can be in:
 * ON     -- driver is working
- * FREEZE -- stop operations and apply whatever policy is applicable to a suspended driver
+ * FREEZE -- stop operations and apply whatever policy is applicable to a
- *           of that class, freeze queues for block like IDE does, drop packets for
+ *           suspended driver of that class, freeze queues for block like IDE
- *           ethernet, etc... stop DMA engine too etc... so a consistent image can be
+ *           does, drop packets for ethernet, etc... stop DMA engine too etc...
- *           saved; but do not power any hardware down.
+ *           so a consistent image can be saved; but do not power any hardware
- * SUSPEND - like FREEZE, but hardware is doing as much powersaving as possible. Roughly
+ *           down.
- *           pci D3.
+ * SUSPEND - like FREEZE, but hardware is doing as much powersaving as
+ *           possible. Roughly pci D3.
 *
- * Unfortunately, current drivers only recognize numeric values 0 (ON) and 3 (SUSPEND).
+ * Unfortunately, current drivers only recognize numeric values 0 (ON) and 3
- * We'll need to fix the drivers. So yes, putting 3 to all diferent defines is intentional,
+ * (SUSPEND).  We'll need to fix the drivers. So yes, putting 3 to all different
- * and will go away as soon as drivers are fixed. Also note that typedef is neccessary,
+ * defines is intentional, and will go away as soon as drivers are fixed.  Also
- * we'll probably want to switch to
+ * note that typedef is neccessary, we'll probably want to switch to
 *   typedef struct pm_message_t { int event; int flags; } pm_message_t
 * or something similar soon.
 */
@@ -222,11 +224,18 @@ struct dev_pm_info {
 extern void device_pm_set_parent(struct device * dev, struct device * parent);
-extern int device_suspend(pm_message_t state);
 extern int device_power_down(pm_message_t state);
 extern void device_power_up(void);
 extern void device_resume(void);
+#ifdef CONFIG_PM
+extern int device_suspend(pm_message_t state);
+#else
+static inline int device_suspend(pm_message_t state)
+{
+        return 0;
+}
+#endif
 #endif /* __KERNEL__ */
diff --git a/include/linux/pmu.h b/include/linux/pmu.h
index 6d73eada277e..373bd3b9b330 100644
--- a/include/linux/pmu.h
+++ b/include/linux/pmu.h
@@ -166,7 +166,7 @@ extern int pmu_i2c_simple_read(int bus, int addr,  u8* data, int len);
 extern int pmu_i2c_simple_write(int bus, int addr,  u8* data, int len);
-#ifdef CONFIG_PMAC_PBOOK
+#ifdef CONFIG_PM
 /*
 * Stuff for putting the powerbook to sleep and waking it again.
 *
@@ -208,6 +208,8 @@ struct pmu_sleep_notifier
 int pmu_register_sleep_notifier(struct pmu_sleep_notifier* notifier);
 int pmu_unregister_sleep_notifier(struct pmu_sleep_notifier* notifier);
+#endif /* CONFIG_PM */
 #define PMU_MAX_BATTERIES       2
 /* values for pmu_power_flags */
@@ -235,6 +237,4 @@ extern int pmu_battery_count;
 extern struct pmu_battery_info pmu_batteries[PMU_MAX_BATTERIES];
 extern unsigned int pmu_power_flags;
-#endif /* CONFIG_PMAC_PBOOK */
 #endif  /* __KERNEL__ */
diff --git a/include/linux/posix_acl_xattr.h b/include/linux/posix_acl_xattr.h
index 5efd0a6dad94..6e53c34035cd 100644
--- a/include/linux/posix_acl_xattr.h
+++ b/include/linux/posix_acl_xattr.h
@@ -23,13 +23,13 @@
 #define ACL_UNDEFINED_ID        (-1)
 typedef struct {
-        __u16                   e_tag;
+        __le16                  e_tag;
-        __u16                   e_perm;
+        __le16                  e_perm;
-        __u32                   e_id;
+        __le32                  e_id;
 } posix_acl_xattr_entry;
 typedef struct {
-        __u32                   a_version;
+        __le32                  a_version;
        posix_acl_xattr_entry   a_entries[0];
 } posix_acl_xattr_header;
@@ -52,4 +52,7 @@ posix_acl_xattr_count(size_t size)
        return size / sizeof(posix_acl_xattr_entry);
 }
+struct posix_acl *posix_acl_from_xattr(const void *value, size_t size);
+int posix_acl_to_xattr(const struct posix_acl *acl, void *buffer, size_t size);
 #endif  /* _POSIX_ACL_XATTR_H */
diff --git a/include/linux/proc_fs.h b/include/linux/proc_fs.h
index 59e505261fd6..0563581e3a02 100644
--- a/include/linux/proc_fs.h
+++ b/include/linux/proc_fs.h
@@ -74,6 +74,13 @@ struct kcore_list {
        size_t size;
 };
+struct vmcore {
+        struct list_head list;
+        unsigned long long paddr;
+        unsigned long size;
+        loff_t offset;
+};
 #ifdef CONFIG_PROC_FS
 extern struct proc_dir_entry proc_root;
diff --git a/include/linux/qnx4_fs.h b/include/linux/qnx4_fs.h
index 22ba580b0ae8..fc610bb0f733 100644
--- a/include/linux/qnx4_fs.h
+++ b/include/linux/qnx4_fs.h
@@ -46,11 +46,11 @@ struct qnx4_inode_entry {
        char            di_fname[QNX4_SHORT_NAME_MAX];
        qnx4_off_t      di_size;
        qnx4_xtnt_t     di_first_xtnt;
-        __u32           di_xblk;
+        __le32          di_xblk;
-        __s32           di_ftime;
+        __le32          di_ftime;
-        __s32           di_mtime;
+        __le32          di_mtime;
-        __s32           di_atime;
+        __le32          di_atime;
-        __s32           di_ctime;
+        __le32          di_ctime;
        qnx4_nxtnt_t    di_num_xtnts;
        qnx4_mode_t     di_mode;
        qnx4_muid_t     di_uid;
@@ -63,18 +63,18 @@ struct qnx4_inode_entry {
 struct qnx4_link_info {
        char            dl_fname[QNX4_NAME_MAX];
-        __u32           dl_inode_blk;
+        __le32          dl_inode_blk;
        __u8            dl_inode_ndx;
        __u8            dl_spare[10];
        __u8            dl_status;
 };
 struct qnx4_xblk {
-        __u32           xblk_next_xblk;
+        __le32          xblk_next_xblk;
-        __u32           xblk_prev_xblk;
+        __le32          xblk_prev_xblk;
        __u8            xblk_num_xtnts;
        __u8            xblk_spare[3];
-        __s32           xblk_num_blocks;
+        __le32          xblk_num_blocks;
        qnx4_xtnt_t     xblk_xtnts[QNX4_MAX_XTNTS_PER_XBLK];
        char            xblk_signature[8];
        qnx4_xtnt_t     xblk_first_xtnt;
diff --git a/include/linux/qnxtypes.h b/include/linux/qnxtypes.h
index fb518e318c7c..a3eb1137857b 100644
--- a/include/linux/qnxtypes.h
+++ b/include/linux/qnxtypes.h
@@ -12,18 +12,18 @@
 #ifndef _QNX4TYPES_H
 #define _QNX4TYPES_H
-typedef __u16 qnx4_nxtnt_t;
+typedef __le16 qnx4_nxtnt_t;
 typedef __u8  qnx4_ftype_t;
 typedef struct {
-        __u32 xtnt_blk;
+        __le32 xtnt_blk;
-        __u32 xtnt_size;
+        __le32 xtnt_size;
 } qnx4_xtnt_t;
-typedef __u16 qnx4_mode_t;
+typedef __le16 qnx4_mode_t;
-typedef __u16 qnx4_muid_t;
+typedef __le16 qnx4_muid_t;
-typedef __u16 qnx4_mgid_t;
+typedef __le16 qnx4_mgid_t;
-typedef __u32 qnx4_off_t;
+typedef __le32 qnx4_off_t;
-typedef __u16 qnx4_nlink_t;
+typedef __le16 qnx4_nlink_t;
 #endif
diff --git a/include/linux/quota.h b/include/linux/quota.h
index ac5b90f4f256..700ead45084f 100644
--- a/include/linux/quota.h
+++ b/include/linux/quota.h
@@ -138,8 +138,11 @@ struct if_dqinfo {
 #include <linux/dqblk_v2.h>
 /* Maximal numbers of writes for quota operation (insert/delete/update)
- * (over all formats) - info block, 4 pointer blocks, data block */
+ * (over VFS all formats) */
-#define DQUOT_MAX_WRITES        6
+#define DQUOT_INIT_ALLOC max(V1_INIT_ALLOC, V2_INIT_ALLOC)
+#define DQUOT_INIT_REWRITE max(V1_INIT_REWRITE, V2_INIT_REWRITE)
+#define DQUOT_DEL_ALLOC max(V1_DEL_ALLOC, V2_DEL_ALLOC)
+#define DQUOT_DEL_REWRITE max(V1_DEL_REWRITE, V2_DEL_REWRITE)
 /*
 * Data for one user/group kept in memory
diff --git a/include/linux/quotaops.h b/include/linux/quotaops.h
index e57baa85e744..d211507ab246 100644
--- a/include/linux/quotaops.h
+++ b/include/linux/quotaops.h
@@ -39,7 +39,8 @@ extern int dquot_commit_info(struct super_block *sb, int type);
 extern int dquot_mark_dquot_dirty(struct dquot *dquot);
 extern int vfs_quota_on(struct super_block *sb, int type, int format_id, char *path);
-extern int vfs_quota_on_mount(int type, int format_id, struct dentry *dentry);
+extern int vfs_quota_on_mount(struct super_block *sb, char *qf_name,
+                int format_id, int type);
 extern int vfs_quota_off(struct super_block *sb, int type);
 #define vfs_quota_off_mount(sb, type) vfs_quota_off(sb, type)
 extern int vfs_quota_sync(struct super_block *sb, int type);
diff --git a/include/linux/raid/bitmap.h b/include/linux/raid/bitmap.h
index e24b74b11150..4bf1659f8aa8 100644
--- a/include/linux/raid/bitmap.h
+++ b/include/linux/raid/bitmap.h
@@ -248,6 +248,7 @@ struct bitmap {
 /* these are used only by md/bitmap */
 int  bitmap_create(mddev_t *mddev);
+void bitmap_flush(mddev_t *mddev);
 void bitmap_destroy(mddev_t *mddev);
 int  bitmap_active(struct bitmap *bitmap);
@@ -262,7 +263,7 @@ void bitmap_write_all(struct bitmap *bitmap);
 int bitmap_startwrite(struct bitmap *bitmap, sector_t offset, unsigned long sectors);
 void bitmap_endwrite(struct bitmap *bitmap, sector_t offset, unsigned long sectors,
                     int success);
-int bitmap_start_sync(struct bitmap *bitmap, sector_t offset, int *blocks);
+int bitmap_start_sync(struct bitmap *bitmap, sector_t offset, int *blocks, int degraded);
 void bitmap_end_sync(struct bitmap *bitmap, sector_t offset, int *blocks, int aborted);
 void bitmap_close_sync(struct bitmap *bitmap);
diff --git a/include/linux/reboot.h b/include/linux/reboot.h
index d60fafc8bdc5..3b3266ff1a95 100644
--- a/include/linux/reboot.h
+++ b/include/linux/reboot.h
@@ -51,6 +51,26 @@ extern void machine_restart(char *cmd);
 extern void machine_halt(void);
 extern void machine_power_off(void);
+extern void machine_shutdown(void);
+struct pt_regs;
+extern void machine_crash_shutdown(struct pt_regs *);
+/* 
+ * Architecture independent implemenations of sys_reboot commands.
+ */
+extern void kernel_restart(char *cmd);
+extern void kernel_halt(void);
+extern void kernel_power_off(void);
+extern void kernel_kexec(void);
+/*
+ * Emergency restart, callable from an interrupt handler.
+ */
+extern void emergency_restart(void);
+#include <asm/emergency-restart.h>
 #endif
 #endif /* _LINUX_REBOOT_H */
diff --git a/include/linux/reiserfs_acl.h b/include/linux/reiserfs_acl.h
index 2aef9c3f5ce8..0a3605099c44 100644
--- a/include/linux/reiserfs_acl.h
+++ b/include/linux/reiserfs_acl.h
@@ -1,33 +1,32 @@
 #include <linux/init.h>
 #include <linux/posix_acl.h>
-#include <linux/xattr_acl.h>
 #define REISERFS_ACL_VERSION    0x0001
 typedef struct {
-        __le16          e_tag;
+        __le16 e_tag;
-        __le16          e_perm;
+        __le16 e_perm;
-        __le32          e_id;
+        __le32 e_id;
 } reiserfs_acl_entry;
 typedef struct {
-        __le16          e_tag;
+        __le16 e_tag;
-        __le16          e_perm;
+        __le16 e_perm;
 } reiserfs_acl_entry_short;
 typedef struct {
-        __le32          a_version;
+        __le32 a_version;
 } reiserfs_acl_header;
 static inline size_t reiserfs_acl_size(int count)
 {
        if (count <= 4) {
                return sizeof(reiserfs_acl_header) +
-                       count * sizeof(reiserfs_acl_entry_short);
+                    count * sizeof(reiserfs_acl_entry_short);
        } else {
                return sizeof(reiserfs_acl_header) +
-                       4 * sizeof(reiserfs_acl_entry_short) +
+                    4 * sizeof(reiserfs_acl_entry_short) +
-                       (count - 4) * sizeof(reiserfs_acl_entry);
+                    (count - 4) * sizeof(reiserfs_acl_entry);
        }
 }
@@ -47,14 +46,14 @@ static inline int reiserfs_acl_count(size_t size)
        }
 }
 #ifdef CONFIG_REISERFS_FS_POSIX_ACL
-struct posix_acl * reiserfs_get_acl(struct inode *inode, int type);
+struct posix_acl *reiserfs_get_acl(struct inode *inode, int type);
-int reiserfs_acl_chmod (struct inode *inode);
+int reiserfs_acl_chmod(struct inode *inode);
-int reiserfs_inherit_default_acl (struct inode *dir, struct dentry *dentry, struct inode *inode);
+int reiserfs_inherit_default_acl(struct inode *dir, struct dentry *dentry,
-int reiserfs_cache_default_acl (struct inode *dir);
+                                 struct inode *inode);
-extern int reiserfs_xattr_posix_acl_init (void) __init;
+int reiserfs_cache_default_acl(struct inode *dir);
-extern int reiserfs_xattr_posix_acl_exit (void);
+extern int reiserfs_xattr_posix_acl_init(void) __init;
+extern int reiserfs_xattr_posix_acl_exit(void);
 extern struct reiserfs_xattr_handler posix_acl_default_handler;
 extern struct reiserfs_xattr_handler posix_acl_access_handler;
 #else
@@ -62,28 +61,26 @@ extern struct reiserfs_xattr_handler posix_acl_access_handler;
 #define reiserfs_get_acl NULL
 #define reiserfs_cache_default_acl(inode) 0
-static inline int
+static inline int reiserfs_xattr_posix_acl_init(void)
-reiserfs_xattr_posix_acl_init (void)
 {
-    return 0;
+        return 0;
 }
-static inline int
+static inline int reiserfs_xattr_posix_acl_exit(void)
-reiserfs_xattr_posix_acl_exit (void)
 {
-    return 0;
+        return 0;
 }
-static inline int
+static inline int reiserfs_acl_chmod(struct inode *inode)
-reiserfs_acl_chmod (struct inode *inode)
 {
-    return 0;
+        return 0;
 }
 static inline int
-reiserfs_inherit_default_acl (const struct inode *dir, struct dentry *dentry, struct inode *inode)
+reiserfs_inherit_default_acl(const struct inode *dir, struct dentry *dentry,
+                             struct inode *inode)
 {
-    return 0;
+        return 0;
 }
 #endif
diff --git a/include/linux/reiserfs_fs.h b/include/linux/reiserfs_fs.h
index 32148625fc2f..17e458e17e2b 100644
--- a/include/linux/reiserfs_fs.h
+++ b/include/linux/reiserfs_fs.h
@@ -3,11 +3,10 @@
 */
                                /* this file has an amazingly stupid
-                                   name, yura please fix it to be
+                                   name, yura please fix it to be
-                                   reiserfs.h, and merge all the rest
+                                   reiserfs.h, and merge all the rest
-                                   of our .h files that are in this
+                                   of our .h files that are in this
-                                   directory into it.  */
+                                   directory into it.  */
 #ifndef _LINUX_REISER_FS_H
 #define _LINUX_REISER_FS_H
@@ -74,9 +73,9 @@
 /* debug levels.  Right now, CONFIG_REISERFS_CHECK means print all debug
 ** messages.
 */
-#define REISERFS_DEBUG_CODE 5 /* extra messages to help find/debug errors */ 
+#define REISERFS_DEBUG_CODE 5   /* extra messages to help find/debug errors */
-void reiserfs_warning (struct super_block *s, const char * fmt, ...);
+void reiserfs_warning(struct super_block *s, const char *fmt, ...);
 /* assertions handling */
 /** always check a condition and panic if it's false. */
@@ -105,82 +104,78 @@ if( !( cond ) ) 								\
 * Structure of super block on disk, a version of which in RAM is often accessed as REISERFS_SB(s)->s_rs
 * the version in RAM is part of a larger structure containing fields never written to disk.
 */
-#define UNSET_HASH 0 // read_super will guess about, what hash names
+#define UNSET_HASH 0            // read_super will guess about, what hash names
-                     // in directories were sorted with
+                     // in directories were sorted with
 #define TEA_HASH  1
 #define YURA_HASH 2
 #define R5_HASH   3
 #define DEFAULT_HASH R5_HASH
 struct journal_params {
-    __le32 jp_journal_1st_block;              /* where does journal start from on its
+        __le32 jp_journal_1st_block;    /* where does journal start from on its
-                                       * device */
+                                         * device */
-    __le32 jp_journal_dev;            /* journal device st_rdev */
+        __le32 jp_journal_dev;  /* journal device st_rdev */
-    __le32 jp_journal_size;           /* size of the journal */
+        __le32 jp_journal_size; /* size of the journal */
-    __le32 jp_journal_trans_max;              /* max number of blocks in a transaction. */
+        __le32 jp_journal_trans_max;    /* max number of blocks in a transaction. */
-    __le32 jp_journal_magic;          /* random value made on fs creation (this
+        __le32 jp_journal_magic;        /* random value made on fs creation (this
-                                       * was sb_journal_block_count) */
+                                         * was sb_journal_block_count) */
-    __le32 jp_journal_max_batch;              /* max number of blocks to batch into a
+        __le32 jp_journal_max_batch;    /* max number of blocks to batch into a
-                                       * trans */
+                                         * trans */
-    __le32 jp_journal_max_commit_age;  /* in seconds, how old can an async
+        __le32 jp_journal_max_commit_age;       /* in seconds, how old can an async
-                                       * commit be */
+                                                 * commit be */
-    __le32 jp_journal_max_trans_age;   /* in seconds, how old can a transaction
+        __le32 jp_journal_max_trans_age;        /* in seconds, how old can a transaction
-                                       * be */
+                                                 * be */
 };
 /* this is the super from 3.5.X, where X >= 10 */
-struct reiserfs_super_block_v1
+struct reiserfs_super_block_v1 {
-{
+        __le32 s_block_count;   /* blocks count         */
-    __le32 s_block_count;          /* blocks count         */
+        __le32 s_free_blocks;   /* free blocks count    */
-    __le32 s_free_blocks;           /* free blocks count    */
+        __le32 s_root_block;    /* root block number    */
-    __le32 s_root_block;            /* root block number    */
+        struct journal_params s_journal;
-    struct journal_params s_journal;
+        __le16 s_blocksize;     /* block size */
-    __le16 s_blocksize;             /* block size */
+        __le16 s_oid_maxsize;   /* max size of object id array, see
-    __le16 s_oid_maxsize;          /* max size of object id array, see
+                                 * get_objectid() commentary  */
-                                    * get_objectid() commentary  */
+        __le16 s_oid_cursize;   /* current size of object id array */
-    __le16 s_oid_cursize;          /* current size of object id array */
+        __le16 s_umount_state;  /* this is set to 1 when filesystem was
-    __le16 s_umount_state;          /* this is set to 1 when filesystem was
+                                 * umounted, to 2 - when not */
-                                    * umounted, to 2 - when not */    
+        char s_magic[10];       /* reiserfs magic string indicates that
-    char s_magic[10];              /* reiserfs magic string indicates that
+                                 * file system is reiserfs:
-                                    * file system is reiserfs:
+                                 * "ReIsErFs" or "ReIsEr2Fs" or "ReIsEr3Fs" */
-                                    * "ReIsErFs" or "ReIsEr2Fs" or "ReIsEr3Fs" */
+        __le16 s_fs_state;      /* it is set to used by fsck to mark which
-    __le16 s_fs_state;             /* it is set to used by fsck to mark which
+                                 * phase of rebuilding is done */
-                                    * phase of rebuilding is done */
+        __le32 s_hash_function_code;    /* indicate, what hash function is being use
-    __le32 s_hash_function_code;    /* indicate, what hash function is being use
+                                         * to sort names in a directory*/
-                                    * to sort names in a directory*/
+        __le16 s_tree_height;   /* height of disk tree */
-    __le16 s_tree_height;           /* height of disk tree */
+        __le16 s_bmap_nr;       /* amount of bitmap blocks needed to address
-    __le16 s_bmap_nr;               /* amount of bitmap blocks needed to address
+                                 * each block of file system */
-                                    * each block of file system */
+        __le16 s_version;       /* this field is only reliable on filesystem
-    __le16 s_version;               /* this field is only reliable on filesystem
+                                 * with non-standard journal */
-                                    * with non-standard journal */
+        __le16 s_reserved_for_journal;  /* size in blocks of journal area on main
-    __le16 s_reserved_for_journal;  /* size in blocks of journal area on main
+                                         * device, we need to keep after
-                                    * device, we need to keep after
+                                         * making fs with non-standard journal */
-                                    * making fs with non-standard journal */    
 } __attribute__ ((__packed__));
 #define SB_SIZE_V1 (sizeof(struct reiserfs_super_block_v1))
 /* this is the on disk super block */
-struct reiserfs_super_block
+struct reiserfs_super_block {
-{
+        struct reiserfs_super_block_v1 s_v1;
-    struct reiserfs_super_block_v1 s_v1;
+        __le32 s_inode_generation;
-    __le32 s_inode_generation;
+        __le32 s_flags;         /* Right now used only by inode-attributes, if enabled */
-    __le32 s_flags;                  /* Right now used only by inode-attributes, if enabled */
+        unsigned char s_uuid[16];       /* filesystem unique identifier */
-    unsigned char s_uuid[16];       /* filesystem unique identifier */
+        unsigned char s_label[16];      /* filesystem volume label */
-    unsigned char s_label[16];      /* filesystem volume label */
+        char s_unused[88];      /* zero filled by mkreiserfs and
-    char s_unused[88] ;             /* zero filled by mkreiserfs and
+                                 * reiserfs_convert_objectid_map_v1()
-                                     * reiserfs_convert_objectid_map_v1()
+                                 * so any additions must be updated
-                                     * so any additions must be updated
+                                 * there as well. */
-                                     * there as well. */
+} __attribute__ ((__packed__));
-}  __attribute__ ((__packed__));
 #define SB_SIZE (sizeof(struct reiserfs_super_block))
 #define REISERFS_VERSION_1 0
 #define REISERFS_VERSION_2 2
 // on-disk super block fields converted to cpu form
 #define SB_DISK_SUPER_BLOCK(s) (REISERFS_SB(s)->s_rs)
 #define SB_V1_DISK_SUPER_BLOCK(s) (&(SB_DISK_SUPER_BLOCK(s)->s_v1))
@@ -210,13 +205,12 @@ struct reiserfs_super_block
 #define PUT_SB_TREE_HEIGHT(s, val) \
   do { SB_V1_DISK_SUPER_BLOCK(s)->s_tree_height = cpu_to_le16(val); } while (0)
 #define PUT_SB_REISERFS_STATE(s, val) \
-   do { SB_V1_DISK_SUPER_BLOCK(s)->s_umount_state = cpu_to_le16(val); } while (0) 
+   do { SB_V1_DISK_SUPER_BLOCK(s)->s_umount_state = cpu_to_le16(val); } while (0)
 #define PUT_SB_VERSION(s, val) \
   do { SB_V1_DISK_SUPER_BLOCK(s)->s_version = cpu_to_le16(val); } while (0)
 #define PUT_SB_BMAP_NR(s, val) \
   do { SB_V1_DISK_SUPER_BLOCK(s)->s_bmap_nr = cpu_to_le16 (val); } while (0)
 #define SB_ONDISK_JP(s) (&SB_V1_DISK_SUPER_BLOCK(s)->s_journal)
 #define SB_ONDISK_JOURNAL_SIZE(s) \
         le32_to_cpu ((SB_ONDISK_JP(s)->jp_journal_size))
@@ -231,21 +225,19 @@ struct reiserfs_super_block
         block >= SB_JOURNAL_1st_RESERVED_BLOCK(s) \
         && block < SB_JOURNAL_1st_RESERVED_BLOCK(s) +  \
         ((!is_reiserfs_jr(SB_DISK_SUPER_BLOCK(s)) ? \
-         SB_ONDISK_JOURNAL_SIZE(s) + 1 : SB_ONDISK_RESERVED_FOR_JOURNAL(s))) 
+         SB_ONDISK_JOURNAL_SIZE(s) + 1 : SB_ONDISK_RESERVED_FOR_JOURNAL(s)))
                                /* used by gcc */
 #define REISERFS_SUPER_MAGIC 0x52654973
                                /* used by file system utilities that
-                                   look at the superblock, etc. */
+                                   look at the superblock, etc. */
 #define REISERFS_SUPER_MAGIC_STRING "ReIsErFs"
 #define REISER2FS_SUPER_MAGIC_STRING "ReIsEr2Fs"
 #define REISER2FS_JR_SUPER_MAGIC_STRING "ReIsEr3Fs"
-int is_reiserfs_3_5 (struct reiserfs_super_block * rs);
+int is_reiserfs_3_5(struct reiserfs_super_block *rs);
-int is_reiserfs_3_6 (struct reiserfs_super_block * rs);
+int is_reiserfs_3_6(struct reiserfs_super_block *rs);
-int is_reiserfs_jr (struct reiserfs_super_block * rs);
+int is_reiserfs_jr(struct reiserfs_super_block *rs);
 /* ReiserFS leaves the first 64k unused, so that partition labels have
   enough space.  If someone wants to write a fancy bootloader that
@@ -272,8 +264,8 @@ typedef __u32 b_blocknr_t;
 typedef __le32 unp_t;
 struct unfm_nodeinfo {
-    unp_t unfm_nodenum;
+        unp_t unfm_nodenum;
-    unsigned short unfm_freespace;
+        unsigned short unfm_freespace;
 };
 /* there are two formats of keys: 3.5 and 3.6
@@ -285,7 +277,6 @@ struct unfm_nodeinfo {
 #define STAT_DATA_V1 0
 #define STAT_DATA_V2 1
 static inline struct reiserfs_inode_info *REISERFS_I(const struct inode *inode)
 {
        return container_of(inode, struct reiserfs_inode_info, vfs_inode);
@@ -343,15 +334,13 @@ static inline struct reiserfs_sb_info *REISERFS_SB(const struct super_block *sb)
   file would fit into one DIRECT item.
   Primary intention for this one is to increase performance by decreasing
   seeking.
-*/   
+*/
 #define STORE_TAIL_IN_UNFM_S2(n_file_size,n_tail_size,n_block_size) \
 (\
  (!(n_tail_size)) || \
  (((n_file_size) > MAX_DIRECT_ITEM_LEN(n_block_size)) ) \
 )
 /*
 * values for s_umount_state field
 */
@@ -364,9 +353,9 @@ static inline struct reiserfs_sb_info *REISERFS_SB(const struct super_block *sb)
 #define TYPE_STAT_DATA 0
 #define TYPE_INDIRECT 1
 #define TYPE_DIRECT 2
-#define TYPE_DIRENTRY 3 
+#define TYPE_DIRENTRY 3
-#define TYPE_MAXTYPE 3 
+#define TYPE_MAXTYPE 3
-#define TYPE_ANY 15 // FIXME: comment is required
+#define TYPE_ANY 15             // FIXME: comment is required
 /***************************************************************************/
 /*                       KEY & ITEM HEAD                                   */
@@ -376,60 +365,62 @@ static inline struct reiserfs_sb_info *REISERFS_SB(const struct super_block *sb)
 // directories use this key as well as old files
 //
 struct offset_v1 {
-    __le32 k_offset;
+        __le32 k_offset;
-    __le32 k_uniqueness;
+        __le32 k_uniqueness;
 } __attribute__ ((__packed__));
 struct offset_v2 {
        __le64 v;
 } __attribute__ ((__packed__));
-static inline __u16 offset_v2_k_type( const struct offset_v2 *v2 )
+static inline __u16 offset_v2_k_type(const struct offset_v2 *v2)
 {
        __u8 type = le64_to_cpu(v2->v) >> 60;
-        return (type <= TYPE_MAXTYPE)?type:TYPE_ANY;
+        return (type <= TYPE_MAXTYPE) ? type : TYPE_ANY;
 }
- 
-static inline void set_offset_v2_k_type( struct offset_v2 *v2, int type )
+static inline void set_offset_v2_k_type(struct offset_v2 *v2, int type)
 {
-        v2->v = (v2->v & cpu_to_le64(~0ULL>>4)) | cpu_to_le64((__u64)type<<60);
+        v2->v =
+            (v2->v & cpu_to_le64(~0ULL >> 4)) | cpu_to_le64((__u64) type << 60);
 }
- 
-static inline loff_t offset_v2_k_offset( const struct offset_v2 *v2 )
+static inline loff_t offset_v2_k_offset(const struct offset_v2 *v2)
 {
-        return le64_to_cpu(v2->v) & (~0ULL>>4);
+        return le64_to_cpu(v2->v) & (~0ULL >> 4);
 }
-static inline void set_offset_v2_k_offset( struct offset_v2 *v2, loff_t offset ){
+static inline void set_offset_v2_k_offset(struct offset_v2 *v2, loff_t offset)
-        offset &= (~0ULL>>4);
+{
-        v2->v = (v2->v & cpu_to_le64(15ULL<<60)) | cpu_to_le64(offset);
+        offset &= (~0ULL >> 4);
+        v2->v = (v2->v & cpu_to_le64(15ULL << 60)) | cpu_to_le64(offset);
 }
 /* Key of an item determines its location in the S+tree, and
   is composed of 4 components */
 struct reiserfs_key {
-    __le32 k_dir_id;    /* packing locality: by default parent
+        __le32 k_dir_id;        /* packing locality: by default parent
-                          directory object id */
+                                   directory object id */
-    __le32 k_objectid;  /* object identifier */
+        __le32 k_objectid;      /* object identifier */
-    union {
+        union {
-        struct offset_v1 k_offset_v1;
+                struct offset_v1 k_offset_v1;
-        struct offset_v2 k_offset_v2;
+                struct offset_v2 k_offset_v2;
-    } __attribute__ ((__packed__)) u;
+        } __attribute__ ((__packed__)) u;
 } __attribute__ ((__packed__));
 struct in_core_key {
-    __u32 k_dir_id;    /* packing locality: by default parent
+        __u32 k_dir_id;         /* packing locality: by default parent
-                          directory object id */
+                                   directory object id */
-    __u32 k_objectid;  /* object identifier */
+        __u32 k_objectid;       /* object identifier */
-    __u64 k_offset;
+        __u64 k_offset;
-    __u8 k_type;
+        __u8 k_type;
 };
 struct cpu_key {
-    struct in_core_key on_disk_key;
+        struct in_core_key on_disk_key;
-    int version;
+        int version;
-    int key_length; /* 3 in all cases but direct2indirect and
+        int key_length;         /* 3 in all cases but direct2indirect and
-                       indirect2direct conversion */
+                                   indirect2direct conversion */
 };
 /* Our function for comparing keys can compare keys of different
@@ -475,8 +466,7 @@ struct cpu_key {
    indirect items) and specifies the location of the item itself
    within the block.  */
-struct item_head
+struct item_head {
-{
        /* Everything in the tree is found by searching for it based on
         * its key.*/
        struct reiserfs_key ih_key;
@@ -492,13 +482,13 @@ struct item_head
                   number of directory entries in the directory item. */
                __le16 ih_entry_count;
        } __attribute__ ((__packed__)) u;
-        __le16 ih_item_len;           /* total size of the item body */
+        __le16 ih_item_len;     /* total size of the item body */
-        __le16 ih_item_location;      /* an offset to the item body
+        __le16 ih_item_location;        /* an offset to the item body
-                                      * within the block */
+                                         * within the block */
-        __le16 ih_version;           /* 0 for all old items, 2 for new
+        __le16 ih_version;      /* 0 for all old items, 2 for new
-                                        ones. Highest bit is set by fsck
+                                   ones. Highest bit is set by fsck
-                                        temporary, cleaned after all
+                                   temporary, cleaned after all
-                                        done */
+                                   done */
 } __attribute__ ((__packed__));
 /* size of item header     */
 #define IH_SIZE (sizeof(struct item_head))
@@ -515,7 +505,6 @@ struct item_head
 #define put_ih_location(ih, val)     do { (ih)->ih_item_location = cpu_to_le16(val); } while (0)
 #define put_ih_item_len(ih, val)     do { (ih)->ih_item_len = cpu_to_le16(val); } while (0)
 #define unreachable_item(ih) (ih_version(ih) & (1 << 15))
 #define get_ih_free_space(ih) (ih_version (ih) == KEY_FORMAT_3_6 ? 0 : ih_free_space (ih))
@@ -537,40 +526,48 @@ struct item_head
 #define V1_INDIRECT_UNIQUENESS 0xfffffffe
 #define V1_DIRECT_UNIQUENESS 0xffffffff
 #define V1_DIRENTRY_UNIQUENESS 500
-#define V1_ANY_UNIQUENESS 555 // FIXME: comment is required
+#define V1_ANY_UNIQUENESS 555   // FIXME: comment is required
 //
 // here are conversion routines
 //
-static inline int uniqueness2type (__u32 uniqueness) CONSTF;
+static inline int uniqueness2type(__u32 uniqueness) CONSTF;
-static inline int uniqueness2type (__u32 uniqueness)
+static inline int uniqueness2type(__u32 uniqueness)
 {
-    switch ((int)uniqueness) {
+        switch ((int)uniqueness) {
-    case V1_SD_UNIQUENESS: return TYPE_STAT_DATA;
+        case V1_SD_UNIQUENESS:
-    case V1_INDIRECT_UNIQUENESS: return TYPE_INDIRECT;
+                return TYPE_STAT_DATA;
-    case V1_DIRECT_UNIQUENESS: return TYPE_DIRECT;
+        case V1_INDIRECT_UNIQUENESS:
-    case V1_DIRENTRY_UNIQUENESS: return TYPE_DIRENTRY;
+                return TYPE_INDIRECT;
-    default:
+        case V1_DIRECT_UNIQUENESS:
-            reiserfs_warning (NULL, "vs-500: unknown uniqueness %d",
+                return TYPE_DIRECT;
-                              uniqueness);
+        case V1_DIRENTRY_UNIQUENESS:
+                return TYPE_DIRENTRY;
+        default:
+                reiserfs_warning(NULL, "vs-500: unknown uniqueness %d",
+                                 uniqueness);
        case V1_ANY_UNIQUENESS:
-            return TYPE_ANY;
+                return TYPE_ANY;
-    }
+        }
 }
-static inline __u32 type2uniqueness (int type) CONSTF;
+static inline __u32 type2uniqueness(int type) CONSTF;
-static inline __u32 type2uniqueness (int type)
+static inline __u32 type2uniqueness(int type)
 {
-    switch (type) {
+        switch (type) {
-    case TYPE_STAT_DATA: return V1_SD_UNIQUENESS;
+        case TYPE_STAT_DATA:
-    case TYPE_INDIRECT: return V1_INDIRECT_UNIQUENESS;
+                return V1_SD_UNIQUENESS;
-    case TYPE_DIRECT: return V1_DIRECT_UNIQUENESS;
+        case TYPE_INDIRECT:
-    case TYPE_DIRENTRY: return V1_DIRENTRY_UNIQUENESS;
+                return V1_INDIRECT_UNIQUENESS;
-    default:
+        case TYPE_DIRECT:
-            reiserfs_warning (NULL, "vs-501: unknown type %d", type);
+                return V1_DIRECT_UNIQUENESS;
+        case TYPE_DIRENTRY:
+                return V1_DIRENTRY_UNIQUENESS;
+        default:
+                reiserfs_warning(NULL, "vs-501: unknown type %d", type);
        case TYPE_ANY:
-            return V1_ANY_UNIQUENESS;
+                return V1_ANY_UNIQUENESS;
-    }
+        }
 }
 //
@@ -578,57 +575,56 @@ static inline __u32 type2uniqueness (int type)
 // there is no way to get version of object from key, so, provide
 // version to these defines
 //
-static inline loff_t le_key_k_offset (int version, const struct reiserfs_key * key)
+static inline loff_t le_key_k_offset(int version,
+                                     const struct reiserfs_key *key)
 {
-    return (version == KEY_FORMAT_3_5) ?
+        return (version == KEY_FORMAT_3_5) ?
-        le32_to_cpu( key->u.k_offset_v1.k_offset ) :
+            le32_to_cpu(key->u.k_offset_v1.k_offset) :
-        offset_v2_k_offset( &(key->u.k_offset_v2) );
+            offset_v2_k_offset(&(key->u.k_offset_v2));
 }
-static inline loff_t le_ih_k_offset (const struct item_head * ih)
+static inline loff_t le_ih_k_offset(const struct item_head *ih)
 {
-    return le_key_k_offset (ih_version (ih), &(ih->ih_key));
+        return le_key_k_offset(ih_version(ih), &(ih->ih_key));
 }
-static inline loff_t le_key_k_type (int version, const struct reiserfs_key * key)
+static inline loff_t le_key_k_type(int version, const struct reiserfs_key *key)
 {
-    return (version == KEY_FORMAT_3_5) ?
+        return (version == KEY_FORMAT_3_5) ?
-        uniqueness2type( le32_to_cpu( key->u.k_offset_v1.k_uniqueness)) :
+            uniqueness2type(le32_to_cpu(key->u.k_offset_v1.k_uniqueness)) :
-        offset_v2_k_type( &(key->u.k_offset_v2) );
+            offset_v2_k_type(&(key->u.k_offset_v2));
 }
-static inline loff_t le_ih_k_type (const struct item_head * ih)
+static inline loff_t le_ih_k_type(const struct item_head *ih)
 {
-    return le_key_k_type (ih_version (ih), &(ih->ih_key));
+        return le_key_k_type(ih_version(ih), &(ih->ih_key));
 }
+static inline void set_le_key_k_offset(int version, struct reiserfs_key *key,
-static inline void set_le_key_k_offset (int version, struct reiserfs_key * key, loff_t offset)
+                                       loff_t offset)
 {
-    (version == KEY_FORMAT_3_5) ?
+        (version == KEY_FORMAT_3_5) ? (void)(key->u.k_offset_v1.k_offset = cpu_to_le32(offset)) :       /* jdm check */
-        (void)(key->u.k_offset_v1.k_offset = cpu_to_le32 (offset)) : /* jdm check */
+            (void)(set_offset_v2_k_offset(&(key->u.k_offset_v2), offset));
-        (void)(set_offset_v2_k_offset( &(key->u.k_offset_v2), offset ));
 }
+static inline void set_le_ih_k_offset(struct item_head *ih, loff_t offset)
-static inline void set_le_ih_k_offset (struct item_head * ih, loff_t offset)
 {
-    set_le_key_k_offset (ih_version (ih), &(ih->ih_key), offset);
+        set_le_key_k_offset(ih_version(ih), &(ih->ih_key), offset);
 }
+static inline void set_le_key_k_type(int version, struct reiserfs_key *key,
-static inline void set_le_key_k_type (int version, struct reiserfs_key * key, int type)
+                                     int type)
 {
-    (version == KEY_FORMAT_3_5) ?
+        (version == KEY_FORMAT_3_5) ?
-        (void)(key->u.k_offset_v1.k_uniqueness = cpu_to_le32(type2uniqueness(type))):
+            (void)(key->u.k_offset_v1.k_uniqueness =
-        (void)(set_offset_v2_k_type( &(key->u.k_offset_v2), type ));
+                   cpu_to_le32(type2uniqueness(type)))
+            : (void)(set_offset_v2_k_type(&(key->u.k_offset_v2), type));
 }
-static inline void set_le_ih_k_type (struct item_head * ih, int type)
+static inline void set_le_ih_k_type(struct item_head *ih, int type)
 {
-    set_le_key_k_type (ih_version (ih), &(ih->ih_key), type);
+        set_le_key_k_type(ih_version(ih), &(ih->ih_key), type);
 }
 #define is_direntry_le_key(version,key) (le_key_k_type (version, key) == TYPE_DIRENTRY)
 #define is_direct_le_key(version,key) (le_key_k_type (version, key) == TYPE_DIRECT)
 #define is_indirect_le_key(version,key) (le_key_k_type (version, key) == TYPE_INDIRECT)
@@ -642,34 +638,32 @@ static inline void set_le_ih_k_type (struct item_head * ih, int type)
 #define is_indirect_le_ih(ih) is_indirect_le_key (ih_version(ih), &((ih)->ih_key))
 #define is_statdata_le_ih(ih) is_statdata_le_key (ih_version (ih), &((ih)->ih_key))
 //
 // key is pointer to cpu key, result is cpu
 //
-static inline loff_t cpu_key_k_offset (const struct cpu_key * key)
+static inline loff_t cpu_key_k_offset(const struct cpu_key *key)
 {
-    return key->on_disk_key.k_offset;
+        return key->on_disk_key.k_offset;
 }
-static inline loff_t cpu_key_k_type (const struct cpu_key * key)
+static inline loff_t cpu_key_k_type(const struct cpu_key *key)
 {
-    return key->on_disk_key.k_type;
+        return key->on_disk_key.k_type;
 }
-static inline void set_cpu_key_k_offset (struct cpu_key * key, loff_t offset)
+static inline void set_cpu_key_k_offset(struct cpu_key *key, loff_t offset)
 {
        key->on_disk_key.k_offset = offset;
 }
-static inline void set_cpu_key_k_type (struct cpu_key * key, int type)
+static inline void set_cpu_key_k_type(struct cpu_key *key, int type)
 {
        key->on_disk_key.k_type = type;
 }
-static inline void cpu_key_k_offset_dec (struct cpu_key * key)
+static inline void cpu_key_k_offset_dec(struct cpu_key *key)
 {
-        key->on_disk_key.k_offset --;
+        key->on_disk_key.k_offset--;
 }
 #define is_direntry_cpu_key(key) (cpu_key_k_type (key) == TYPE_DIRENTRY)
@@ -677,34 +671,25 @@ static inline void cpu_key_k_offset_dec (struct cpu_key * key)
 #define is_indirect_cpu_key(key) (cpu_key_k_type (key) == TYPE_INDIRECT)
 #define is_statdata_cpu_key(key) (cpu_key_k_type (key) == TYPE_STAT_DATA)
 /* are these used ? */
 #define is_direntry_cpu_ih(ih) (is_direntry_cpu_key (&((ih)->ih_key)))
 #define is_direct_cpu_ih(ih) (is_direct_cpu_key (&((ih)->ih_key)))
 #define is_indirect_cpu_ih(ih) (is_indirect_cpu_key (&((ih)->ih_key)))
 #define is_statdata_cpu_ih(ih) (is_statdata_cpu_key (&((ih)->ih_key)))
 #define I_K_KEY_IN_ITEM(p_s_ih, p_s_key, n_blocksize) \
    ( ! COMP_SHORT_KEYS(p_s_ih, p_s_key) && \
          I_OFF_BYTE_IN_ITEM(p_s_ih, k_offset (p_s_key), n_blocksize) )
-/* maximal length of item */ 
+/* maximal length of item */
 #define MAX_ITEM_LEN(block_size) (block_size - BLKH_SIZE - IH_SIZE)
 #define MIN_ITEM_LEN 1
 /* object identifier for root dir */
 #define REISERFS_ROOT_OBJECTID 2
 #define REISERFS_ROOT_PARENT_OBJECTID 1
 extern struct reiserfs_key root_key;
 /* 
 * Picture represents a leaf of the S+tree
 *  ______________________________________________________
@@ -716,13 +701,13 @@ extern struct reiserfs_key root_key;
 /* Header of a disk block.  More precisely, header of a formatted leaf
   or internal node, and not the header of an unformatted node. */
-struct block_head {       
+struct block_head {
-  __le16 blk_level;        /* Level of a block in the tree. */
+        __le16 blk_level;       /* Level of a block in the tree. */
-  __le16 blk_nr_item;      /* Number of keys/items in a block. */
+        __le16 blk_nr_item;     /* Number of keys/items in a block. */
-  __le16 blk_free_space;   /* Block free space in bytes. */
+        __le16 blk_free_space;  /* Block free space in bytes. */
-  __le16 blk_reserved;
+        __le16 blk_reserved;
-                                /* dump this in v4/planA */
+        /* dump this in v4/planA */
-  struct reiserfs_key  blk_right_delim_key; /* kept only for compatibility */
+        struct reiserfs_key blk_right_delim_key;        /* kept only for compatibility */
 };
 #define BLKH_SIZE                     (sizeof(struct block_head))
@@ -741,12 +726,12 @@ struct block_head {
 * values for blk_level field of the struct block_head
 */
-#define FREE_LEVEL 0 /* when node gets removed from the tree its
+#define FREE_LEVEL 0            /* when node gets removed from the tree its
-                        blk_level is set to FREE_LEVEL. It is then
+                                   blk_level is set to FREE_LEVEL. It is then
-                        used to see whether the node is still in the
+                                   used to see whether the node is still in the
-                        tree */
+                                   tree */
-#define DISK_LEAF_NODE_LEVEL  1 /* Leaf node level.*/
+#define DISK_LEAF_NODE_LEVEL  1 /* Leaf node level. */
 /* Given the buffer head of a formatted node, resolve to the block head of that node. */
 #define B_BLK_HEAD(p_s_bh)            ((struct block_head *)((p_s_bh)->b_data))
@@ -759,7 +744,6 @@ struct block_head {
 #define PUT_B_LEVEL(p_s_bh,val)       do { set_blkh_level(B_BLK_HEAD(p_s_bh),val); } while (0)
 #define PUT_B_FREE_SPACE(p_s_bh,val)  do { set_blkh_free_space(B_BLK_HEAD(p_s_bh),val); } while (0)
 /* Get right delimiting key. -- little endian */
 #define B_PRIGHT_DELIM_KEY(p_s_bh)   (&(blk_right_delim_key(B_BLK_HEAD(p_s_bh))
@@ -770,41 +754,36 @@ struct block_head {
 #define B_IS_KEYS_LEVEL(p_s_bh)      (B_LEVEL(p_s_bh) > DISK_LEAF_NODE_LEVEL \
                                            && B_LEVEL(p_s_bh) <= MAX_HEIGHT)
 /***************************************************************************/
 /*                             STAT DATA                                   */
 /***************************************************************************/
 //
 // old stat data is 32 bytes long. We are going to distinguish new one by
 // different size
 //
-struct stat_data_v1
+struct stat_data_v1 {
-{
+        __le16 sd_mode;         /* file type, permissions */
-    __le16 sd_mode;     /* file type, permissions */
+        __le16 sd_nlink;        /* number of hard links */
-    __le16 sd_nlink;    /* number of hard links */
+        __le16 sd_uid;          /* owner */
-    __le16 sd_uid;              /* owner */
+        __le16 sd_gid;          /* group */
-    __le16 sd_gid;              /* group */
+        __le32 sd_size;         /* file size */
-    __le32 sd_size;     /* file size */
+        __le32 sd_atime;        /* time of last access */
-    __le32 sd_atime;    /* time of last access */
+        __le32 sd_mtime;        /* time file was last modified  */
-    __le32 sd_mtime;    /* time file was last modified  */
+        __le32 sd_ctime;        /* time inode (stat data) was last changed (except changes to sd_atime and sd_mtime) */
-    __le32 sd_ctime;    /* time inode (stat data) was last changed (except changes to sd_atime and sd_mtime) */
+        union {
-    union {
+                __le32 sd_rdev;
-        __le32 sd_rdev;
+                __le32 sd_blocks;       /* number of blocks file uses */
-        __le32 sd_blocks;       /* number of blocks file uses */
+        } __attribute__ ((__packed__)) u;
-    } __attribute__ ((__packed__)) u;
+        __le32 sd_first_direct_byte;    /* first byte of file which is stored
-    __le32 sd_first_direct_byte; /* first byte of file which is stored
+                                           in a direct item: except that if it
-                                   in a direct item: except that if it
+                                           equals 1 it is a symlink and if it
-                                   equals 1 it is a symlink and if it
+                                           equals ~(__u32)0 there is no
-                                   equals ~(__u32)0 there is no
+                                           direct item.  The existence of this
-                                   direct item.  The existence of this
+                                           field really grates on me. Let's
-                                   field really grates on me. Let's
+                                           replace it with a macro based on
-                                   replace it with a macro based on
+                                           sd_size and our tail suppression
-                                   sd_size and our tail suppression
+                                           policy.  Someday.  -Hans */
-                                   policy.  Someday.  -Hans */
 } __attribute__ ((__packed__));
 #define SD_V1_SIZE              (sizeof(struct stat_data_v1))
@@ -862,29 +841,29 @@ struct stat_data_v1
 /* Stat Data on disk (reiserfs version of UFS disk inode minus the
   address blocks) */
 struct stat_data {
-    __le16 sd_mode;     /* file type, permissions */
+        __le16 sd_mode;         /* file type, permissions */
-    __le16 sd_attrs;     /* persistent inode flags */
+        __le16 sd_attrs;        /* persistent inode flags */
-    __le32 sd_nlink;    /* number of hard links */
+        __le32 sd_nlink;        /* number of hard links */
-    __le64 sd_size;     /* file size */
+        __le64 sd_size;         /* file size */
-    __le32 sd_uid;              /* owner */
+        __le32 sd_uid;          /* owner */
-    __le32 sd_gid;              /* group */
+        __le32 sd_gid;          /* group */
-    __le32 sd_atime;    /* time of last access */
+        __le32 sd_atime;        /* time of last access */
-    __le32 sd_mtime;    /* time file was last modified  */
+        __le32 sd_mtime;        /* time file was last modified  */
-    __le32 sd_ctime;    /* time inode (stat data) was last changed (except changes to sd_atime and sd_mtime) */
+        __le32 sd_ctime;        /* time inode (stat data) was last changed (except changes to sd_atime and sd_mtime) */
-    __le32 sd_blocks;
+        __le32 sd_blocks;
-    union {
+        union {
-        __le32 sd_rdev;
+                __le32 sd_rdev;
-        __le32 sd_generation;
+                __le32 sd_generation;
-      //__le32 sd_first_direct_byte;
+                //__le32 sd_first_direct_byte;
-      /* first byte of file which is stored in a
+                /* first byte of file which is stored in a
-                                       direct item: except that if it equals 1
+                   direct item: except that if it equals 1
-                                       it is a symlink and if it equals
+                   it is a symlink and if it equals
-                                       ~(__u32)0 there is no direct item.  The
+                   ~(__u32)0 there is no direct item.  The
-                                       existence of this field really grates
+                   existence of this field really grates
-                                       on me. Let's replace it with a macro
+                   on me. Let's replace it with a macro
-                                       based on sd_size and our tail
+                   based on sd_size and our tail
-                                       suppression policy? */
+                   suppression policy? */
-  } __attribute__ ((__packed__)) u;
+        } __attribute__ ((__packed__)) u;
 } __attribute__ ((__packed__));
 //
 // this is 44 bytes long
@@ -919,7 +898,6 @@ struct stat_data {
 #define sd_v2_attrs(sdp)         (le16_to_cpu((sdp)->sd_attrs))
 #define set_sd_v2_attrs(sdp,v)   ((sdp)->sd_attrs = cpu_to_le16(v))
 /***************************************************************************/
 /*                      DIRECTORY STRUCTURE                                */
 /***************************************************************************/
@@ -954,17 +932,14 @@ struct stat_data {
 /* NOT IMPLEMENTED:   
   Directory will someday contain stat data of object */
+struct reiserfs_de_head {
+        __le32 deh_offset;      /* third component of the directory entry key */
-struct reiserfs_de_head
+        __le32 deh_dir_id;      /* objectid of the parent directory of the object, that is referenced
-{
+                                   by directory entry */
-  __le32 deh_offset;            /* third component of the directory entry key */
+        __le32 deh_objectid;    /* objectid of the object, that is referenced by directory entry */
-  __le32 deh_dir_id;            /* objectid of the parent directory of the object, that is referenced
+        __le16 deh_location;    /* offset of name in the whole item */
-                                           by directory entry */
+        __le16 deh_state;       /* whether 1) entry contains stat data (for future), and 2) whether
-  __le32 deh_objectid;          /* objectid of the object, that is referenced by directory entry */
+                                   entry is hidden (unlinked) */
-  __le16 deh_location;          /* offset of name in the whole item */
-  __le16 deh_state;             /* whether 1) entry contains stat data (for future), and 2) whether
-                                           entry is hidden (unlinked) */
 } __attribute__ ((__packed__));
 #define DEH_SIZE                  sizeof(struct reiserfs_de_head)
 #define deh_offset(p_deh)         (le32_to_cpu((p_deh)->deh_offset))
@@ -986,7 +961,7 @@ struct reiserfs_de_head
 /* old format directories have this size when empty */
 #define EMPTY_DIR_SIZE_V1 (DEH_SIZE * 2 + 3)
-#define DEH_Statdata 0                  /* not used now */
+#define DEH_Statdata 0          /* not used now */
 #define DEH_Visible 2
 /* 64 bit systems (and the S/390) need to be aligned explicitly -jdm */
@@ -1023,10 +998,10 @@ struct reiserfs_de_head
 #define de_visible(deh)             test_bit_unaligned (DEH_Visible, &((deh)->deh_state))
 #define de_hidden(deh)              !test_bit_unaligned (DEH_Visible, &((deh)->deh_state))
-extern void make_empty_dir_item_v1 (char * body, __le32 dirid, __le32 objid,
+extern void make_empty_dir_item_v1(char *body, __le32 dirid, __le32 objid,
-                                    __le32 par_dirid, __le32 par_objid);
+                                   __le32 par_dirid, __le32 par_objid);
-extern void make_empty_dir_item (char * body, __le32 dirid, __le32 objid,
+extern void make_empty_dir_item(char *body, __le32 dirid, __le32 objid,
-                                 __le32 par_dirid, __le32 par_objid);
+                                __le32 par_dirid, __le32 par_objid);
 /* array of the entry headers */
 /* get item body */
@@ -1043,53 +1018,48 @@ extern void make_empty_dir_item (char * body, __le32 dirid, __le32 objid,
 #define I_DEH_N_ENTRY_LENGTH(ih,deh,i) \
 ((i) ? (deh_location((deh)-1) - deh_location((deh))) : (ih_item_len((ih)) - deh_location((deh))))
 */
-static inline int entry_length (const struct buffer_head * bh, 
+static inline int entry_length(const struct buffer_head *bh,
-                                                                const struct item_head * ih, int pos_in_item)
+                               const struct item_head *ih, int pos_in_item)
 {
-    struct reiserfs_de_head * deh;
+        struct reiserfs_de_head *deh;
-    deh = B_I_DEH (bh, ih) + pos_in_item;
+        deh = B_I_DEH(bh, ih) + pos_in_item;
-    if (pos_in_item)
+        if (pos_in_item)
-        return deh_location(deh-1) - deh_location(deh);
+                return deh_location(deh - 1) - deh_location(deh);
-    return ih_item_len(ih) - deh_location(deh);
+        return ih_item_len(ih) - deh_location(deh);
 }
 /* number of entries in the directory item, depends on ENTRY_COUNT being at the start of directory dynamic data. */
 #define I_ENTRY_COUNT(ih) (ih_entry_count((ih)))
 /* name by bh, ih and entry_num */
 #define B_I_E_NAME(bh,ih,entry_num) ((char *)(bh->b_data + ih_location(ih) + deh_location(B_I_DEH(bh,ih)+(entry_num))))
 // two entries per block (at least)
 #define REISERFS_MAX_NAME(block_size) 255
 /* this structure is used for operations on directory entries. It is
   not a disk structure. */
 /* When reiserfs_find_entry or search_by_entry_key find directory
   entry, they return filled reiserfs_dir_entry structure */
-struct reiserfs_dir_entry
+struct reiserfs_dir_entry {
-{
+        struct buffer_head *de_bh;
-  struct buffer_head * de_bh;
+        int de_item_num;
-  int de_item_num;
+        struct item_head *de_ih;
-  struct item_head * de_ih;
+        int de_entry_num;
-  int de_entry_num;
+        struct reiserfs_de_head *de_deh;
-  struct reiserfs_de_head * de_deh;
+        int de_entrylen;
-  int de_entrylen;
+        int de_namelen;
-  int de_namelen;
+        char *de_name;
-  char * de_name;
+        char *de_gen_number_bit_string;
-  char * de_gen_number_bit_string;
+        __u32 de_dir_id;
-  __u32 de_dir_id;
+        __u32 de_objectid;
-  __u32 de_objectid;
+        struct cpu_key de_entry_key;
-  struct cpu_key de_entry_key;
 };
-   
 /* these defines are useful when a particular member of a reiserfs_dir_entry is needed */
 /* pointer to file name, stored in entry */
@@ -1099,8 +1069,6 @@ struct reiserfs_dir_entry
 #define I_DEH_N_ENTRY_FILE_NAME_LENGTH(ih,deh,entry_num) \
 (I_DEH_N_ENTRY_LENGTH (ih, deh, entry_num) - (de_with_sd (deh) ? SD_SIZE : 0))
 /* hash value occupies bits from 7 up to 30 */
 #define GET_HASH_VALUE(offset) ((offset) & 0x7fffff80LL)
 /* generation number occupies 7 bits starting from 0 up to 6 */
@@ -1109,7 +1077,6 @@ struct reiserfs_dir_entry
 #define SET_GENERATION_NUMBER(offset,gen_number) (GET_HASH_VALUE(offset)|(gen_number))
 /*
 * Picture represents an internal node of the reiserfs tree
 *  ______________________________________________________
@@ -1125,9 +1092,9 @@ struct reiserfs_dir_entry
 /* Disk child pointer: The pointer from an internal node of the tree
   to a node that is on disk. */
 struct disk_child {
-  __le32       dc_block_number;              /* Disk child's block number. */
+        __le32 dc_block_number; /* Disk child's block number. */
-  __le16       dc_size;                     /* Disk child's used space.   */
+        __le16 dc_size;         /* Disk child's used space.   */
-  __le16       dc_reserved;
+        __le16 dc_reserved;
 };
 #define DC_SIZE (sizeof(struct disk_child))
@@ -1144,7 +1111,7 @@ struct disk_child {
 #define B_N_CHILD_NUM(p_s_bh,n_pos) (dc_block_number(B_N_CHILD(p_s_bh,n_pos)))
 #define PUT_B_N_CHILD_NUM(p_s_bh,n_pos, val) (put_dc_block_number(B_N_CHILD(p_s_bh,n_pos), val ))
- /* maximal value of field child_size in structure disk_child */ 
+ /* maximal value of field child_size in structure disk_child */
 /* child size is the combined size of all items and their headers */
 #define MAX_CHILD_SIZE(bh) ((int)( (bh)->b_size - BLKH_SIZE ))
@@ -1159,7 +1126,6 @@ struct disk_child {
 /*                      PATH STRUCTURES AND DEFINES                        */
 /***************************************************************************/
 /* Search_by_key fills up the path from the root to the leaf as it descends the tree looking for the
   key.  It uses reiserfs_bread to try to find buffers in the cache given their block number.  If it
   does not find them in the cache it reads them from disk.  For each node search_by_key finds using
@@ -1168,20 +1134,18 @@ struct disk_child {
   is looking through a leaf node bin_search will find the position of the item which has key either
   equal to given key, or which is the maximal key less than the given key. */
-struct  path_element  {
+struct path_element {
-  struct buffer_head *  pe_buffer;    /* Pointer to the buffer at the path in the tree. */
+        struct buffer_head *pe_buffer;  /* Pointer to the buffer at the path in the tree. */
-  int                   pe_position;  /* Position in the tree node which is placed in the */
+        int pe_position;        /* Position in the tree node which is placed in the */
-                                      /* buffer above.                                  */
+        /* buffer above.                                  */
 };
-#define MAX_HEIGHT 5 /* maximal height of a tree. don't change this without changing JOURNAL_PER_BALANCE_CNT */
+#define MAX_HEIGHT 5            /* maximal height of a tree. don't change this without changing JOURNAL_PER_BALANCE_CNT */
-#define EXTENDED_MAX_HEIGHT         7 /* Must be equals MAX_HEIGHT + FIRST_PATH_ELEMENT_OFFSET */
+#define EXTENDED_MAX_HEIGHT         7   /* Must be equals MAX_HEIGHT + FIRST_PATH_ELEMENT_OFFSET */
-#define FIRST_PATH_ELEMENT_OFFSET   2 /* Must be equal to at least 2. */
+#define FIRST_PATH_ELEMENT_OFFSET   2   /* Must be equal to at least 2. */
-#define ILLEGAL_PATH_ELEMENT_OFFSET 1 /* Must be equal to FIRST_PATH_ELEMENT_OFFSET - 1 */
-#define MAX_FEB_SIZE 6   /* this MUST be MAX_HEIGHT + 1. See about FEB below */
+#define ILLEGAL_PATH_ELEMENT_OFFSET 1   /* Must be equal to FIRST_PATH_ELEMENT_OFFSET - 1 */
+#define MAX_FEB_SIZE 6          /* this MUST be MAX_HEIGHT + 1. See about FEB below */
 /* We need to keep track of who the ancestors of nodes are.  When we
   perform a search we record which nodes were visited while
@@ -1200,14 +1164,14 @@ excessive effort to avoid disturbing the precious VFS code.:-( The
 gods only know how we are going to SMP the code that uses them.
 znodes are the way! */
-#define PATH_READA      0x1 /* do read ahead */
+#define PATH_READA      0x1     /* do read ahead */
-#define PATH_READA_BACK 0x2 /* read backwards */
+#define PATH_READA_BACK 0x2     /* read backwards */
-struct  path {
+struct path {
-  int                   path_length;                            /* Length of the array above.   */
+        int path_length;        /* Length of the array above.   */
-  int                   reada;
+        int reada;
-  struct  path_element  path_elements[EXTENDED_MAX_HEIGHT];     /* Array of the path elements.  */
+        struct path_element path_elements[EXTENDED_MAX_HEIGHT]; /* Array of the path elements.  */
-  int                   pos_in_item;
+        int pos_in_item;
 };
 #define pos_in_item(path) ((path)->pos_in_item)
@@ -1224,25 +1188,23 @@ struct path var = {.path_length = ILLEGAL_PATH_ELEMENT_OFFSET, .reada = 0,}
 /* Get position in the element at the path by path and path position. */
 #define PATH_OFFSET_POSITION(p_s_path,n_offset) (PATH_OFFSET_PELEMENT(p_s_path,n_offset)->pe_position)
 #define PATH_PLAST_BUFFER(p_s_path) (PATH_OFFSET_PBUFFER((p_s_path), (p_s_path)->path_length))
                                /* you know, to the person who didn't
-                                   write this the macro name does not
+                                   write this the macro name does not
-                                   at first suggest what it does.
+                                   at first suggest what it does.
-                                   Maybe POSITION_FROM_PATH_END? Or
+                                   Maybe POSITION_FROM_PATH_END? Or
-                                   maybe we should just focus on
+                                   maybe we should just focus on
-                                   dumping paths... -Hans */
+                                   dumping paths... -Hans */
 #define PATH_LAST_POSITION(p_s_path) (PATH_OFFSET_POSITION((p_s_path), (p_s_path)->path_length))
 #define PATH_PITEM_HEAD(p_s_path)    B_N_PITEM_HEAD(PATH_PLAST_BUFFER(p_s_path),PATH_LAST_POSITION(p_s_path))
 /* in do_balance leaf has h == 0 in contrast with path structure,
   where root has level == 0. That is why we need these defines */
 #define PATH_H_PBUFFER(p_s_path, h) PATH_OFFSET_PBUFFER (p_s_path, p_s_path->path_length - (h)) /* tb->S[h] */
-#define PATH_H_PPARENT(path, h) PATH_H_PBUFFER (path, (h) + 1)                  /* tb->F[h] or tb->S[0]->b_parent */
+#define PATH_H_PPARENT(path, h) PATH_H_PBUFFER (path, (h) + 1)  /* tb->F[h] or tb->S[0]->b_parent */
-#define PATH_H_POSITION(path, h) PATH_OFFSET_POSITION (path, path->path_length - (h))   
+#define PATH_H_POSITION(path, h) PATH_OFFSET_POSITION (path, path->path_length - (h))
-#define PATH_H_B_ITEM_ORDER(path, h) PATH_H_POSITION(path, h + 1)               /* tb->S[h]->b_item_order */
+#define PATH_H_B_ITEM_ORDER(path, h) PATH_H_POSITION(path, h + 1)       /* tb->S[h]->b_item_order */
 #define PATH_H_PATH_OFFSET(p_s_path, n_h) ((p_s_path)->path_length - (n_h))
@@ -1253,7 +1215,6 @@ struct path var = {.path_length = ILLEGAL_PATH_ELEMENT_OFFSET, .reada = 0,}
 #define item_moved(ih,path) comp_items(ih, path)
 #define path_changed(ih,path) comp_items (ih, path)
 /***************************************************************************/
 /*                       MISC                                              */
 /***************************************************************************/
@@ -1272,30 +1233,26 @@ struct path var = {.path_length = ILLEGAL_PATH_ELEMENT_OFFSET, .reada = 0,}
 // reiserfs version 2 has max offset 60 bits. Version 1 - 32 bit offset
 #define U32_MAX (~(__u32)0)
-static inline loff_t max_reiserfs_offset (struct inode * inode)
+static inline loff_t max_reiserfs_offset(struct inode *inode)
 {
-    if (get_inode_item_key_version(inode) == KEY_FORMAT_3_5)
+        if (get_inode_item_key_version(inode) == KEY_FORMAT_3_5)
-        return (loff_t)U32_MAX;
+                return (loff_t) U32_MAX;
-    return (loff_t)((~(__u64)0) >> 4);
+        return (loff_t) ((~(__u64) 0) >> 4);
 }
 /*#define MAX_KEY_UNIQUENESS    MAX_UL_INT*/
 #define MAX_KEY_OBJECTID        MAX_UL_INT
 #define MAX_B_NUM  MAX_UL_INT
 #define MAX_FC_NUM MAX_US_INT
 /* the purpose is to detect overflow of an unsigned short */
 #define REISERFS_LINK_MAX (MAX_US_INT - 1000)
 /* The following defines are used in reiserfs_insert_item and reiserfs_append_item  */
-#define REISERFS_KERNEL_MEM             0       /* reiserfs kernel memory mode  */
+#define REISERFS_KERNEL_MEM             0       /* reiserfs kernel memory mode  */
-#define REISERFS_USER_MEM               1       /* reiserfs user memory mode            */
+#define REISERFS_USER_MEM               1       /* reiserfs user memory mode            */
 #define fs_generation(s) (REISERFS_SB(s)->s_generation_counter)
 #define get_generation(s) atomic_read (&fs_generation(s))
@@ -1303,7 +1260,6 @@ static inline loff_t max_reiserfs_offset (struct inode * inode)
 #define __fs_changed(gen,s) (gen != get_generation (s))
 #define fs_changed(gen,s) ({cond_resched(); __fs_changed(gen, s);})
 /***************************************************************************/
 /*                  FIXATE NODES                                           */
 /***************************************************************************/
@@ -1324,38 +1280,34 @@ static inline loff_t max_reiserfs_offset (struct inode * inode)
   calculating what we can shift to neighbors and how many nodes we
   have to have if we do not any shiftings, if we shift to left/right
   neighbor or to both. */
-struct virtual_item
+struct virtual_item {
-{
+        int vi_index;           // index in the array of item operations
-    int vi_index; // index in the array of item operations
+        unsigned short vi_type; // left/right mergeability
-    unsigned short vi_type;     // left/right mergeability
+        unsigned short vi_item_len;     /* length of item that it will have after balancing */
-    unsigned short vi_item_len;           /* length of item that it will have after balancing */
+        struct item_head *vi_ih;
-    struct item_head * vi_ih;
+        const char *vi_item;    // body of item (old or new)
-    const char * vi_item;     // body of item (old or new)
+        const void *vi_new_data;        // 0 always but paste mode
-    const void * vi_new_data; // 0 always but paste mode
+        void *vi_uarea;         // item specific area
-    void * vi_uarea;    // item specific area
 };
+struct virtual_node {
-struct virtual_node
+        char *vn_free_ptr;      /* this is a pointer to the free space in the buffer */
-{
+        unsigned short vn_nr_item;      /* number of items in virtual node */
-  char * vn_free_ptr;           /* this is a pointer to the free space in the buffer */
+        short vn_size;          /* size of node , that node would have if it has unlimited size and no balancing is performed */
-  unsigned short vn_nr_item;    /* number of items in virtual node */
+        short vn_mode;          /* mode of balancing (paste, insert, delete, cut) */
-  short vn_size;                /* size of node , that node would have if it has unlimited size and no balancing is performed */
+        short vn_affected_item_num;
-  short vn_mode;                /* mode of balancing (paste, insert, delete, cut) */
+        short vn_pos_in_item;
-  short vn_affected_item_num; 
+        struct item_head *vn_ins_ih;    /* item header of inserted item, 0 for other modes */
-  short vn_pos_in_item;
+        const void *vn_data;
-  struct item_head * vn_ins_ih; /* item header of inserted item, 0 for other modes */
+        struct virtual_item *vn_vi;     /* array of items (including a new one, excluding item to be deleted) */
-  const void * vn_data;
-  struct virtual_item * vn_vi;  /* array of items (including a new one, excluding item to be deleted) */
 };
 /* used by directory items when creating virtual nodes */
 struct direntry_uarea {
-    int flags;
+        int flags;
-    __u16 entry_count;
+        __u16 entry_count;
-    __u16 entry_sizes[1];
+        __u16 entry_sizes[1];
-} __attribute__ ((__packed__)) ;
+} __attribute__ ((__packed__));
 /***************************************************************************/
 /*                  TREE BALANCE                                           */
@@ -1378,73 +1330,72 @@ struct direntry_uarea {
 #define MAX_AMOUNT_NEEDED 2
 /* someday somebody will prefix every field in this struct with tb_ */
-struct tree_balance
+struct tree_balance {
-{
+        int tb_mode;
-  int tb_mode;
+        int need_balance_dirty;
-  int need_balance_dirty;
+        struct super_block *tb_sb;
-  struct super_block * tb_sb;
+        struct reiserfs_transaction_handle *transaction_handle;
-  struct reiserfs_transaction_handle *transaction_handle ;
+        struct path *tb_path;
-  struct path * tb_path;
+        struct buffer_head *L[MAX_HEIGHT];      /* array of left neighbors of nodes in the path */
-  struct buffer_head * L[MAX_HEIGHT];        /* array of left neighbors of nodes in the path */
+        struct buffer_head *R[MAX_HEIGHT];      /* array of right neighbors of nodes in the path */
-  struct buffer_head * R[MAX_HEIGHT];        /* array of right neighbors of nodes in the path*/
+        struct buffer_head *FL[MAX_HEIGHT];     /* array of fathers of the left  neighbors      */
-  struct buffer_head * FL[MAX_HEIGHT];       /* array of fathers of the left  neighbors      */
+        struct buffer_head *FR[MAX_HEIGHT];     /* array of fathers of the right neighbors      */
-  struct buffer_head * FR[MAX_HEIGHT];       /* array of fathers of the right neighbors      */
+        struct buffer_head *CFL[MAX_HEIGHT];    /* array of common parents of center node and its left neighbor  */
-  struct buffer_head * CFL[MAX_HEIGHT];      /* array of common parents of center node and its left neighbor  */
+        struct buffer_head *CFR[MAX_HEIGHT];    /* array of common parents of center node and its right neighbor */
-  struct buffer_head * CFR[MAX_HEIGHT];      /* array of common parents of center node and its right neighbor */
+        struct buffer_head *FEB[MAX_FEB_SIZE];  /* array of empty buffers. Number of buffers in array equals
-  struct buffer_head * FEB[MAX_FEB_SIZE]; /* array of empty buffers. Number of buffers in array equals
+                                                   cur_blknum. */
-                                             cur_blknum. */
+        struct buffer_head *used[MAX_FEB_SIZE];
-  struct buffer_head * used[MAX_FEB_SIZE];
+        struct buffer_head *thrown[MAX_FEB_SIZE];
-  struct buffer_head * thrown[MAX_FEB_SIZE];
+        int lnum[MAX_HEIGHT];   /* array of number of items which must be
-  int lnum[MAX_HEIGHT]; /* array of number of items which must be
+                                   shifted to the left in order to balance the
-                           shifted to the left in order to balance the
+                                   current node; for leaves includes item that
-                           current node; for leaves includes item that
+                                   will be partially shifted; for internal
-                           will be partially shifted; for internal
+                                   nodes, it is the number of child pointers
-                           nodes, it is the number of child pointers
+                                   rather than items. It includes the new item
-                           rather than items. It includes the new item
+                                   being created. The code sometimes subtracts
-                           being created. The code sometimes subtracts
+                                   one to get the number of wholly shifted
-                           one to get the number of wholly shifted
+                                   items for other purposes. */
-                           items for other purposes. */
+        int rnum[MAX_HEIGHT];   /* substitute right for left in comment above */
-  int rnum[MAX_HEIGHT]; /* substitute right for left in comment above */
+        int lkey[MAX_HEIGHT];   /* array indexed by height h mapping the key delimiting L[h] and
-  int lkey[MAX_HEIGHT];               /* array indexed by height h mapping the key delimiting L[h] and
+                                   S[h] to its item number within the node CFL[h] */
-                                               S[h] to its item number within the node CFL[h] */
+        int rkey[MAX_HEIGHT];   /* substitute r for l in comment above */
-  int rkey[MAX_HEIGHT];               /* substitute r for l in comment above */
+        int insert_size[MAX_HEIGHT];    /* the number of bytes by we are trying to add or remove from
-  int insert_size[MAX_HEIGHT];        /* the number of bytes by we are trying to add or remove from
+                                           S[h]. A negative value means removing.  */
-                                               S[h]. A negative value means removing.  */
+        int blknum[MAX_HEIGHT]; /* number of nodes that will replace node S[h] after
-  int blknum[MAX_HEIGHT];             /* number of nodes that will replace node S[h] after
+                                   balancing on the level h of the tree.  If 0 then S is
-                                               balancing on the level h of the tree.  If 0 then S is
+                                   being deleted, if 1 then S is remaining and no new nodes
-                                               being deleted, if 1 then S is remaining and no new nodes
+                                   are being created, if 2 or 3 then 1 or 2 new nodes is
-                                               are being created, if 2 or 3 then 1 or 2 new nodes is
+                                   being created */
-                                               being created */
+        /* fields that are used only for balancing leaves of the tree */
-  /* fields that are used only for balancing leaves of the tree */
+        int cur_blknum;         /* number of empty blocks having been already allocated                 */
-  int cur_blknum;       /* number of empty blocks having been already allocated                 */
+        int s0num;              /* number of items that fall into left most  node when S[0] splits     */
-  int s0num;             /* number of items that fall into left most  node when S[0] splits     */
+        int s1num;              /* number of items that fall into first  new node when S[0] splits     */
-  int s1num;             /* number of items that fall into first  new node when S[0] splits     */
+        int s2num;              /* number of items that fall into second new node when S[0] splits     */
-  int s2num;             /* number of items that fall into second new node when S[0] splits     */
+        int lbytes;             /* number of bytes which can flow to the left neighbor from the        left    */
-  int lbytes;            /* number of bytes which can flow to the left neighbor from the        left    */
+        /* most liquid item that cannot be shifted from S[0] entirely         */
-  /* most liquid item that cannot be shifted from S[0] entirely         */
+        /* if -1 then nothing will be partially shifted */
-  /* if -1 then nothing will be partially shifted */
+        int rbytes;             /* number of bytes which will flow to the right neighbor from the right        */
-  int rbytes;            /* number of bytes which will flow to the right neighbor from the right        */
+        /* most liquid item that cannot be shifted from S[0] entirely         */
-  /* most liquid item that cannot be shifted from S[0] entirely         */
+        /* if -1 then nothing will be partially shifted                           */
-  /* if -1 then nothing will be partially shifted                           */
+        int s1bytes;            /* number of bytes which flow to the first  new node when S[0] splits   */
-  int s1bytes;          /* number of bytes which flow to the first  new node when S[0] splits   */
+        /* note: if S[0] splits into 3 nodes, then items do not need to be cut  */
-                                /* note: if S[0] splits into 3 nodes, then items do not need to be cut  */
+        int s2bytes;
-  int s2bytes;
+        struct buffer_head *buf_to_free[MAX_FREE_BLOCK];        /* buffers which are to be freed after do_balance finishes by unfix_nodes */
-  struct buffer_head * buf_to_free[MAX_FREE_BLOCK]; /* buffers which are to be freed after do_balance finishes by unfix_nodes */
+        char *vn_buf;           /* kmalloced memory. Used to create
-  char * vn_buf;                /* kmalloced memory. Used to create
                                   virtual node and keep map of
                                   dirtied bitmap blocks */
-  int vn_buf_size;              /* size of the vn_buf */
+        int vn_buf_size;        /* size of the vn_buf */
-  struct virtual_node * tb_vn;  /* VN starts after bitmap of bitmap blocks */
+        struct virtual_node *tb_vn;     /* VN starts after bitmap of bitmap blocks */
-  int fs_gen;                  /* saved value of `reiserfs_generation' counter
+        int fs_gen;             /* saved value of `reiserfs_generation' counter
-                                  see FILESYSTEM_CHANGED() macro in reiserfs_fs.h */
+                                   see FILESYSTEM_CHANGED() macro in reiserfs_fs.h */
 #ifdef DISPLACE_NEW_PACKING_LOCALITIES
-  struct in_core_key  key;            /* key pointer, to pass to block allocator or
+        struct in_core_key key; /* key pointer, to pass to block allocator or
-                                 another low-level subsystem */
+                                   another low-level subsystem */
 #endif
-} ;
+};
 /* These are modes of balancing */
@@ -1479,13 +1430,12 @@ struct tree_balance
 /* used in do_balance for passing parent of node information that has
   been gotten from tb struct */
 struct buffer_info {
-    struct tree_balance * tb;
+        struct tree_balance *tb;
-    struct buffer_head * bi_bh;
+        struct buffer_head *bi_bh;
-    struct buffer_head * bi_parent;
+        struct buffer_head *bi_parent;
-    int bi_position;
+        int bi_position;
 };
 /* there are 4 types of items: stat data, directory item, indirect, direct.
 +-------------------+------------+--------------+------------+
 |                   |  k_offset  | k_uniqueness | mergeable? |
@@ -1503,24 +1453,24 @@ struct buffer_info {
 */
 struct item_operations {
-    int (*bytes_number) (struct item_head * ih, int block_size);
+        int (*bytes_number) (struct item_head * ih, int block_size);
-    void (*decrement_key) (struct cpu_key *);
+        void (*decrement_key) (struct cpu_key *);
-    int (*is_left_mergeable) (struct reiserfs_key * ih, unsigned long bsize);
+        int (*is_left_mergeable) (struct reiserfs_key * ih,
-    void (*print_item) (struct item_head *, char * item);
+                                  unsigned long bsize);
-    void (*check_item) (struct item_head *, char * item);
+        void (*print_item) (struct item_head *, char *item);
+        void (*check_item) (struct item_head *, char *item);
-    int (*create_vi) (struct virtual_node * vn, struct virtual_item * vi, 
-                      int is_affected, int insert_size);
+        int (*create_vi) (struct virtual_node * vn, struct virtual_item * vi,
-    int (*check_left) (struct virtual_item * vi, int free, 
+                          int is_affected, int insert_size);
-                            int start_skip, int end_skip);
+        int (*check_left) (struct virtual_item * vi, int free,
-    int (*check_right) (struct virtual_item * vi, int free);
+                           int start_skip, int end_skip);
-    int (*part_size) (struct virtual_item * vi, int from, int to);
+        int (*check_right) (struct virtual_item * vi, int free);
-    int (*unit_num) (struct virtual_item * vi);
+        int (*part_size) (struct virtual_item * vi, int from, int to);
-    void (*print_vi) (struct virtual_item * vi);
+        int (*unit_num) (struct virtual_item * vi);
+        void (*print_vi) (struct virtual_item * vi);
 };
+extern struct item_operations *item_ops[TYPE_ANY + 1];
-extern struct item_operations * item_ops [TYPE_ANY + 1];
 #define op_bytes_number(ih,bsize)                    item_ops[le_ih_k_type (ih)]->bytes_number (ih, bsize)
 #define op_is_left_mergeable(key,bsize)              item_ops[le_key_k_type (le_key_version (key), key)]->is_left_mergeable (key, bsize)
@@ -1533,8 +1483,6 @@ extern struct item_operations * item_ops [TYPE_ANY + 1];
 #define op_unit_num(vi)                              item_ops[(vi)->vi_index]->unit_num (vi)
 #define op_print_vi(vi)                              item_ops[(vi)->vi_index]->print_vi (vi)
 #define COMP_SHORT_KEYS comp_short_keys
 /* number of blocks pointed to by the indirect item */
@@ -1545,8 +1493,7 @@ extern struct item_operations * item_ops [TYPE_ANY + 1];
 /* number of bytes contained by the direct item or the unformatted nodes the indirect item points to */
+/* get the item header */
-/* get the item header */ 
 #define B_N_PITEM_HEAD(bh,item_num) ( (struct item_head * )((bh)->b_data + BLKH_SIZE) + (item_num) )
 /* get key */
@@ -1577,9 +1524,9 @@ extern struct item_operations * item_ops [TYPE_ANY + 1];
 #define PUT_B_I_POS_UNFM_POINTER(bh,ih,pos, val) do {*(((unp_t *)B_I_PITEM(bh,ih)) + (pos)) = cpu_to_le32(val); } while (0)
 struct reiserfs_iget_args {
-    __u32 objectid ;
+        __u32 objectid;
-    __u32 dirid ;
+        __u32 dirid;
-} ;
+};
 /***************************************************************************/
 /*                    FUNCTION DECLARATIONS                                */
@@ -1595,11 +1542,11 @@ struct reiserfs_iget_args {
 /* first block written in a commit.  */
 struct reiserfs_journal_desc {
-  __le32 j_trans_id ;                   /* id of commit */
+        __le32 j_trans_id;      /* id of commit */
-  __le32 j_len ;                        /* length of commit. len +1 is the commit block */
+        __le32 j_len;           /* length of commit. len +1 is the commit block */
-  __le32 j_mount_id ;                           /* mount id of this trans*/
+        __le32 j_mount_id;      /* mount id of this trans */
-  __le32 j_realblock[1] ; /* real locations for each block */
+        __le32 j_realblock[1];  /* real locations for each block */
-} ;
+};
 #define get_desc_trans_id(d)   le32_to_cpu((d)->j_trans_id)
 #define get_desc_trans_len(d)  le32_to_cpu((d)->j_len)
@@ -1611,10 +1558,10 @@ struct reiserfs_journal_desc {
 /* last block written in a commit */
 struct reiserfs_journal_commit {
-  __le32 j_trans_id ;                   /* must match j_trans_id from the desc block */
+        __le32 j_trans_id;      /* must match j_trans_id from the desc block */
-  __le32 j_len ;                        /* ditto */
+        __le32 j_len;           /* ditto */
-  __le32 j_realblock[1] ; /* real locations for each block */
+        __le32 j_realblock[1];  /* real locations for each block */
-} ;
+};
 #define get_commit_trans_id(c) le32_to_cpu((c)->j_trans_id)
 #define get_commit_trans_len(c)        le32_to_cpu((c)->j_len)
@@ -1628,27 +1575,34 @@ struct reiserfs_journal_commit {
 ** and this transaction does not need to be replayed.
 */
 struct reiserfs_journal_header {
-  __le32 j_last_flush_trans_id ;                /* id of last fully flushed transaction */
+        __le32 j_last_flush_trans_id;   /* id of last fully flushed transaction */
-  __le32 j_first_unflushed_offset ;      /* offset in the log of where to start replay after a crash */
+        __le32 j_first_unflushed_offset;        /* offset in the log of where to start replay after a crash */
-  __le32 j_mount_id ;
+        __le32 j_mount_id;
-  /* 12 */ struct journal_params jh_journal;
+        /* 12 */ struct journal_params jh_journal;
-} ;
+};
 /* biggest tunable defines are right here */
-#define JOURNAL_BLOCK_COUNT 8192 /* number of blocks in the journal */
+#define JOURNAL_BLOCK_COUNT 8192        /* number of blocks in the journal */
-#define JOURNAL_TRANS_MAX_DEFAULT 1024   /* biggest possible single transaction, don't change for now (8/3/99) */
+#define JOURNAL_TRANS_MAX_DEFAULT 1024  /* biggest possible single transaction, don't change for now (8/3/99) */
 #define JOURNAL_TRANS_MIN_DEFAULT 256
-#define JOURNAL_MAX_BATCH_DEFAULT   900 /* max blocks to batch into one transaction, don't make this any bigger than 900 */
+#define JOURNAL_MAX_BATCH_DEFAULT   900 /* max blocks to batch into one transaction, don't make this any bigger than 900 */
 #define JOURNAL_MIN_RATIO 2
-#define JOURNAL_MAX_COMMIT_AGE 30 
+#define JOURNAL_MAX_COMMIT_AGE 30
 #define JOURNAL_MAX_TRANS_AGE 30
 #define JOURNAL_PER_BALANCE_CNT (3 * (MAX_HEIGHT-2) + 9)
 #ifdef CONFIG_QUOTA
-#define REISERFS_QUOTA_TRANS_BLOCKS 2   /* We need to update data and inode (atime) */
+/* We need to update data and inode (atime) */
-#define REISERFS_QUOTA_INIT_BLOCKS (DQUOT_MAX_WRITES*(JOURNAL_PER_BALANCE_CNT+2)+1)     /* 1 balancing, 1 bitmap, 1 data per write + stat data update */
+#define REISERFS_QUOTA_TRANS_BLOCKS(s) (REISERFS_SB(s)->s_mount_opt & (1<<REISERFS_QUOTA) ? 2 : 0)
+/* 1 balancing, 1 bitmap, 1 data per write + stat data update */
+#define REISERFS_QUOTA_INIT_BLOCKS(s) (REISERFS_SB(s)->s_mount_opt & (1<<REISERFS_QUOTA) ? \
+(DQUOT_INIT_ALLOC*(JOURNAL_PER_BALANCE_CNT+2)+DQUOT_INIT_REWRITE+1) : 0)
+/* same as with INIT */
+#define REISERFS_QUOTA_DEL_BLOCKS(s) (REISERFS_SB(s)->s_mount_opt & (1<<REISERFS_QUOTA) ? \
+(DQUOT_DEL_ALLOC*(JOURNAL_PER_BALANCE_CNT+2)+DQUOT_DEL_REWRITE+1) : 0)
 #else
-#define REISERFS_QUOTA_TRANS_BLOCKS 0
+#define REISERFS_QUOTA_TRANS_BLOCKS(s) 0
-#define REISERFS_QUOTA_INIT_BLOCKS 0
+#define REISERFS_QUOTA_INIT_BLOCKS(s) 0
+#define REISERFS_QUOTA_DEL_BLOCKS(s) 0
 #endif
 /* both of these can be as low as 1, or as high as you want.  The min is the
@@ -1657,10 +1611,10 @@ struct reiserfs_journal_header {
 ** the current number of nodes is > max, the node is freed, otherwise, 
 ** it is put on a free list for faster use later.
 */
-#define REISERFS_MIN_BITMAP_NODES 10 
+#define REISERFS_MIN_BITMAP_NODES 10
-#define REISERFS_MAX_BITMAP_NODES 100 
+#define REISERFS_MAX_BITMAP_NODES 100
-#define JBH_HASH_SHIFT 13 /* these are based on journal hash size of 8192 */
+#define JBH_HASH_SHIFT 13       /* these are based on journal hash size of 8192 */
 #define JBH_HASH_MASK 8191
 #define _jhashfn(sb,block)      \
@@ -1674,14 +1628,14 @@ struct reiserfs_journal_header {
 #define journal_bread(s, block) __bread(SB_JOURNAL(s)->j_dev_bd, block, s->s_blocksize)
 enum reiserfs_bh_state_bits {
-    BH_JDirty = BH_PrivateStart, /* buffer is in current transaction */
+        BH_JDirty = BH_PrivateStart,    /* buffer is in current transaction */
-    BH_JDirty_wait,
+        BH_JDirty_wait,
-    BH_JNew,                     /* disk block was taken off free list before
+        BH_JNew,                /* disk block was taken off free list before
-                                  * being in a finished transaction, or
+                                 * being in a finished transaction, or
-                                  * written to disk. Can be reused immed. */
+                                 * written to disk. Can be reused immed. */
-    BH_JPrepared,
+        BH_JPrepared,
-    BH_JRestore_dirty,
+        BH_JRestore_dirty,
-    BH_JTest, // debugging only will go away
+        BH_JTest,               // debugging only will go away
 };
 BUFFER_FNS(JDirty, journaled);
@@ -1701,175 +1655,192 @@ TAS_BUFFER_FNS(JTest, journal_test);
 ** transaction handle which is passed around for all journal calls
 */
 struct reiserfs_transaction_handle {
-  struct super_block *t_super ; /* super for this FS when journal_begin was
+        struct super_block *t_super;    /* super for this FS when journal_begin was
-                                   called. saves calls to reiserfs_get_super
+                                           called. saves calls to reiserfs_get_super
-                                   also used by nested transactions to make
+                                           also used by nested transactions to make
-                                   sure they are nesting on the right FS
+                                           sure they are nesting on the right FS
-                                   _must_ be first in the handle
+                                           _must_ be first in the handle
-                                */
+                                         */
-  int t_refcount;
+        int t_refcount;
-  int t_blocks_logged ;         /* number of blocks this writer has logged */
+        int t_blocks_logged;    /* number of blocks this writer has logged */
-  int t_blocks_allocated ;      /* number of blocks this writer allocated */
+        int t_blocks_allocated; /* number of blocks this writer allocated */
-  unsigned long t_trans_id ;    /* sanity check, equals the current trans id */
+        unsigned long t_trans_id;       /* sanity check, equals the current trans id */
-  void *t_handle_save ;         /* save existing current->journal_info */
+        void *t_handle_save;    /* save existing current->journal_info */
-  unsigned displace_new_blocks:1; /* if new block allocation occurres, that block
+        unsigned displace_new_blocks:1; /* if new block allocation occurres, that block
-                                   should be displaced from others */
+                                           should be displaced from others */
-  struct list_head t_list;
+        struct list_head t_list;
-} ;
+};
 /* used to keep track of ordered and tail writes, attached to the buffer
 * head through b_journal_head.
 */
 struct reiserfs_jh {
-    struct reiserfs_journal_list *jl;
+        struct reiserfs_journal_list *jl;
-    struct buffer_head *bh;
+        struct buffer_head *bh;
-    struct list_head list;
+        struct list_head list;
 };
 void reiserfs_free_jh(struct buffer_head *bh);
 int reiserfs_add_tail_list(struct inode *inode, struct buffer_head *bh);
 int reiserfs_add_ordered_list(struct inode *inode, struct buffer_head *bh);
-int journal_mark_dirty(struct reiserfs_transaction_handle *, struct super_block *, struct buffer_head *bh) ;
+int journal_mark_dirty(struct reiserfs_transaction_handle *,
+                       struct super_block *, struct buffer_head *bh);
-static inline int
-reiserfs_file_data_log(struct inode *inode) {
+static inline int reiserfs_file_data_log(struct inode *inode)
-    if (reiserfs_data_log(inode->i_sb) ||
+{
-       (REISERFS_I(inode)->i_flags & i_data_log))
+        if (reiserfs_data_log(inode->i_sb) ||
-        return 1 ;
+            (REISERFS_I(inode)->i_flags & i_data_log))
-    return 0 ;
+                return 1;
+        return 0;
 }
-static inline int reiserfs_transaction_running(struct super_block *s) {
+static inline int reiserfs_transaction_running(struct super_block *s)
-    struct reiserfs_transaction_handle *th = current->journal_info ;
+{
-    if (th && th->t_super == s)
+        struct reiserfs_transaction_handle *th = current->journal_info;
-        return 1 ;
+        if (th && th->t_super == s)
-    if (th && th->t_super == NULL)
+                return 1;
-        BUG();
+        if (th && th->t_super == NULL)
-    return 0 ;
+                BUG();
+        return 0;
 }
 int reiserfs_async_progress_wait(struct super_block *s);
-struct reiserfs_transaction_handle *
+struct reiserfs_transaction_handle *reiserfs_persistent_transaction(struct
-reiserfs_persistent_transaction(struct super_block *, int count);
+                                                                    super_block
+                                                                    *,
+                                                                    int count);
 int reiserfs_end_persistent_transaction(struct reiserfs_transaction_handle *);
 int reiserfs_commit_page(struct inode *inode, struct page *page,
-                unsigned from, unsigned to);
+                         unsigned from, unsigned to);
 int reiserfs_flush_old_commits(struct super_block *);
-int reiserfs_commit_for_inode(struct inode *) ;
+int reiserfs_commit_for_inode(struct inode *);
-int  reiserfs_inode_needs_commit(struct inode *) ;
+int reiserfs_inode_needs_commit(struct inode *);
-void reiserfs_update_inode_transaction(struct inode *) ;
+void reiserfs_update_inode_transaction(struct inode *);
-void reiserfs_wait_on_write_block(struct super_block *s) ;
+void reiserfs_wait_on_write_block(struct super_block *s);
-void reiserfs_block_writes(struct reiserfs_transaction_handle *th) ;
+void reiserfs_block_writes(struct reiserfs_transaction_handle *th);
-void reiserfs_allow_writes(struct super_block *s) ;
+void reiserfs_allow_writes(struct super_block *s);
-void reiserfs_check_lock_depth(struct super_block *s, char *caller) ;
+void reiserfs_check_lock_depth(struct super_block *s, char *caller);
-int reiserfs_prepare_for_journal(struct super_block *, struct buffer_head *bh, int wait) ;
+int reiserfs_prepare_for_journal(struct super_block *, struct buffer_head *bh,
-void reiserfs_restore_prepared_buffer(struct super_block *, struct buffer_head *bh) ;
+                                 int wait);
-int journal_init(struct super_block *, const char * j_dev_name, int old_format, unsigned int) ;
+void reiserfs_restore_prepared_buffer(struct super_block *,
-int journal_release(struct reiserfs_transaction_handle*, struct super_block *) ;
+                                      struct buffer_head *bh);
-int journal_release_error(struct reiserfs_transaction_handle*, struct super_block *) ;
+int journal_init(struct super_block *, const char *j_dev_name, int old_format,
-int journal_end(struct reiserfs_transaction_handle *, struct super_block *, unsigned long) ;
+                 unsigned int);
-int journal_end_sync(struct reiserfs_transaction_handle *, struct super_block *, unsigned long) ;
+int journal_release(struct reiserfs_transaction_handle *, struct super_block *);
-int journal_mark_freed(struct reiserfs_transaction_handle *, struct super_block *, b_blocknr_t blocknr) ;
+int journal_release_error(struct reiserfs_transaction_handle *,
-int journal_transaction_should_end(struct reiserfs_transaction_handle *, int) ;
+                          struct super_block *);
-int reiserfs_in_journal(struct super_block *p_s_sb, int bmap_nr, int bit_nr, int searchall, b_blocknr_t *next) ;
+int journal_end(struct reiserfs_transaction_handle *, struct super_block *,
-int journal_begin(struct reiserfs_transaction_handle *, struct super_block *p_s_sb, unsigned long) ;
+                unsigned long);
-int journal_join_abort(struct reiserfs_transaction_handle *, struct super_block *p_s_sb, unsigned long) ;
+int journal_end_sync(struct reiserfs_transaction_handle *, struct super_block *,
-void reiserfs_journal_abort (struct super_block *sb, int errno);
+                     unsigned long);
-void reiserfs_abort (struct super_block *sb, int errno, const char *fmt, ...);
+int journal_mark_freed(struct reiserfs_transaction_handle *,
-int reiserfs_allocate_list_bitmaps(struct super_block *s, struct reiserfs_list_bitmap *, int) ;
+                       struct super_block *, b_blocknr_t blocknr);
+int journal_transaction_should_end(struct reiserfs_transaction_handle *, int);
-void add_save_link (struct reiserfs_transaction_handle * th,
+int reiserfs_in_journal(struct super_block *p_s_sb, int bmap_nr, int bit_nr,
-                                        struct inode * inode, int truncate);
+                        int searchall, b_blocknr_t * next);
-int remove_save_link (struct inode * inode, int truncate);
+int journal_begin(struct reiserfs_transaction_handle *,
+                  struct super_block *p_s_sb, unsigned long);
+int journal_join_abort(struct reiserfs_transaction_handle *,
+                       struct super_block *p_s_sb, unsigned long);
+void reiserfs_journal_abort(struct super_block *sb, int errno);
+void reiserfs_abort(struct super_block *sb, int errno, const char *fmt, ...);
+int reiserfs_allocate_list_bitmaps(struct super_block *s,
+                                   struct reiserfs_list_bitmap *, int);
+void add_save_link(struct reiserfs_transaction_handle *th,
+                   struct inode *inode, int truncate);
+int remove_save_link(struct inode *inode, int truncate);
 /* objectid.c */
-__u32 reiserfs_get_unused_objectid (struct reiserfs_transaction_handle *th);
+__u32 reiserfs_get_unused_objectid(struct reiserfs_transaction_handle *th);
-void reiserfs_release_objectid (struct reiserfs_transaction_handle *th, __u32 objectid_to_release);
+void reiserfs_release_objectid(struct reiserfs_transaction_handle *th,
-int reiserfs_convert_objectid_map_v1(struct super_block *) ;
+                               __u32 objectid_to_release);
+int reiserfs_convert_objectid_map_v1(struct super_block *);
 /* stree.c */
 int B_IS_IN_TREE(const struct buffer_head *);
-extern void copy_item_head(struct item_head * p_v_to,
+extern void copy_item_head(struct item_head *p_v_to,
-                                                                  const struct item_head * p_v_from);
+                           const struct item_head *p_v_from);
 // first key is in cpu form, second - le
-extern int  comp_short_keys (const struct reiserfs_key * le_key,
+extern int comp_short_keys(const struct reiserfs_key *le_key,
-                                    const struct cpu_key * cpu_key);
+                           const struct cpu_key *cpu_key);
-extern void le_key2cpu_key (struct cpu_key * to, const struct reiserfs_key * from);
+extern void le_key2cpu_key(struct cpu_key *to, const struct reiserfs_key *from);
 // both are in le form
-extern int comp_le_keys (const struct reiserfs_key *, const struct reiserfs_key *);
+extern int comp_le_keys(const struct reiserfs_key *,
-extern int comp_short_le_keys (const struct reiserfs_key *, const struct reiserfs_key *);
+                        const struct reiserfs_key *);
+extern int comp_short_le_keys(const struct reiserfs_key *,
+                              const struct reiserfs_key *);
 //
 // get key version from on disk key - kludge
 //
-static inline int le_key_version (const struct reiserfs_key * key)
+static inline int le_key_version(const struct reiserfs_key *key)
 {
-    int type;
+        int type;
-    
-    type = offset_v2_k_type( &(key->u.k_offset_v2));
-    if (type != TYPE_DIRECT && type != TYPE_INDIRECT && type != TYPE_DIRENTRY)
-        return KEY_FORMAT_3_5;
-    return KEY_FORMAT_3_6;
-        
-}
+        type = offset_v2_k_type(&(key->u.k_offset_v2));
+        if (type != TYPE_DIRECT && type != TYPE_INDIRECT
+            && type != TYPE_DIRENTRY)
+                return KEY_FORMAT_3_5;
+        return KEY_FORMAT_3_6;
-static inline void copy_key (struct reiserfs_key *to, const struct reiserfs_key *from)
-{
-    memcpy (to, from, KEY_SIZE);
 }
+static inline void copy_key(struct reiserfs_key *to,
+                            const struct reiserfs_key *from)
+{
+        memcpy(to, from, KEY_SIZE);
+}
-int comp_items (const struct item_head * stored_ih, const struct path * p_s_path);
+int comp_items(const struct item_head *stored_ih, const struct path *p_s_path);
-const struct reiserfs_key * get_rkey (const struct path * p_s_chk_path,
+const struct reiserfs_key *get_rkey(const struct path *p_s_chk_path,
-                                                         const struct super_block  * p_s_sb);
+                                    const struct super_block *p_s_sb);
-int search_by_key (struct super_block *, const struct cpu_key *, 
+int search_by_key(struct super_block *, const struct cpu_key *,
-                                   struct path *, int);
+                  struct path *, int);
 #define search_item(s,key,path) search_by_key (s, key, path, DISK_LEAF_NODE_LEVEL)
-int search_for_position_by_key (struct super_block * p_s_sb, 
+int search_for_position_by_key(struct super_block *p_s_sb,
-                                                                const struct cpu_key * p_s_cpu_key, 
+                               const struct cpu_key *p_s_cpu_key,
-                                                                struct path * p_s_search_path);
+                               struct path *p_s_search_path);
-extern void decrement_bcount (struct buffer_head * p_s_bh);
+extern void decrement_bcount(struct buffer_head *p_s_bh);
-void decrement_counters_in_path (struct path * p_s_search_path);
+void decrement_counters_in_path(struct path *p_s_search_path);
-void pathrelse (struct path * p_s_search_path);
+void pathrelse(struct path *p_s_search_path);
-int reiserfs_check_path(struct path *p) ;
+int reiserfs_check_path(struct path *p);
-void pathrelse_and_restore (struct super_block *s, struct path * p_s_search_path);
+void pathrelse_and_restore(struct super_block *s, struct path *p_s_search_path);
-int reiserfs_insert_item (struct reiserfs_transaction_handle *th, 
+int reiserfs_insert_item(struct reiserfs_transaction_handle *th,
-                          struct path * path, 
+                         struct path *path,
-                          const struct cpu_key * key,
+                         const struct cpu_key *key,
-                          struct item_head * ih,
+                         struct item_head *ih,
-                          struct inode *inode, const char * body);
+                         struct inode *inode, const char *body);
-int reiserfs_paste_into_item (struct reiserfs_transaction_handle *th,
+int reiserfs_paste_into_item(struct reiserfs_transaction_handle *th,
-                              struct path * path,
+                             struct path *path,
-                              const struct cpu_key * key,
+                             const struct cpu_key *key,
-                              struct inode *inode,
+                             struct inode *inode,
-                              const char * body, int paste_size);
+                             const char *body, int paste_size);
-int reiserfs_cut_from_item (struct reiserfs_transaction_handle *th,
+int reiserfs_cut_from_item(struct reiserfs_transaction_handle *th,
-                            struct path * path,
+                           struct path *path,
-                            struct cpu_key * key,
+                           struct cpu_key *key,
-                            struct inode * inode,
+                           struct inode *inode,
-                            struct page *page,
+                           struct page *page, loff_t new_file_size);
-                            loff_t new_file_size);
+int reiserfs_delete_item(struct reiserfs_transaction_handle *th,
-int reiserfs_delete_item (struct reiserfs_transaction_handle *th,
+                         struct path *path,
-                          struct path * path, 
+                         const struct cpu_key *key,
-                          const struct cpu_key * key,
+                         struct inode *inode, struct buffer_head *p_s_un_bh);
-                          struct inode * inode, 
-                          struct buffer_head  * p_s_un_bh);
+void reiserfs_delete_solid_item(struct reiserfs_transaction_handle *th,
+                                struct inode *inode, struct reiserfs_key *key);
-void reiserfs_delete_solid_item (struct reiserfs_transaction_handle *th,
+int reiserfs_delete_object(struct reiserfs_transaction_handle *th,
-                        struct inode *inode, struct reiserfs_key * key);
+                           struct inode *p_s_inode);
-int reiserfs_delete_object (struct reiserfs_transaction_handle *th, struct inode * p_s_inode);
+int reiserfs_do_truncate(struct reiserfs_transaction_handle *th,
-int reiserfs_do_truncate (struct reiserfs_transaction_handle *th,
+                         struct inode *p_s_inode, struct page *,
-                           struct  inode * p_s_inode, struct page *, 
+                         int update_timestamps);
-                           int update_timestamps);
 #define i_block_size(inode) ((inode)->i_sb->s_blocksize)
 #define file_size(inode) ((inode)->i_size)
@@ -1878,66 +1849,67 @@ int reiserfs_do_truncate (struct reiserfs_transaction_handle *th,
 #define tail_has_to_be_packed(inode) (have_large_tails ((inode)->i_sb)?\
 !STORE_TAIL_IN_UNFM_S1(file_size (inode), tail_size(inode), inode->i_sb->s_blocksize):have_small_tails ((inode)->i_sb)?!STORE_TAIL_IN_UNFM_S2(file_size (inode), tail_size(inode), inode->i_sb->s_blocksize):0 )
-void padd_item (char * item, int total_length, int length);
+void padd_item(char *item, int total_length, int length);
 /* inode.c */
 /* args for the create parameter of reiserfs_get_block */
-#define GET_BLOCK_NO_CREATE 0 /* don't create new blocks or convert tails */
+#define GET_BLOCK_NO_CREATE 0   /* don't create new blocks or convert tails */
-#define GET_BLOCK_CREATE 1    /* add anything you need to find block */
+#define GET_BLOCK_CREATE 1      /* add anything you need to find block */
-#define GET_BLOCK_NO_HOLE 2   /* return -ENOENT for file holes */
+#define GET_BLOCK_NO_HOLE 2     /* return -ENOENT for file holes */
-#define GET_BLOCK_READ_DIRECT 4  /* read the tail if indirect item not found */
+#define GET_BLOCK_READ_DIRECT 4 /* read the tail if indirect item not found */
-#define GET_BLOCK_NO_ISEM     8 /* i_sem is not held, don't preallocate */
+#define GET_BLOCK_NO_ISEM     8 /* i_sem is not held, don't preallocate */
-#define GET_BLOCK_NO_DANGLE   16 /* don't leave any transactions running */
+#define GET_BLOCK_NO_DANGLE   16        /* don't leave any transactions running */
-int restart_transaction(struct reiserfs_transaction_handle *th, struct inode *inode, struct path *path);
+int restart_transaction(struct reiserfs_transaction_handle *th,
-void reiserfs_read_locked_inode(struct inode * inode, struct reiserfs_iget_args *args) ;
+                        struct inode *inode, struct path *path);
-int reiserfs_find_actor(struct inode * inode, void *p) ;
+void reiserfs_read_locked_inode(struct inode *inode,
-int reiserfs_init_locked_inode(struct inode * inode, void *p) ;
+                                struct reiserfs_iget_args *args);
-void reiserfs_delete_inode (struct inode * inode);
+int reiserfs_find_actor(struct inode *inode, void *p);
-int reiserfs_write_inode (struct inode * inode, int) ;
+int reiserfs_init_locked_inode(struct inode *inode, void *p);
-int reiserfs_get_block (struct inode * inode, sector_t block, struct buffer_head * bh_result, int create);
+void reiserfs_delete_inode(struct inode *inode);
-struct dentry *reiserfs_get_dentry(struct super_block *, void *) ;
+int reiserfs_write_inode(struct inode *inode, int);
-struct dentry *reiserfs_decode_fh(struct super_block *sb, __u32 *data,
+int reiserfs_get_block(struct inode *inode, sector_t block,
-                                     int len, int fhtype,
+                       struct buffer_head *bh_result, int create);
-                                  int (*acceptable)(void *contect, struct dentry *de),
+struct dentry *reiserfs_get_dentry(struct super_block *, void *);
-                                  void *context) ;
+struct dentry *reiserfs_decode_fh(struct super_block *sb, __u32 * data,
-int reiserfs_encode_fh( struct dentry *dentry, __u32 *data, int *lenp, 
+                                  int len, int fhtype,
-                                                int connectable );
+                                  int (*acceptable) (void *contect,
+                                                     struct dentry * de),
-int reiserfs_truncate_file(struct inode *, int update_timestamps) ;
+                                  void *context);
-void make_cpu_key (struct cpu_key * cpu_key, struct inode * inode, loff_t offset,
+int reiserfs_encode_fh(struct dentry *dentry, __u32 * data, int *lenp,
-                   int type, int key_length);
+                       int connectable);
-void make_le_item_head (struct item_head * ih, const struct cpu_key * key, 
-                        int version,
+int reiserfs_truncate_file(struct inode *, int update_timestamps);
-                        loff_t offset, int type, int length, int entry_count);
+void make_cpu_key(struct cpu_key *cpu_key, struct inode *inode, loff_t offset,
-struct inode * reiserfs_iget (struct super_block * s, 
+                  int type, int key_length);
-                              const struct cpu_key * key);
+void make_le_item_head(struct item_head *ih, const struct cpu_key *key,
+                       int version,
+                       loff_t offset, int type, int length, int entry_count);
-int reiserfs_new_inode (struct reiserfs_transaction_handle *th, 
+struct inode *reiserfs_iget(struct super_block *s, const struct cpu_key *key);
-                                   struct inode * dir, int mode, 
-                                   const char * symname, loff_t i_size,
+int reiserfs_new_inode(struct reiserfs_transaction_handle *th,
-                                   struct dentry *dentry, struct inode *inode);
+                       struct inode *dir, int mode,
+                       const char *symname, loff_t i_size,
-void reiserfs_update_sd_size (struct reiserfs_transaction_handle *th,
+                       struct dentry *dentry, struct inode *inode);
-                              struct inode * inode, loff_t size);
+void reiserfs_update_sd_size(struct reiserfs_transaction_handle *th,
+                             struct inode *inode, loff_t size);
 static inline void reiserfs_update_sd(struct reiserfs_transaction_handle *th,
-                                      struct inode *inode)
+                                      struct inode *inode)
 {
-    reiserfs_update_sd_size(th, inode, inode->i_size) ;
+        reiserfs_update_sd_size(th, inode, inode->i_size);
 }
-void sd_attrs_to_i_attrs( __u16 sd_attrs, struct inode *inode );
+void sd_attrs_to_i_attrs(__u16 sd_attrs, struct inode *inode);
-void i_attrs_to_sd_attrs( struct inode *inode, __u16 *sd_attrs );
+void i_attrs_to_sd_attrs(struct inode *inode, __u16 * sd_attrs);
 int reiserfs_setattr(struct dentry *dentry, struct iattr *attr);
 /* namei.c */
-void set_de_name_and_namelen (struct reiserfs_dir_entry * de);
+void set_de_name_and_namelen(struct reiserfs_dir_entry *de);
-int search_by_entry_key (struct super_block * sb, const struct cpu_key * key, 
+int search_by_entry_key(struct super_block *sb, const struct cpu_key *key,
-                         struct path * path, 
+                        struct path *path, struct reiserfs_dir_entry *de);
-                         struct reiserfs_dir_entry * de);
+struct dentry *reiserfs_get_parent(struct dentry *);
-struct dentry *reiserfs_get_parent(struct dentry *) ;
 /* procfs.c */
 #if defined( CONFIG_PROC_FS ) && defined( CONFIG_REISERFS_PROC_INFO )
@@ -1946,15 +1918,15 @@ struct dentry *reiserfs_get_parent(struct dentry *) ;
 #undef REISERFS_PROC_INFO
 #endif
-int reiserfs_proc_info_init( struct super_block *sb );
+int reiserfs_proc_info_init(struct super_block *sb);
-int reiserfs_proc_info_done( struct super_block *sb );
+int reiserfs_proc_info_done(struct super_block *sb);
-struct proc_dir_entry *reiserfs_proc_register_global( char *name, 
+struct proc_dir_entry *reiserfs_proc_register_global(char *name,
-                                                                                                          read_proc_t *func );
+                                                     read_proc_t * func);
-void reiserfs_proc_unregister_global( const char *name );
+void reiserfs_proc_unregister_global(const char *name);
-int reiserfs_proc_info_global_init( void );
+int reiserfs_proc_info_global_init(void);
-int reiserfs_proc_info_global_done( void );
+int reiserfs_proc_info_global_done(void);
-int reiserfs_global_version_in_proc( char *buffer, char **start, off_t offset,
+int reiserfs_global_version_in_proc(char *buffer, char **start, off_t offset,
-                                                                         int count, int *eof, void *data );
+                                    int count, int *eof, void *data);
 #if defined( REISERFS_PROC_INFO )
@@ -1986,123 +1958,132 @@ extern struct inode_operations reiserfs_special_inode_operations;
 extern struct file_operations reiserfs_dir_operations;
 /* tail_conversion.c */
-int direct2indirect (struct reiserfs_transaction_handle *, struct inode *, struct path *, struct buffer_head *, loff_t);
+int direct2indirect(struct reiserfs_transaction_handle *, struct inode *,
-int indirect2direct (struct reiserfs_transaction_handle *, struct inode *, struct page *, struct path *, const struct cpu_key *, loff_t, char *);
+                    struct path *, struct buffer_head *, loff_t);
-void reiserfs_unmap_buffer(struct buffer_head *) ;
+int indirect2direct(struct reiserfs_transaction_handle *, struct inode *,
+                    struct page *, struct path *, const struct cpu_key *,
+                    loff_t, char *);
+void reiserfs_unmap_buffer(struct buffer_head *);
 /* file.c */
 extern struct inode_operations reiserfs_file_inode_operations;
 extern struct file_operations reiserfs_file_operations;
-extern struct address_space_operations reiserfs_address_space_operations ;
+extern struct address_space_operations reiserfs_address_space_operations;
 /* fix_nodes.c */
 #ifdef CONFIG_REISERFS_CHECK
-void * reiserfs_kmalloc (size_t size, int flags, struct super_block * s);
+void *reiserfs_kmalloc(size_t size, int flags, struct super_block *s);
-void reiserfs_kfree (const void * vp, size_t size, struct super_block * s);
+void reiserfs_kfree(const void *vp, size_t size, struct super_block *s);
 #else
 static inline void *reiserfs_kmalloc(size_t size, int flags,
-                                        struct super_block *s)
+                                     struct super_block *s)
 {
        return kmalloc(size, flags);
 }
 static inline void reiserfs_kfree(const void *vp, size_t size,
-                                        struct super_block *s)
+                                  struct super_block *s)
 {
        kfree(vp);
 }
 #endif
-int fix_nodes (int n_op_mode, struct tree_balance * p_s_tb, 
+int fix_nodes(int n_op_mode, struct tree_balance *p_s_tb,
-               struct item_head * p_s_ins_ih, const void *);
+              struct item_head *p_s_ins_ih, const void *);
-void unfix_nodes (struct tree_balance *);
+void unfix_nodes(struct tree_balance *);
 /* prints.c */
-void reiserfs_panic (struct super_block * s, const char * fmt, ...) __attribute__ ( ( noreturn ) );
+void reiserfs_panic(struct super_block *s, const char *fmt, ...)
-void reiserfs_info (struct super_block *s, const char * fmt, ...);
+    __attribute__ ((noreturn));
-void reiserfs_debug (struct super_block *s, int level, const char * fmt, ...);
+void reiserfs_info(struct super_block *s, const char *fmt, ...);
-void print_indirect_item (struct buffer_head * bh, int item_num);
+void reiserfs_debug(struct super_block *s, int level, const char *fmt, ...);
-void store_print_tb (struct tree_balance * tb);
+void print_indirect_item(struct buffer_head *bh, int item_num);
-void print_cur_tb (char * mes);
+void store_print_tb(struct tree_balance *tb);
-void print_de (struct reiserfs_dir_entry * de);
+void print_cur_tb(char *mes);
-void print_bi (struct buffer_info * bi, char * mes);
+void print_de(struct reiserfs_dir_entry *de);
-#define PRINT_LEAF_ITEMS 1   /* print all items */
+void print_bi(struct buffer_info *bi, char *mes);
-#define PRINT_DIRECTORY_ITEMS 2 /* print directory items */
+#define PRINT_LEAF_ITEMS 1      /* print all items */
-#define PRINT_DIRECT_ITEMS 4 /* print contents of direct items */
+#define PRINT_DIRECTORY_ITEMS 2 /* print directory items */
-void print_block (struct buffer_head * bh, ...);
+#define PRINT_DIRECT_ITEMS 4    /* print contents of direct items */
-void print_bmap (struct super_block * s, int silent);
+void print_block(struct buffer_head *bh, ...);
-void print_bmap_block (int i, char * data, int size, int silent);
+void print_bmap(struct super_block *s, int silent);
+void print_bmap_block(int i, char *data, int size, int silent);
 /*void print_super_block (struct super_block * s, char * mes);*/
-void print_objectid_map (struct super_block * s);
+void print_objectid_map(struct super_block *s);
-void print_block_head (struct buffer_head * bh, char * mes);
+void print_block_head(struct buffer_head *bh, char *mes);
-void check_leaf (struct buffer_head * bh);
+void check_leaf(struct buffer_head *bh);
-void check_internal (struct buffer_head * bh);
+void check_internal(struct buffer_head *bh);
-void print_statistics (struct super_block * s);
+void print_statistics(struct super_block *s);
-char * reiserfs_hashname(int code);
+char *reiserfs_hashname(int code);
 /* lbalance.c */
-int leaf_move_items (int shift_mode, struct tree_balance * tb, int mov_num, int mov_bytes, struct buffer_head * Snew);
+int leaf_move_items(int shift_mode, struct tree_balance *tb, int mov_num,
-int leaf_shift_left (struct tree_balance * tb, int shift_num, int shift_bytes);
+                    int mov_bytes, struct buffer_head *Snew);
-int leaf_shift_right (struct tree_balance * tb, int shift_num, int shift_bytes);
+int leaf_shift_left(struct tree_balance *tb, int shift_num, int shift_bytes);
-void leaf_delete_items (struct buffer_info * cur_bi, int last_first, int first, int del_num, int del_bytes);
+int leaf_shift_right(struct tree_balance *tb, int shift_num, int shift_bytes);
-void leaf_insert_into_buf (struct buffer_info * bi, int before, 
+void leaf_delete_items(struct buffer_info *cur_bi, int last_first, int first,
-                           struct item_head * inserted_item_ih, const char * inserted_item_body, int zeros_number);
+                       int del_num, int del_bytes);
-void leaf_paste_in_buffer (struct buffer_info * bi, int pasted_item_num, 
+void leaf_insert_into_buf(struct buffer_info *bi, int before,
-                           int pos_in_item, int paste_size, const char * body, int zeros_number);
+                          struct item_head *inserted_item_ih,
-void leaf_cut_from_buffer (struct buffer_info * bi, int cut_item_num, int pos_in_item, 
+                          const char *inserted_item_body, int zeros_number);
-                           int cut_size);
+void leaf_paste_in_buffer(struct buffer_info *bi, int pasted_item_num,
-void leaf_paste_entries (struct buffer_head * bh, int item_num, int before, 
+                          int pos_in_item, int paste_size, const char *body,
-                         int new_entry_count, struct reiserfs_de_head * new_dehs, const char * records, int paste_size);
+                          int zeros_number);
+void leaf_cut_from_buffer(struct buffer_info *bi, int cut_item_num,
+                          int pos_in_item, int cut_size);
+void leaf_paste_entries(struct buffer_head *bh, int item_num, int before,
+                        int new_entry_count, struct reiserfs_de_head *new_dehs,
+                        const char *records, int paste_size);
 /* ibalance.c */
-int balance_internal (struct tree_balance * , int, int, struct item_head * , 
+int balance_internal(struct tree_balance *, int, int, struct item_head *,
-                      struct buffer_head **);
+                     struct buffer_head **);
 /* do_balance.c */
-void do_balance_mark_leaf_dirty (struct tree_balance * tb,
+void do_balance_mark_leaf_dirty(struct tree_balance *tb,
-                                        struct buffer_head * bh, int flag);
+                                struct buffer_head *bh, int flag);
 #define do_balance_mark_internal_dirty do_balance_mark_leaf_dirty
 #define do_balance_mark_sb_dirty do_balance_mark_leaf_dirty
-void do_balance (struct tree_balance * tb, struct item_head * ih, 
+void do_balance(struct tree_balance *tb, struct item_head *ih,
-                 const char * body, int flag);
+                const char *body, int flag);
-void reiserfs_invalidate_buffer (struct tree_balance * tb, struct buffer_head * bh);
+void reiserfs_invalidate_buffer(struct tree_balance *tb,
+                                struct buffer_head *bh);
-int get_left_neighbor_position (struct tree_balance * tb, int h);
+int get_left_neighbor_position(struct tree_balance *tb, int h);
-int get_right_neighbor_position (struct tree_balance * tb, int h);
+int get_right_neighbor_position(struct tree_balance *tb, int h);
-void replace_key (struct tree_balance * tb, struct buffer_head *, int, struct buffer_head *, int);
+void replace_key(struct tree_balance *tb, struct buffer_head *, int,
-void make_empty_node (struct buffer_info *);
+                 struct buffer_head *, int);
-struct buffer_head * get_FEB (struct tree_balance *);
+void make_empty_node(struct buffer_info *);
+struct buffer_head *get_FEB(struct tree_balance *);
 /* bitmap.c */
 /* structure contains hints for block allocator, and it is a container for
 * arguments, such as node, search path, transaction_handle, etc. */
- struct __reiserfs_blocknr_hint {
+struct __reiserfs_blocknr_hint {
-     struct inode * inode;              /* inode passed to allocator, if we allocate unf. nodes */
+        struct inode *inode;    /* inode passed to allocator, if we allocate unf. nodes */
-     long block;                        /* file offset, in blocks */
+        long block;             /* file offset, in blocks */
-     struct in_core_key key;
+        struct in_core_key key;
-     struct path * path;                /* search path, used by allocator to deternine search_start by
+        struct path *path;      /* search path, used by allocator to deternine search_start by
-                                         * various ways */
+                                 * various ways */
-     struct reiserfs_transaction_handle * th; /* transaction handle is needed to log super blocks and
+        struct reiserfs_transaction_handle *th; /* transaction handle is needed to log super blocks and
-                                               * bitmap blocks changes  */
+                                                 * bitmap blocks changes  */
-     b_blocknr_t beg, end;
+        b_blocknr_t beg, end;
-     b_blocknr_t search_start;          /* a field used to transfer search start value (block number)
+        b_blocknr_t search_start;       /* a field used to transfer search start value (block number)
                                         * between different block allocator procedures
                                         * (determine_search_start() and others) */
-    int prealloc_size;                  /* is set in determine_prealloc_size() function, used by underlayed
+        int prealloc_size;      /* is set in determine_prealloc_size() function, used by underlayed
-                                         * function that do actual allocation */
+                                 * function that do actual allocation */
-    unsigned formatted_node:1;          /* the allocator uses different polices for getting disk space for
+        unsigned formatted_node:1;      /* the allocator uses different polices for getting disk space for
                                         * formatted/unformatted blocks with/without preallocation */
-    unsigned preallocate:1;
+        unsigned preallocate:1;
 };
 typedef struct __reiserfs_blocknr_hint reiserfs_blocknr_hint_t;
-int reiserfs_parse_alloc_options (struct super_block *, char *);
+int reiserfs_parse_alloc_options(struct super_block *, char *);
-void reiserfs_init_alloc_options (struct super_block *s);
+void reiserfs_init_alloc_options(struct super_block *s);
 /*
 * given a directory, this will tell you what packing locality
@@ -2111,68 +2092,72 @@ void reiserfs_init_alloc_options (struct super_block *s);
 */
 __le32 reiserfs_choose_packing(struct inode *dir);
-int is_reusable (struct super_block * s, b_blocknr_t block, int bit_value);
+int is_reusable(struct super_block *s, b_blocknr_t block, int bit_value);
-void reiserfs_free_block (struct reiserfs_transaction_handle *th, struct inode *, b_blocknr_t, int for_unformatted);
+void reiserfs_free_block(struct reiserfs_transaction_handle *th, struct inode *,
-int reiserfs_allocate_blocknrs(reiserfs_blocknr_hint_t *, b_blocknr_t * , int, int);
+                         b_blocknr_t, int for_unformatted);
-extern inline int reiserfs_new_form_blocknrs (struct tree_balance * tb,
+int reiserfs_allocate_blocknrs(reiserfs_blocknr_hint_t *, b_blocknr_t *, int,
-                                              b_blocknr_t *new_blocknrs, int amount_needed)
+                               int);
+extern inline int reiserfs_new_form_blocknrs(struct tree_balance *tb,
+                                             b_blocknr_t * new_blocknrs,
+                                             int amount_needed)
 {
-    reiserfs_blocknr_hint_t hint = {
+        reiserfs_blocknr_hint_t hint = {
-        .th = tb->transaction_handle,
+                .th = tb->transaction_handle,
-        .path = tb->tb_path,
+                .path = tb->tb_path,
-        .inode = NULL,
+                .inode = NULL,
-        .key = tb->key,
+                .key = tb->key,
-        .block = 0,
+                .block = 0,
-        .formatted_node = 1
+                .formatted_node = 1
-    };
+        };
-    return reiserfs_allocate_blocknrs(&hint, new_blocknrs, amount_needed, 0);
+        return reiserfs_allocate_blocknrs(&hint, new_blocknrs, amount_needed,
+                                          0);
 }
-extern inline int reiserfs_new_unf_blocknrs (struct reiserfs_transaction_handle *th,
+extern inline int reiserfs_new_unf_blocknrs(struct reiserfs_transaction_handle
-                                             struct inode *inode,
+                                            *th, struct inode *inode,
-                                             b_blocknr_t *new_blocknrs,
+                                            b_blocknr_t * new_blocknrs,
-                                             struct path * path, long block)
+                                            struct path *path, long block)
 {
-    reiserfs_blocknr_hint_t hint = {
+        reiserfs_blocknr_hint_t hint = {
-        .th = th,
+                .th = th,
-        .path = path,
+                .path = path,
-        .inode = inode,
+                .inode = inode,
-        .block = block,
+                .block = block,
-        .formatted_node = 0,
+                .formatted_node = 0,
-        .preallocate = 0
+                .preallocate = 0
-    };
+        };
-    return reiserfs_allocate_blocknrs(&hint, new_blocknrs, 1, 0);
+        return reiserfs_allocate_blocknrs(&hint, new_blocknrs, 1, 0);
 }
 #ifdef REISERFS_PREALLOCATE
-extern inline int reiserfs_new_unf_blocknrs2(struct reiserfs_transaction_handle *th,
+extern inline int reiserfs_new_unf_blocknrs2(struct reiserfs_transaction_handle
-                                             struct inode * inode,
+                                             *th, struct inode *inode,
-                                             b_blocknr_t *new_blocknrs,
+                                             b_blocknr_t * new_blocknrs,
-                                             struct path * path, long block)
+                                             struct path *path, long block)
 {
-    reiserfs_blocknr_hint_t hint = {
+        reiserfs_blocknr_hint_t hint = {
-        .th = th,
+                .th = th,
-        .path = path,
+                .path = path,
-        .inode = inode,
+                .inode = inode,
-        .block = block,
+                .block = block,
-        .formatted_node = 0,
+                .formatted_node = 0,
-        .preallocate = 1
+                .preallocate = 1
-    };
+        };
-    return reiserfs_allocate_blocknrs(&hint, new_blocknrs, 1, 0);
+        return reiserfs_allocate_blocknrs(&hint, new_blocknrs, 1, 0);
 }
-void reiserfs_discard_prealloc (struct reiserfs_transaction_handle *th, 
+void reiserfs_discard_prealloc(struct reiserfs_transaction_handle *th,
-                                struct inode * inode);
+                               struct inode *inode);
-void reiserfs_discard_all_prealloc (struct reiserfs_transaction_handle *th);
+void reiserfs_discard_all_prealloc(struct reiserfs_transaction_handle *th);
 #endif
-void reiserfs_claim_blocks_to_be_allocated( struct super_block *sb, int blocks);
+void reiserfs_claim_blocks_to_be_allocated(struct super_block *sb, int blocks);
-void reiserfs_release_claimed_blocks( struct super_block *sb, int blocks);
+void reiserfs_release_claimed_blocks(struct super_block *sb, int blocks);
 int reiserfs_can_fit_pages(struct super_block *sb);
 /* hashes.c */
-__u32 keyed_hash (const signed char *msg, int len);
+__u32 keyed_hash(const signed char *msg, int len);
-__u32 yura_hash (const signed char *msg, int len);
+__u32 yura_hash(const signed char *msg, int len);
-__u32 r5_hash (const signed char *msg, int len);
+__u32 r5_hash(const signed char *msg, int len);
 /* the ext2 bit routines adjust for big or little endian as
 ** appropriate for the arch, so in our laziness we use them rather
@@ -2192,11 +2177,10 @@ __u32 r5_hash (const signed char *msg, int len);
   absolutely safe */
 #define SPARE_SPACE 500
 /* prototypes from ioctl.c */
-int reiserfs_ioctl (struct inode * inode, struct file * filp, 
+int reiserfs_ioctl(struct inode *inode, struct file *filp,
-                    unsigned int cmd, unsigned long arg);
+                   unsigned int cmd, unsigned long arg);
- 
 /* ioctl's command */
 #define REISERFS_IOC_UNPACK             _IOW(0xCD,1,long)
 /* define following flags to be the same as in ext2, so that chattr(1),
@@ -2211,10 +2195,8 @@ int reiserfs_ioctl (struct inode * inode, struct file * filp,
   would evolve into real per-fs locks */
 #define reiserfs_write_lock( sb ) lock_kernel()
 #define reiserfs_write_unlock( sb ) unlock_kernel()
-                                 
 /* xattr stuff */
 #define REISERFS_XATTR_DIR_SEM(s) (REISERFS_SB(s)->xattr_dir_sem)
-#endif /* _LINUX_REISER_FS_H */
+#endif                          /* _LINUX_REISER_FS_H */
diff --git a/include/linux/reiserfs_fs_i.h b/include/linux/reiserfs_fs_i.h
index e321eb050d65..149be8d9a0c9 100644
--- a/include/linux/reiserfs_fs_i.h
+++ b/include/linux/reiserfs_fs_i.h
@@ -10,54 +10,53 @@ typedef enum {
    /** this says what format of key do all items (but stat data) of
      an object have.  If this is set, that format is 3.6 otherwise
      - 3.5 */
-    i_item_key_version_mask    =  0x0001,
+        i_item_key_version_mask = 0x0001,
    /** If this is unset, object has 3.5 stat data, otherwise, it has
      3.6 stat data with 64bit size, 32bit nlink etc. */
-    i_stat_data_version_mask   =  0x0002,
+        i_stat_data_version_mask = 0x0002,
    /** file might need tail packing on close */
-    i_pack_on_close_mask       =  0x0004,
+        i_pack_on_close_mask = 0x0004,
    /** don't pack tail of file */
-    i_nopack_mask              =  0x0008,
+        i_nopack_mask = 0x0008,
    /** If those is set, "safe link" was created for this file during
      truncate or unlink. Safe link is used to avoid leakage of disk
      space on crash with some files open, but unlinked. */
-    i_link_saved_unlink_mask   =  0x0010,
+        i_link_saved_unlink_mask = 0x0010,
-    i_link_saved_truncate_mask =  0x0020,
+        i_link_saved_truncate_mask = 0x0020,
-    i_has_xattr_dir            =  0x0040,
+        i_has_xattr_dir = 0x0040,
-    i_data_log                 =  0x0080,
+        i_data_log = 0x0080,
 } reiserfs_inode_flags;
 struct reiserfs_inode_info {
-    __u32 i_key [4];/* key is still 4 32 bit integers */
+        __u32 i_key[4];         /* key is still 4 32 bit integers */
    /** transient inode flags that are never stored on disk. Bitmasks
      for this field are defined above. */
-    __u32 i_flags;
+        __u32 i_flags;
-    __u32 i_first_direct_byte; // offset of first byte stored in direct item.
+        __u32 i_first_direct_byte;      // offset of first byte stored in direct item.
-    /* copy of persistent inode flags read from sd_attrs. */
+        /* copy of persistent inode flags read from sd_attrs. */
-    __u32 i_attrs;
+        __u32 i_attrs;
-    int i_prealloc_block; /* first unused block of a sequence of unused blocks */
+        int i_prealloc_block;   /* first unused block of a sequence of unused blocks */
-    int i_prealloc_count; /* length of that sequence */
+        int i_prealloc_count;   /* length of that sequence */
-    struct list_head i_prealloc_list; /* per-transaction list of inodes which
+        struct list_head i_prealloc_list;       /* per-transaction list of inodes which
-                                       * have preallocated blocks */
+                                                 * have preallocated blocks */
-    unsigned new_packing_locality:1;  /* new_packig_locality is created; new blocks
+        unsigned new_packing_locality:1;        /* new_packig_locality is created; new blocks
-                                       * for the contents of this directory should be
+                                                 * for the contents of this directory should be
-                                       * displaced */
+                                                 * displaced */
-    /* we use these for fsync or O_SYNC to decide which transaction
+        /* we use these for fsync or O_SYNC to decide which transaction
-    ** needs to be committed in order for this inode to be properly
+         ** needs to be committed in order for this inode to be properly
-    ** flushed */
+         ** flushed */
-    unsigned long i_trans_id ;
+        unsigned long i_trans_id;
-    struct reiserfs_journal_list *i_jl;
+        struct reiserfs_journal_list *i_jl;
-    struct posix_acl *i_acl_access;
+        struct posix_acl *i_acl_access;
-    struct posix_acl *i_acl_default;
+        struct posix_acl *i_acl_default;
-    struct rw_semaphore xattr_sem;
+        struct rw_semaphore xattr_sem;
-    struct inode vfs_inode;
+        struct inode vfs_inode;
 };
 #endif
diff --git a/include/linux/reiserfs_fs_sb.h b/include/linux/reiserfs_fs_sb.h
index 37a3a7afbec7..3e68592e52e9 100644
--- a/include/linux/reiserfs_fs_sb.h
+++ b/include/linux/reiserfs_fs_sb.h
@@ -10,7 +10,7 @@
 #endif
 typedef enum {
-  reiserfs_attrs_cleared        = 0x00000001,
+        reiserfs_attrs_cleared = 0x00000001,
 } reiserfs_super_block_flags;
 /* struct reiserfs_super_block accessors/mutators
@@ -61,7 +61,7 @@ typedef enum {
 #define sb_umount_state(sbp)       (le16_to_cpu((sbp)->s_v1.s_umount_state))
 #define set_sb_umount_state(sbp,v) ((sbp)->s_v1.s_umount_state = cpu_to_le16(v))
 #define sb_fs_state(sbp)           (le16_to_cpu((sbp)->s_v1.s_fs_state))
-#define set_sb_fs_state(sbp,v)     ((sbp)->s_v1.s_fs_state = cpu_to_le16(v)) 
+#define set_sb_fs_state(sbp,v)     ((sbp)->s_v1.s_fs_state = cpu_to_le16(v))
 #define sb_hash_function_code(sbp) \
              (le32_to_cpu((sbp)->s_v1.s_hash_function_code))
 #define set_sb_hash_function_code(sbp,v) \
@@ -103,10 +103,10 @@ typedef enum {
 /* don't mess with these for a while */
                                /* we have a node size define somewhere in reiserfs_fs.h. -Hans */
-#define JOURNAL_BLOCK_SIZE  4096 /* BUG gotta get rid of this */
+#define JOURNAL_BLOCK_SIZE  4096        /* BUG gotta get rid of this */
-#define JOURNAL_MAX_CNODE   1500 /* max cnodes to allocate. */
+#define JOURNAL_MAX_CNODE   1500        /* max cnodes to allocate. */
-#define JOURNAL_HASH_SIZE 8192   
+#define JOURNAL_HASH_SIZE 8192
-#define JOURNAL_NUM_BITMAPS 5 /* number of copies of the bitmaps to have floating.  Must be >= 2 */
+#define JOURNAL_NUM_BITMAPS 5   /* number of copies of the bitmaps to have floating.  Must be >= 2 */
 /* One of these for every block in every transaction
 ** Each one is in two hash tables.  First, a hash of the current transaction, and after journal_end, a
@@ -117,27 +117,27 @@ typedef enum {
 ** to a given transaction.
 */
 struct reiserfs_journal_cnode {
-  struct buffer_head *bh ;               /* real buffer head */
+        struct buffer_head *bh; /* real buffer head */
-  struct super_block *sb ;               /* dev of real buffer head */
+        struct super_block *sb; /* dev of real buffer head */
-  __u32 blocknr ;                /* block number of real buffer head, == 0 when buffer on disk */
+        __u32 blocknr;          /* block number of real buffer head, == 0 when buffer on disk */
-  long state ;
+        long state;
-  struct reiserfs_journal_list *jlist ;  /* journal list this cnode lives in */
+        struct reiserfs_journal_list *jlist;    /* journal list this cnode lives in */
-  struct reiserfs_journal_cnode *next ;  /* next in transaction list */
+        struct reiserfs_journal_cnode *next;    /* next in transaction list */
-  struct reiserfs_journal_cnode *prev ;  /* prev in transaction list */
+        struct reiserfs_journal_cnode *prev;    /* prev in transaction list */
-  struct reiserfs_journal_cnode *hprev ; /* prev in hash list */
+        struct reiserfs_journal_cnode *hprev;   /* prev in hash list */
-  struct reiserfs_journal_cnode *hnext ; /* next in hash list */
+        struct reiserfs_journal_cnode *hnext;   /* next in hash list */
 };
 struct reiserfs_bitmap_node {
-  int id ;
+        int id;
-  char *data ;
+        char *data;
-  struct list_head list ;
+        struct list_head list;
-} ;
+};
 struct reiserfs_list_bitmap {
-  struct reiserfs_journal_list *journal_list ;
+        struct reiserfs_journal_list *journal_list;
-  struct reiserfs_bitmap_node **bitmaps ;
+        struct reiserfs_bitmap_node **bitmaps;
-} ;
+};
 /*
 ** one of these for each transaction.  The most important part here is the j_realblock.
@@ -146,273 +146,269 @@ struct reiserfs_list_bitmap {
 ** and to make sure every real block in a transaction is on disk before allowing the log area
 ** to be overwritten */
 struct reiserfs_journal_list {
-  unsigned long j_start ;
+        unsigned long j_start;
-  unsigned long j_state;
+        unsigned long j_state;
-  unsigned long j_len ;
+        unsigned long j_len;
-  atomic_t j_nonzerolen ;
+        atomic_t j_nonzerolen;
-  atomic_t j_commit_left ;
+        atomic_t j_commit_left;
-  atomic_t j_older_commits_done ;      /* all commits older than this on disk*/
+        atomic_t j_older_commits_done;  /* all commits older than this on disk */
-  struct semaphore j_commit_lock;
+        struct semaphore j_commit_lock;
-  unsigned long j_trans_id ;
+        unsigned long j_trans_id;
-  time_t j_timestamp ;
+        time_t j_timestamp;
-  struct reiserfs_list_bitmap *j_list_bitmap ;
+        struct reiserfs_list_bitmap *j_list_bitmap;
-  struct buffer_head *j_commit_bh ; /* commit buffer head */
+        struct buffer_head *j_commit_bh;        /* commit buffer head */
-  struct reiserfs_journal_cnode *j_realblock  ;
+        struct reiserfs_journal_cnode *j_realblock;
-  struct reiserfs_journal_cnode *j_freedlist ; /* list of buffers that were freed during this trans.  free each of these on flush */
+        struct reiserfs_journal_cnode *j_freedlist;     /* list of buffers that were freed during this trans.  free each of these on flush */
-  /* time ordered list of all active transactions */
+        /* time ordered list of all active transactions */
-  struct list_head j_list;
+        struct list_head j_list;
-  /* time ordered list of all transactions we haven't tried to flush yet */
+        /* time ordered list of all transactions we haven't tried to flush yet */
-  struct list_head j_working_list;
+        struct list_head j_working_list;
-  /* list of tail conversion targets in need of flush before commit */
+        /* list of tail conversion targets in need of flush before commit */
-  struct list_head j_tail_bh_list;
+        struct list_head j_tail_bh_list;
-  /* list of data=ordered buffers in need of flush before commit */
+        /* list of data=ordered buffers in need of flush before commit */
-  struct list_head j_bh_list;
+        struct list_head j_bh_list;
-  int j_refcount;
+        int j_refcount;
-} ;
+};
 struct reiserfs_journal {
-  struct buffer_head ** j_ap_blocks ; /* journal blocks on disk */
+        struct buffer_head **j_ap_blocks;       /* journal blocks on disk */
-  struct reiserfs_journal_cnode *j_last ; /* newest journal block */
+        struct reiserfs_journal_cnode *j_last;  /* newest journal block */
-  struct reiserfs_journal_cnode *j_first ; /*  oldest journal block.  start here for traverse */
+        struct reiserfs_journal_cnode *j_first; /*  oldest journal block.  start here for traverse */
-  struct file         *j_dev_file;
+        struct file *j_dev_file;
-  struct block_device *j_dev_bd;  
+        struct block_device *j_dev_bd;
-  int j_1st_reserved_block;     /* first block on s_dev of reserved area journal */        
+        int j_1st_reserved_block;       /* first block on s_dev of reserved area journal */
-        
-  long j_state ;                        
+        long j_state;
-  unsigned long j_trans_id ;
+        unsigned long j_trans_id;
-  unsigned long j_mount_id ;
+        unsigned long j_mount_id;
-  unsigned long j_start ;             /* start of current waiting commit (index into j_ap_blocks) */
+        unsigned long j_start;  /* start of current waiting commit (index into j_ap_blocks) */
-  unsigned long j_len ;               /* lenght of current waiting commit */
+        unsigned long j_len;    /* lenght of current waiting commit */
-  unsigned long j_len_alloc ;         /* number of buffers requested by journal_begin() */
+        unsigned long j_len_alloc;      /* number of buffers requested by journal_begin() */
-  atomic_t j_wcount ;            /* count of writers for current commit */
+        atomic_t j_wcount;      /* count of writers for current commit */
-  unsigned long j_bcount ;            /* batch count. allows turning X transactions into 1 */
+        unsigned long j_bcount; /* batch count. allows turning X transactions into 1 */
-  unsigned long j_first_unflushed_offset ;  /* first unflushed transactions offset */
+        unsigned long j_first_unflushed_offset; /* first unflushed transactions offset */
-  unsigned long j_last_flush_trans_id ;    /* last fully flushed journal timestamp */
+        unsigned long j_last_flush_trans_id;    /* last fully flushed journal timestamp */
-  struct buffer_head *j_header_bh ;   
+        struct buffer_head *j_header_bh;
-  time_t j_trans_start_time ;         /* time this transaction started */
+        time_t j_trans_start_time;      /* time this transaction started */
-  struct semaphore j_lock;
+        struct semaphore j_lock;
-  struct semaphore j_flush_sem;
+        struct semaphore j_flush_sem;
-  wait_queue_head_t j_join_wait ;    /* wait for current transaction to finish before starting new one */
+        wait_queue_head_t j_join_wait;  /* wait for current transaction to finish before starting new one */
-  atomic_t j_jlock ;                       /* lock for j_join_wait */
+        atomic_t j_jlock;       /* lock for j_join_wait */
-  int j_list_bitmap_index ;           /* number of next list bitmap to use */
+        int j_list_bitmap_index;        /* number of next list bitmap to use */
-  int j_must_wait ;                    /* no more journal begins allowed. MUST sleep on j_join_wait */
+        int j_must_wait;        /* no more journal begins allowed. MUST sleep on j_join_wait */
-  int j_next_full_flush ;             /* next journal_end will flush all journal list */
+        int j_next_full_flush;  /* next journal_end will flush all journal list */
-  int j_next_async_flush ;             /* next journal_end will flush all async commits */
+        int j_next_async_flush; /* next journal_end will flush all async commits */
-  int j_cnode_used ;          /* number of cnodes on the used list */
+        int j_cnode_used;       /* number of cnodes on the used list */
-  int j_cnode_free ;          /* number of cnodes on the free list */
+        int j_cnode_free;       /* number of cnodes on the free list */
-  unsigned int j_trans_max ;           /* max number of blocks in a transaction.  */
+        unsigned int j_trans_max;       /* max number of blocks in a transaction.  */
-  unsigned int j_max_batch ;           /* max number of blocks to batch into a trans */
+        unsigned int j_max_batch;       /* max number of blocks to batch into a trans */
-  unsigned int j_max_commit_age ;      /* in seconds, how old can an async commit be */
+        unsigned int j_max_commit_age;  /* in seconds, how old can an async commit be */
-  unsigned int j_max_trans_age ;       /* in seconds, how old can a transaction be */
+        unsigned int j_max_trans_age;   /* in seconds, how old can a transaction be */
-  unsigned int j_default_max_commit_age ; /* the default for the max commit age */
+        unsigned int j_default_max_commit_age;  /* the default for the max commit age */
-  struct reiserfs_journal_cnode *j_cnode_free_list ;
+        struct reiserfs_journal_cnode *j_cnode_free_list;
-  struct reiserfs_journal_cnode *j_cnode_free_orig ; /* orig pointer returned from vmalloc */
+        struct reiserfs_journal_cnode *j_cnode_free_orig;       /* orig pointer returned from vmalloc */
-  struct reiserfs_journal_list *j_current_jl;
+        struct reiserfs_journal_list *j_current_jl;
-  int j_free_bitmap_nodes ;
+        int j_free_bitmap_nodes;
-  int j_used_bitmap_nodes ;
+        int j_used_bitmap_nodes;
-  int j_num_lists;      /* total number of active transactions */
+        int j_num_lists;        /* total number of active transactions */
-  int j_num_work_lists; /* number that need attention from kreiserfsd */
+        int j_num_work_lists;   /* number that need attention from kreiserfsd */
-  /* debugging to make sure things are flushed in order */
+        /* debugging to make sure things are flushed in order */
-  int j_last_flush_id;
+        int j_last_flush_id;
-  /* debugging to make sure things are committed in order */
+        /* debugging to make sure things are committed in order */
-  int j_last_commit_id;
+        int j_last_commit_id;
-  struct list_head j_bitmap_nodes ;
+        struct list_head j_bitmap_nodes;
-  struct list_head j_dirty_buffers ;
+        struct list_head j_dirty_buffers;
-  spinlock_t j_dirty_buffers_lock ; /* protects j_dirty_buffers */
+        spinlock_t j_dirty_buffers_lock;        /* protects j_dirty_buffers */
-  /* list of all active transactions */
+        /* list of all active transactions */
-  struct list_head j_journal_list;
+        struct list_head j_journal_list;
-  /* lists that haven't been touched by writeback attempts */
+        /* lists that haven't been touched by writeback attempts */
-  struct list_head j_working_list;
+        struct list_head j_working_list;
-  struct reiserfs_list_bitmap j_list_bitmap[JOURNAL_NUM_BITMAPS] ;      /* array of bitmaps to record the deleted blocks */
+        struct reiserfs_list_bitmap j_list_bitmap[JOURNAL_NUM_BITMAPS]; /* array of bitmaps to record the deleted blocks */
-  struct reiserfs_journal_cnode *j_hash_table[JOURNAL_HASH_SIZE] ;          /* hash table for real buffer heads in current trans */ 
+        struct reiserfs_journal_cnode *j_hash_table[JOURNAL_HASH_SIZE]; /* hash table for real buffer heads in current trans */
-  struct reiserfs_journal_cnode *j_list_hash_table[JOURNAL_HASH_SIZE] ; /* hash table for all the real buffer heads in all 
+        struct reiserfs_journal_cnode *j_list_hash_table[JOURNAL_HASH_SIZE];    /* hash table for all the real buffer heads in all 
-                                                                                the transactions */
+                                                                                   the transactions */
-  struct list_head j_prealloc_list;     /* list of inodes which have preallocated blocks */
+        struct list_head j_prealloc_list;       /* list of inodes which have preallocated blocks */
-  int j_persistent_trans;
+        int j_persistent_trans;
-  unsigned long j_max_trans_size ;
+        unsigned long j_max_trans_size;
-  unsigned long j_max_batch_size ;
+        unsigned long j_max_batch_size;
-  int j_errno;
+        int j_errno;
-  /* when flushing ordered buffers, throttle new ordered writers */
+        /* when flushing ordered buffers, throttle new ordered writers */
-  struct work_struct j_work;
+        struct work_struct j_work;
-  atomic_t j_async_throttle;
+        atomic_t j_async_throttle;
 };
 enum journal_state_bits {
-    J_WRITERS_BLOCKED = 1,   /* set when new writers not allowed */
+        J_WRITERS_BLOCKED = 1,  /* set when new writers not allowed */
-    J_WRITERS_QUEUED,        /* set when log is full due to too many writers */
+        J_WRITERS_QUEUED,       /* set when log is full due to too many writers */
-    J_ABORTED,               /* set when log is aborted */
+        J_ABORTED,              /* set when log is aborted */
 };
+#define JOURNAL_DESC_MAGIC "ReIsErLB"   /* ick.  magic string to find desc blocks in the journal */
-#define JOURNAL_DESC_MAGIC "ReIsErLB" /* ick.  magic string to find desc blocks in the journal */
+typedef __u32(*hashf_t) (const signed char *, int);
-typedef __u32 (*hashf_t) (const signed char *, int);
+struct reiserfs_bitmap_info {
+        // FIXME: Won't work with block sizes > 8K
-struct reiserfs_bitmap_info
+        __u16 first_zero_hint;
-{
+        __u16 free_count;
-    // FIXME: Won't work with block sizes > 8K
+        struct buffer_head *bh; /* the actual bitmap */
-    __u16  first_zero_hint;
-    __u16  free_count;
-    struct buffer_head *bh; /* the actual bitmap */
 };
 struct proc_dir_entry;
 #if defined( CONFIG_PROC_FS ) && defined( CONFIG_REISERFS_PROC_INFO )
 typedef unsigned long int stat_cnt_t;
-typedef struct reiserfs_proc_info_data
+typedef struct reiserfs_proc_info_data {
-{
+        spinlock_t lock;
-  spinlock_t lock;
+        int exiting;
-  int exiting;
+        int max_hash_collisions;
-  int max_hash_collisions;
+        stat_cnt_t breads;
-  stat_cnt_t breads;
+        stat_cnt_t bread_miss;
-  stat_cnt_t bread_miss;
+        stat_cnt_t search_by_key;
-  stat_cnt_t search_by_key;
+        stat_cnt_t search_by_key_fs_changed;
-  stat_cnt_t search_by_key_fs_changed;
+        stat_cnt_t search_by_key_restarted;
-  stat_cnt_t search_by_key_restarted;
+        stat_cnt_t insert_item_restarted;
-  stat_cnt_t insert_item_restarted;
+        stat_cnt_t paste_into_item_restarted;
-  stat_cnt_t paste_into_item_restarted;
+        stat_cnt_t cut_from_item_restarted;
-  stat_cnt_t cut_from_item_restarted;
+        stat_cnt_t delete_solid_item_restarted;
-  stat_cnt_t delete_solid_item_restarted;
+        stat_cnt_t delete_item_restarted;
-  stat_cnt_t delete_item_restarted;
+        stat_cnt_t leaked_oid;
-  stat_cnt_t leaked_oid;
+        stat_cnt_t leaves_removable;
-  stat_cnt_t leaves_removable;
+        /* balances per level. Use explicit 5 as MAX_HEIGHT is not visible yet. */
-  /* balances per level. Use explicit 5 as MAX_HEIGHT is not visible yet. */
+        stat_cnt_t balance_at[5];       /* XXX */
-  stat_cnt_t balance_at[ 5 ]; /* XXX */
+        /* sbk == search_by_key */
-  /* sbk == search_by_key */
+        stat_cnt_t sbk_read_at[5];      /* XXX */
-  stat_cnt_t sbk_read_at[ 5 ]; /* XXX */
+        stat_cnt_t sbk_fs_changed[5];
-  stat_cnt_t sbk_fs_changed[ 5 ];
+        stat_cnt_t sbk_restarted[5];
-  stat_cnt_t sbk_restarted[ 5 ];
+        stat_cnt_t items_at[5]; /* XXX */
-  stat_cnt_t items_at[ 5 ]; /* XXX */
+        stat_cnt_t free_at[5];  /* XXX */
-  stat_cnt_t free_at[ 5 ]; /* XXX */
+        stat_cnt_t can_node_be_removed[5];      /* XXX */
-  stat_cnt_t can_node_be_removed[ 5 ]; /* XXX */
+        long int lnum[5];       /* XXX */
-  long int lnum[ 5 ]; /* XXX */
+        long int rnum[5];       /* XXX */
-  long int rnum[ 5 ]; /* XXX */
+        long int lbytes[5];     /* XXX */
-  long int lbytes[ 5 ]; /* XXX */
+        long int rbytes[5];     /* XXX */
-  long int rbytes[ 5 ]; /* XXX */
+        stat_cnt_t get_neighbors[5];
-  stat_cnt_t get_neighbors[ 5 ];
+        stat_cnt_t get_neighbors_restart[5];
-  stat_cnt_t get_neighbors_restart[ 5 ];
+        stat_cnt_t need_l_neighbor[5];
-  stat_cnt_t need_l_neighbor[ 5 ];
+        stat_cnt_t need_r_neighbor[5];
-  stat_cnt_t need_r_neighbor[ 5 ];
+        stat_cnt_t free_block;
-  stat_cnt_t free_block;
+        struct __scan_bitmap_stats {
-  struct __scan_bitmap_stats {
+                stat_cnt_t call;
-        stat_cnt_t call;
+                stat_cnt_t wait;
-        stat_cnt_t wait;
+                stat_cnt_t bmap;
-        stat_cnt_t bmap;
+                stat_cnt_t retry;
-        stat_cnt_t retry;
+                stat_cnt_t in_journal_hint;
-        stat_cnt_t in_journal_hint;
+                stat_cnt_t in_journal_nohint;
-        stat_cnt_t in_journal_nohint;
+                stat_cnt_t stolen;
-        stat_cnt_t stolen;
+        } scan_bitmap;
-  } scan_bitmap;
+        struct __journal_stats {
-  struct __journal_stats {
+                stat_cnt_t in_journal;
-        stat_cnt_t in_journal;
+                stat_cnt_t in_journal_bitmap;
-        stat_cnt_t in_journal_bitmap;
+                stat_cnt_t in_journal_reusable;
-        stat_cnt_t in_journal_reusable;
+                stat_cnt_t lock_journal;
-        stat_cnt_t lock_journal;
+                stat_cnt_t lock_journal_wait;
-        stat_cnt_t lock_journal_wait;
+                stat_cnt_t journal_being;
-        stat_cnt_t journal_being;
+                stat_cnt_t journal_relock_writers;
-        stat_cnt_t journal_relock_writers;
+                stat_cnt_t journal_relock_wcount;
-        stat_cnt_t journal_relock_wcount;
+                stat_cnt_t mark_dirty;
-        stat_cnt_t mark_dirty;
+                stat_cnt_t mark_dirty_already;
-        stat_cnt_t mark_dirty_already;
+                stat_cnt_t mark_dirty_notjournal;
-        stat_cnt_t mark_dirty_notjournal;
+                stat_cnt_t restore_prepared;
-        stat_cnt_t restore_prepared;
+                stat_cnt_t prepare;
-        stat_cnt_t prepare;
+                stat_cnt_t prepare_retry;
-        stat_cnt_t prepare_retry;
+        } journal;
-  } journal;
 } reiserfs_proc_info_data_t;
 #else
-typedef struct reiserfs_proc_info_data
+typedef struct reiserfs_proc_info_data {
-{} reiserfs_proc_info_data_t;
+} reiserfs_proc_info_data_t;
 #endif
 /* reiserfs union of in-core super block data */
-struct reiserfs_sb_info
+struct reiserfs_sb_info {
-{
+        struct buffer_head *s_sbh;      /* Buffer containing the super block */
-    struct buffer_head * s_sbh;                   /* Buffer containing the super block */
+        /* both the comment and the choice of
-                                /* both the comment and the choice of
+           name are unclear for s_rs -Hans */
-                                   name are unclear for s_rs -Hans */
+        struct reiserfs_super_block *s_rs;      /* Pointer to the super block in the buffer */
-    struct reiserfs_super_block * s_rs;           /* Pointer to the super block in the buffer */
+        struct reiserfs_bitmap_info *s_ap_bitmap;
-    struct reiserfs_bitmap_info * s_ap_bitmap;
+        struct reiserfs_journal *s_journal;     /* pointer to journal information */
-    struct reiserfs_journal *s_journal ;                /* pointer to journal information */
+        unsigned short s_mount_state;   /* reiserfs state (valid, invalid) */
-    unsigned short s_mount_state;                 /* reiserfs state (valid, invalid) */
-  
+        /* Comment? -Hans */
-                                /* Comment? -Hans */
+        void (*end_io_handler) (struct buffer_head *, int);
-    void (*end_io_handler)(struct buffer_head *, int);
+        hashf_t s_hash_function;        /* pointer to function which is used
-    hashf_t s_hash_function;    /* pointer to function which is used
+                                           to sort names in directory. Set on
-                                   to sort names in directory. Set on
+                                           mount */
-                                   mount */
+        unsigned long s_mount_opt;      /* reiserfs's mount options are set
-    unsigned long s_mount_opt;  /* reiserfs's mount options are set
+                                           here (currently - NOTAIL, NOLOG,
-                                   here (currently - NOTAIL, NOLOG,
+                                           REPLAYONLY) */
-                                   REPLAYONLY) */
+        struct {                /* This is a structure that describes block allocator options */
-    struct {                    /* This is a structure that describes block allocator options */
+                unsigned long bits;     /* Bitfield for enable/disable kind of options */
-        unsigned long bits;     /* Bitfield for enable/disable kind of options */
+                unsigned long large_file_size;  /* size started from which we consider file to be a large one(in blocks) */
-        unsigned long large_file_size; /* size started from which we consider file to be a large one(in blocks) */
+                int border;     /* percentage of disk, border takes */
-        int border;             /* percentage of disk, border takes */
+                int preallocmin;        /* Minimal file size (in blocks) starting from which we do preallocations */
-        int preallocmin;        /* Minimal file size (in blocks) starting from which we do preallocations */
+                int preallocsize;       /* Number of blocks we try to prealloc when file
-        int preallocsize;       /* Number of blocks we try to prealloc when file
+                                           reaches preallocmin size (in blocks) or
-                                   reaches preallocmin size (in blocks) or
+                                           prealloc_list is empty. */
-                                   prealloc_list is empty. */
+        } s_alloc_options;
-    } s_alloc_options;
+        /* Comment? -Hans */
-                                /* Comment? -Hans */
+        wait_queue_head_t s_wait;
-    wait_queue_head_t s_wait;
+        /* To be obsoleted soon by per buffer seals.. -Hans */
-                                /* To be obsoleted soon by per buffer seals.. -Hans */
+        atomic_t s_generation_counter;  // increased by one every time the
-    atomic_t s_generation_counter; // increased by one every time the
+        // tree gets re-balanced
-    // tree gets re-balanced
+        unsigned long s_properties;     /* File system properties. Currently holds
-    unsigned long s_properties;    /* File system properties. Currently holds
+                                           on-disk FS format */
-                                     on-disk FS format */
-    
+        /* session statistics */
-    /* session statistics */
+        int s_kmallocs;
-    int s_kmallocs;
+        int s_disk_reads;
-    int s_disk_reads;
+        int s_disk_writes;
-    int s_disk_writes;
+        int s_fix_nodes;
-    int s_fix_nodes;
+        int s_do_balance;
-    int s_do_balance;
+        int s_unneeded_left_neighbor;
-    int s_unneeded_left_neighbor;
+        int s_good_search_by_key_reada;
-    int s_good_search_by_key_reada;
+        int s_bmaps;
-    int s_bmaps;
+        int s_bmaps_without_search;
-    int s_bmaps_without_search;
+        int s_direct2indirect;
-    int s_direct2indirect;
+        int s_indirect2direct;
-    int s_indirect2direct;
        /* set up when it's ok for reiserfs_read_inode2() to read from
           disk inode with nlink==0. Currently this is only used during
           finish_unfinished() processing at mount time */
-    int s_is_unlinked_ok;
+        int s_is_unlinked_ok;
-    reiserfs_proc_info_data_t s_proc_info_data;
+        reiserfs_proc_info_data_t s_proc_info_data;
-    struct proc_dir_entry *procdir;
+        struct proc_dir_entry *procdir;
-    int reserved_blocks; /* amount of blocks reserved for further allocations */
+        int reserved_blocks;    /* amount of blocks reserved for further allocations */
-    spinlock_t bitmap_lock; /* this lock on now only used to protect reserved_blocks variable */
+        spinlock_t bitmap_lock; /* this lock on now only used to protect reserved_blocks variable */
-    struct dentry *priv_root; /* root of /.reiserfs_priv */
+        struct dentry *priv_root;       /* root of /.reiserfs_priv */
-    struct dentry *xattr_root; /* root of /.reiserfs_priv/.xa */
+        struct dentry *xattr_root;      /* root of /.reiserfs_priv/.xa */
-    struct rw_semaphore xattr_dir_sem;
+        struct rw_semaphore xattr_dir_sem;
-    int j_errno;
+        int j_errno;
 #ifdef CONFIG_QUOTA
-    char *s_qf_names[MAXQUOTAS];
+        char *s_qf_names[MAXQUOTAS];
-    int s_jquota_fmt;
+        int s_jquota_fmt;
 #endif
 };
@@ -422,14 +418,14 @@ struct reiserfs_sb_info
 enum reiserfs_mount_options {
 /* Mount options */
-    REISERFS_LARGETAIL,  /* large tails will be created in a session */
+        REISERFS_LARGETAIL,     /* large tails will be created in a session */
-    REISERFS_SMALLTAIL,  /* small (for files less than block size) tails will be created in a session */
+        REISERFS_SMALLTAIL,     /* small (for files less than block size) tails will be created in a session */
-    REPLAYONLY, /* replay journal and return 0. Use by fsck */
+        REPLAYONLY,             /* replay journal and return 0. Use by fsck */
-    REISERFS_CONVERT,    /* -o conv: causes conversion of old
+        REISERFS_CONVERT,       /* -o conv: causes conversion of old
-                                 format super block to the new
+                                   format super block to the new
-                                 format. If not specified - old
+                                   format. If not specified - old
-                                 partition will be dealt with in a
+                                   partition will be dealt with in a
-                                 manner of 3.5.x */
+                                   manner of 3.5.x */
 /* -o hash={tea, rupasov, r5, detect} is meant for properly mounting 
 ** reiserfs disks from 3.5.19 or earlier.  99% of the time, this option
@@ -439,39 +435,41 @@ enum reiserfs_mount_options {
 ** the existing hash on the FS, so if you have a tea hash disk, and mount
 ** with -o hash=rupasov, the mount will fail.
 */
-    FORCE_TEA_HASH,      /* try to force tea hash on mount */
+        FORCE_TEA_HASH,         /* try to force tea hash on mount */
-    FORCE_RUPASOV_HASH,  /* try to force rupasov hash on mount */
+        FORCE_RUPASOV_HASH,     /* try to force rupasov hash on mount */
-    FORCE_R5_HASH,       /* try to force rupasov hash on mount */
+        FORCE_R5_HASH,          /* try to force rupasov hash on mount */
-    FORCE_HASH_DETECT,   /* try to detect hash function on mount */
+        FORCE_HASH_DETECT,      /* try to detect hash function on mount */
-    REISERFS_DATA_LOG,
+        REISERFS_DATA_LOG,
-    REISERFS_DATA_ORDERED,
+        REISERFS_DATA_ORDERED,
-    REISERFS_DATA_WRITEBACK,
+        REISERFS_DATA_WRITEBACK,
 /* used for testing experimental features, makes benchmarking new
   features with and without more convenient, should never be used by
   users in any code shipped to users (ideally) */
-    REISERFS_NO_BORDER,
+        REISERFS_NO_BORDER,
-    REISERFS_NO_UNHASHED_RELOCATION,
+        REISERFS_NO_UNHASHED_RELOCATION,
-    REISERFS_HASHED_RELOCATION,
+        REISERFS_HASHED_RELOCATION,
-    REISERFS_ATTRS,
+        REISERFS_ATTRS,
-    REISERFS_XATTRS,
+        REISERFS_XATTRS,
-    REISERFS_XATTRS_USER,
+        REISERFS_XATTRS_USER,
-    REISERFS_POSIXACL,
+        REISERFS_POSIXACL,
-    REISERFS_BARRIER_NONE,
+        REISERFS_BARRIER_NONE,
-    REISERFS_BARRIER_FLUSH,
+        REISERFS_BARRIER_FLUSH,
-    /* Actions on error */
+        /* Actions on error */
-    REISERFS_ERROR_PANIC,
+        REISERFS_ERROR_PANIC,
-    REISERFS_ERROR_RO,
+        REISERFS_ERROR_RO,
-    REISERFS_ERROR_CONTINUE,
+        REISERFS_ERROR_CONTINUE,
-    REISERFS_TEST1,
+        REISERFS_QUOTA,         /* Some quota option specified */
-    REISERFS_TEST2,
-    REISERFS_TEST3,
+        REISERFS_TEST1,
-    REISERFS_TEST4,
+        REISERFS_TEST2,
-    REISERFS_UNSUPPORTED_OPT,
+        REISERFS_TEST3,
+        REISERFS_TEST4,
+        REISERFS_UNSUPPORTED_OPT,
 };
 #define reiserfs_r5_hash(s) (REISERFS_SB(s)->s_mount_opt & (1 << FORCE_R5_HASH))
@@ -502,18 +500,17 @@ enum reiserfs_mount_options {
 #define reiserfs_error_panic(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_ERROR_PANIC))
 #define reiserfs_error_ro(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_ERROR_RO))
-void reiserfs_file_buffer (struct buffer_head * bh, int list);
+void reiserfs_file_buffer(struct buffer_head *bh, int list);
 extern struct file_system_type reiserfs_fs_type;
-int reiserfs_resize(struct super_block *, unsigned long) ;
+int reiserfs_resize(struct super_block *, unsigned long);
 #define CARRY_ON                0
 #define SCHEDULE_OCCURRED       1
 #define SB_BUFFER_WITH_SB(s) (REISERFS_SB(s)->s_sbh)
 #define SB_JOURNAL(s) (REISERFS_SB(s)->s_journal)
 #define SB_JOURNAL_1st_RESERVED_BLOCK(s) (SB_JOURNAL(s)->j_1st_reserved_block)
-#define SB_JOURNAL_LEN_FREE(s) (SB_JOURNAL(s)->j_journal_len_free) 
+#define SB_JOURNAL_LEN_FREE(s) (SB_JOURNAL(s)->j_journal_len_free)
 #define SB_AP_BITMAP(s) (REISERFS_SB(s)->s_ap_bitmap)
 #define SB_DISK_JOURNAL_HEAD(s) (SB_JOURNAL(s)->j_header_bh->)
@@ -523,13 +520,14 @@ int reiserfs_resize(struct super_block *, unsigned long) ;
 */
 static inline char *reiserfs_bdevname(struct super_block *s)
 {
-        return (s == NULL) ? "Null superblock" : s -> s_id;
+        return (s == NULL) ? "Null superblock" : s->s_id;
 }
 #define reiserfs_is_journal_aborted(journal) (unlikely (__reiserfs_is_journal_aborted (journal)))
-static inline int __reiserfs_is_journal_aborted (struct reiserfs_journal *journal)
+static inline int __reiserfs_is_journal_aborted(struct reiserfs_journal
+                                                *journal)
 {
-    return test_bit (J_ABORTED, &journal->j_state);
+        return test_bit(J_ABORTED, &journal->j_state);
 }
-#endif  /* _LINUX_REISER_FS_SB */
+#endif                          /* _LINUX_REISER_FS_SB */
diff --git a/include/linux/reiserfs_xattr.h b/include/linux/reiserfs_xattr.h
index 9244c5748820..c84354e8374c 100644
--- a/include/linux/reiserfs_xattr.h
+++ b/include/linux/reiserfs_xattr.h
@@ -7,48 +7,48 @@
 #include <linux/xattr.h>
 /* Magic value in header */
-#define REISERFS_XATTR_MAGIC 0x52465841 /* "RFXA" */
+#define REISERFS_XATTR_MAGIC 0x52465841 /* "RFXA" */
 struct reiserfs_xattr_header {
-    __le32 h_magic;              /* magic number for identification */
+        __le32 h_magic;         /* magic number for identification */
-    __le32 h_hash;               /* hash of the value */
+        __le32 h_hash;          /* hash of the value */
 };
 #ifdef __KERNEL__
 struct reiserfs_xattr_handler {
        char *prefix;
-        int (*init)(void);
+        int (*init) (void);
-        void (*exit)(void);
+        void (*exit) (void);
-        int (*get)(struct inode *inode, const char *name, void *buffer,
+        int (*get) (struct inode * inode, const char *name, void *buffer,
-                   size_t size);
+                    size_t size);
-        int (*set)(struct inode *inode, const char *name, const void *buffer,
+        int (*set) (struct inode * inode, const char *name, const void *buffer,
-                   size_t size, int flags);
+                    size_t size, int flags);
-        int (*del)(struct inode *inode, const char *name);
+        int (*del) (struct inode * inode, const char *name);
-        int (*list)(struct inode *inode, const char *name, int namelen, char *out);
+        int (*list) (struct inode * inode, const char *name, int namelen,
-        struct list_head handlers;
+                     char *out);
+        struct list_head handlers;
 };
 #ifdef CONFIG_REISERFS_FS_XATTR
 #define is_reiserfs_priv_object(inode) IS_PRIVATE(inode)
 #define has_xattr_dir(inode) (REISERFS_I(inode)->i_flags & i_has_xattr_dir)
-ssize_t reiserfs_getxattr (struct dentry *dentry, const char *name,
+ssize_t reiserfs_getxattr(struct dentry *dentry, const char *name,
-                           void *buffer, size_t size);
+                          void *buffer, size_t size);
-int reiserfs_setxattr (struct dentry *dentry, const char *name,
+int reiserfs_setxattr(struct dentry *dentry, const char *name,
-                       const void *value, size_t size, int flags);
+                      const void *value, size_t size, int flags);
-ssize_t reiserfs_listxattr (struct dentry *dentry, char *buffer, size_t size);
+ssize_t reiserfs_listxattr(struct dentry *dentry, char *buffer, size_t size);
-int reiserfs_removexattr (struct dentry *dentry, const char *name);
+int reiserfs_removexattr(struct dentry *dentry, const char *name);
-int reiserfs_delete_xattrs (struct inode *inode);
+int reiserfs_delete_xattrs(struct inode *inode);
-int reiserfs_chown_xattrs (struct inode *inode, struct iattr *attrs);
+int reiserfs_chown_xattrs(struct inode *inode, struct iattr *attrs);
-int reiserfs_xattr_init (struct super_block *sb, int mount_flags);
+int reiserfs_xattr_init(struct super_block *sb, int mount_flags);
-int reiserfs_permission (struct inode *inode, int mask, struct nameidata *nd);
+int reiserfs_permission(struct inode *inode, int mask, struct nameidata *nd);
-int reiserfs_permission_locked (struct inode *inode, int mask, struct nameidata *nd);
+int reiserfs_permission_locked(struct inode *inode, int mask,
+                               struct nameidata *nd);
-int reiserfs_xattr_del (struct inode *, const char *);
-int reiserfs_xattr_get (const struct inode *, const char *, void *, size_t);
+int reiserfs_xattr_del(struct inode *, const char *);
-int reiserfs_xattr_set (struct inode *, const char *, const void *,
+int reiserfs_xattr_get(const struct inode *, const char *, void *, size_t);
-                               size_t, int);
+int reiserfs_xattr_set(struct inode *, const char *, const void *, size_t, int);
 extern struct reiserfs_xattr_handler user_handler;
 extern struct reiserfs_xattr_handler trusted_handler;
@@ -56,57 +56,48 @@ extern struct reiserfs_xattr_handler trusted_handler;
 extern struct reiserfs_xattr_handler security_handler;
 #endif
-int reiserfs_xattr_register_handlers (void) __init;
+int reiserfs_xattr_register_handlers(void) __init;
-void reiserfs_xattr_unregister_handlers (void);
+void reiserfs_xattr_unregister_handlers(void);
-static inline void
+static inline void reiserfs_write_lock_xattrs(struct super_block *sb)
-reiserfs_write_lock_xattrs(struct super_block *sb)
 {
-    down_write (&REISERFS_XATTR_DIR_SEM(sb));
+        down_write(&REISERFS_XATTR_DIR_SEM(sb));
 }
-static inline void
+static inline void reiserfs_write_unlock_xattrs(struct super_block *sb)
-reiserfs_write_unlock_xattrs(struct super_block *sb)
 {
-    up_write (&REISERFS_XATTR_DIR_SEM(sb));
+        up_write(&REISERFS_XATTR_DIR_SEM(sb));
 }
-static inline void
+static inline void reiserfs_read_lock_xattrs(struct super_block *sb)
-reiserfs_read_lock_xattrs(struct super_block *sb)
 {
-    down_read (&REISERFS_XATTR_DIR_SEM(sb));
+        down_read(&REISERFS_XATTR_DIR_SEM(sb));
 }
-static inline void
+static inline void reiserfs_read_unlock_xattrs(struct super_block *sb)
-reiserfs_read_unlock_xattrs(struct super_block *sb)
 {
-    up_read (&REISERFS_XATTR_DIR_SEM(sb));
+        up_read(&REISERFS_XATTR_DIR_SEM(sb));
 }
-static inline void
+static inline void reiserfs_write_lock_xattr_i(struct inode *inode)
-reiserfs_write_lock_xattr_i(struct inode *inode)
 {
-    down_write (&REISERFS_I(inode)->xattr_sem);
+        down_write(&REISERFS_I(inode)->xattr_sem);
 }
-static inline void
+static inline void reiserfs_write_unlock_xattr_i(struct inode *inode)
-reiserfs_write_unlock_xattr_i(struct inode *inode)
 {
-    up_write (&REISERFS_I(inode)->xattr_sem);
+        up_write(&REISERFS_I(inode)->xattr_sem);
 }
-static inline void
+static inline void reiserfs_read_lock_xattr_i(struct inode *inode)
-reiserfs_read_lock_xattr_i(struct inode *inode)
 {
-    down_read (&REISERFS_I(inode)->xattr_sem);
+        down_read(&REISERFS_I(inode)->xattr_sem);
 }
-static inline void
+static inline void reiserfs_read_unlock_xattr_i(struct inode *inode)
-reiserfs_read_unlock_xattr_i(struct inode *inode)
 {
-    up_read (&REISERFS_I(inode)->xattr_sem);
+        up_read(&REISERFS_I(inode)->xattr_sem);
 }
-static inline void
+static inline void reiserfs_mark_inode_private(struct inode *inode)
-reiserfs_mark_inode_private(struct inode *inode)
 {
-    inode->i_flags |= S_PRIVATE;
+        inode->i_flags |= S_PRIVATE;
 }
 #else
@@ -127,13 +118,20 @@ reiserfs_mark_inode_private(struct inode *inode)
 #define reiserfs_xattr_register_handlers() 0
 #define reiserfs_xattr_unregister_handlers()
-static inline int reiserfs_delete_xattrs (struct inode *inode) { return 0; };
+static inline int reiserfs_delete_xattrs(struct inode *inode)
-static inline int reiserfs_chown_xattrs (struct inode *inode, struct iattr *attrs) { return 0; };
+{
-static inline int reiserfs_xattr_init (struct super_block *sb, int mount_flags)
+        return 0;
+};
+static inline int reiserfs_chown_xattrs(struct inode *inode,
+                                        struct iattr *attrs)
+{
+        return 0;
+};
+static inline int reiserfs_xattr_init(struct super_block *sb, int mount_flags)
 {
-    sb->s_flags = (sb->s_flags & ~MS_POSIXACL); /* to be sure */
+        sb->s_flags = (sb->s_flags & ~MS_POSIXACL);     /* to be sure */
-    return 0;
+        return 0;
 };
 #endif
-#endif  /* __KERNEL__ */
+#endif                          /* __KERNEL__ */
diff --git a/include/linux/rmap.h b/include/linux/rmap.h
index 11b484e37ac9..e80fb7ee6efd 100644
--- a/include/linux/rmap.h
+++ b/include/linux/rmap.h
@@ -93,6 +93,12 @@ int page_referenced(struct page *, int is_locked, int ignore_token);
 int try_to_unmap(struct page *);
 /*
+ * Called from mm/filemap_xip.c to unmap empty zero page
+ */
+pte_t *page_check_address(struct page *, struct mm_struct *, unsigned long);
+/*
 * Used by swapoff to help locate where page is expected in vma.
 */
 unsigned long page_address_in_vma(struct page *, struct vm_area_struct *);
diff --git a/include/linux/rtnetlink.h b/include/linux/rtnetlink.h
index e68dbf0bf579..657c05ab8f9e 100644
--- a/include/linux/rtnetlink.h
+++ b/include/linux/rtnetlink.h
@@ -363,6 +363,8 @@ enum
 struct rta_session
 {
        __u8    proto;
+        __u8    pad1;
+        __u16   pad2;
        union {
                struct {
@@ -635,10 +637,13 @@ struct ifinfomsg
 struct prefixmsg
 {
        unsigned char   prefix_family;
+        unsigned char   prefix_pad1;
+        unsigned short  prefix_pad2;
        int             prefix_ifindex;
        unsigned char   prefix_type;
        unsigned char   prefix_len;
        unsigned char   prefix_flags;
+        unsigned char   prefix_pad3;
 };
 enum 
@@ -892,10 +897,15 @@ extern void __rta_fill(struct sk_buff *skb, int attrtype, int attrlen, const voi
                 goto rtattr_failure; \
        __rta_fill(skb, attrtype, attrlen, data); }) 
-#define RTA_PUT_NOHDR(skb, attrlen, data) \
+#define RTA_APPEND(skb, attrlen, data) \
 ({      if (unlikely(skb_tailroom(skb) < (int)(attrlen))) \
                goto rtattr_failure; \
-        memcpy(skb_put(skb, RTA_ALIGN(attrlen)), data, attrlen); })
+        memcpy(skb_put(skb, attrlen), data, attrlen); })
+#define RTA_PUT_NOHDR(skb, attrlen, data) \
+({      RTA_APPEND(skb, RTA_ALIGN(attrlen), data); \
+        memset(skb->tail - (RTA_ALIGN(attrlen) - attrlen), 0, \
+               RTA_ALIGN(attrlen) - attrlen); })
 #define RTA_PUT_U8(skb, attrtype, value) \
 ({      u8 _tmp = (value); \
@@ -975,6 +985,7 @@ __rta_reserve(struct sk_buff *skb, int attrtype, int attrlen)
        rta = (struct rtattr*)skb_put(skb, RTA_ALIGN(size));
        rta->rta_type = attrtype;
        rta->rta_len = size;
+        memset(RTA_DATA(rta) + attrlen, 0, RTA_ALIGN(size) - size);
        return rta;
 }
diff --git a/include/linux/sched.h b/include/linux/sched.h
index b58afd97a180..dec5827c7742 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -246,7 +246,7 @@ struct mm_struct {
        unsigned long saved_auxv[42]; /* for /proc/PID/auxv */
-        unsigned dumpable:1;
+        unsigned dumpable:2;
        cpumask_t cpu_vm_mask;
        /* Architecture-specific MM context */
@@ -368,6 +368,11 @@ struct signal_struct {
 #endif
 };
+/* Context switch must be unlocked if interrupts are to be enabled */
+#ifdef __ARCH_WANT_INTERRUPTS_ON_CTXSW
+# define __ARCH_WANT_UNLOCKED_CTXSW
+#endif
 /*
 * Bits in flags field of signal_struct.
 */
@@ -405,6 +410,10 @@ struct user_struct {
        atomic_t processes;     /* How many processes does this user have? */
        atomic_t files;         /* How many open files does this user have? */
        atomic_t sigpending;    /* How many pending signals does this user have? */
+#ifdef CONFIG_INOTIFY
+        atomic_t inotify_watches; /* How many inotify watches does this user have? */
+        atomic_t inotify_devs;  /* How many inotify devs does this user have opened? */
+#endif
        /* protected by mq_lock */
        unsigned long mq_bytes; /* How many bytes can be allocated to mqueue? */
        unsigned long locked_shm; /* How many pages of mlocked shm ? */
@@ -460,10 +469,11 @@ enum idle_type
 #define SD_LOAD_BALANCE         1       /* Do load balancing on this domain. */
 #define SD_BALANCE_NEWIDLE      2       /* Balance when about to become idle */
 #define SD_BALANCE_EXEC         4       /* Balance on exec */
-#define SD_WAKE_IDLE            8       /* Wake to idle CPU on task wakeup */
+#define SD_BALANCE_FORK         8       /* Balance on fork, clone */
-#define SD_WAKE_AFFINE          16      /* Wake task to waking CPU */
+#define SD_WAKE_IDLE            16      /* Wake to idle CPU on task wakeup */
-#define SD_WAKE_BALANCE         32      /* Perform balancing at task wakeup */
+#define SD_WAKE_AFFINE          32      /* Wake task to waking CPU */
-#define SD_SHARE_CPUPOWER       64      /* Domain members share cpu power */
+#define SD_WAKE_BALANCE         64      /* Perform balancing at task wakeup */
+#define SD_SHARE_CPUPOWER       128     /* Domain members share cpu power */
 struct sched_group {
        struct sched_group *next;       /* Must be a circular list */
@@ -488,6 +498,11 @@ struct sched_domain {
        unsigned long long cache_hot_time; /* Task considered cache hot (ns) */
        unsigned int cache_nice_tries;  /* Leave cache hot tasks for # tries */
        unsigned int per_cpu_gain;      /* CPU % gained by adding domain cpus */
+        unsigned int busy_idx;
+        unsigned int idle_idx;
+        unsigned int newidle_idx;
+        unsigned int wake_idx;
+        unsigned int forkexec_idx;
        int flags;                      /* See SD_* */
        /* Runtime fields. */
@@ -511,10 +526,16 @@ struct sched_domain {
        unsigned long alb_failed;
        unsigned long alb_pushed;
-        /* sched_balance_exec() stats */
+        /* SD_BALANCE_EXEC stats */
-        unsigned long sbe_attempts;
+        unsigned long sbe_cnt;
+        unsigned long sbe_balanced;
        unsigned long sbe_pushed;
+        /* SD_BALANCE_FORK stats */
+        unsigned long sbf_cnt;
+        unsigned long sbf_balanced;
+        unsigned long sbf_pushed;
        /* try_to_wake_up() stats */
        unsigned long ttwu_wake_remote;
        unsigned long ttwu_move_affine;
@@ -522,6 +543,8 @@ struct sched_domain {
 #endif
 };
+extern void partition_sched_domains(cpumask_t *partition1,
+                                    cpumask_t *partition2);
 #ifdef ARCH_HAS_SCHED_DOMAIN
 /* Useful helpers that arch setup code may use. Defined in kernel/sched.c */
 extern cpumask_t cpu_isolated_map;
@@ -561,9 +584,10 @@ struct group_info {
                groups_free(group_info); \
 } while (0)
-struct group_info *groups_alloc(int gidsetsize);
+extern struct group_info *groups_alloc(int gidsetsize);
-void groups_free(struct group_info *group_info);
+extern void groups_free(struct group_info *group_info);
-int set_current_groups(struct group_info *group_info);
+extern int set_current_groups(struct group_info *group_info);
+extern int groups_search(struct group_info *group_info, gid_t grp);
 /* access the groups "array" with this macro */
 #define GROUP_AT(gi, i) \
    ((gi)->blocks[(i)/NGROUPS_PER_BLOCK][(i)%NGROUPS_PER_BLOCK])
@@ -581,10 +605,15 @@ struct task_struct {
        int lock_depth;         /* BKL lock depth */
+#if defined(CONFIG_SMP) && defined(__ARCH_WANT_UNLOCKED_CTXSW)
+        int oncpu;
+#endif
        int prio, static_prio;
        struct list_head run_list;
        prio_array_t *array;
+        unsigned short ioprio;
        unsigned long sleep_avg;
        unsigned long long timestamp, last_ran;
        unsigned long long sched_time; /* sched_clock time spent running */
@@ -660,6 +689,7 @@ struct task_struct {
        struct user_struct *user;
 #ifdef CONFIG_KEYS
        struct key *thread_keyring;     /* keyring private to this thread */
+        unsigned char jit_keyring;      /* default keyring to attach requested keys to */
 #endif
        int oomkilladj; /* OOM kill score adjustment (bit shift). */
        char comm[TASK_COMM_LEN]; /* executable name excluding path
@@ -702,8 +732,6 @@ struct task_struct {
        spinlock_t alloc_lock;
 /* Protection of proc_dentry: nesting proc_lock, dcache_lock, write_lock_irq(&tasklist_lock); */
        spinlock_t proc_lock;
-/* context-switch lock */
-        spinlock_t switch_lock;
 /* journalling filesystem info */
        void *journal_info;
@@ -741,6 +769,7 @@ struct task_struct {
        nodemask_t mems_allowed;
        int cpuset_mems_generation;
 #endif
+        atomic_t fs_excl;       /* holding fs exclusive resources */
 };
 static inline pid_t process_group(struct task_struct *tsk)
@@ -910,7 +939,7 @@ extern void FASTCALL(wake_up_new_task(struct task_struct * tsk,
 #else
 static inline void kick_process(struct task_struct *tsk) { }
 #endif
-extern void FASTCALL(sched_fork(task_t * p));
+extern void FASTCALL(sched_fork(task_t * p, int clone_flags));
 extern void FASTCALL(sched_exit(task_t * p));
 extern int in_group_p(gid_t);
@@ -1090,7 +1119,8 @@ extern void unhash_process(struct task_struct *p);
 /*
 * Protects ->fs, ->files, ->mm, ->ptrace, ->group_info, ->comm, keyring
- * subscriptions and synchronises with wait4().  Also used in procfs.
+ * subscriptions and synchronises with wait4().  Also used in procfs.  Also
+ * pins the final release of task.io_context.
 *
 * Nests both inside and outside of read_lock(&tasklist_lock).
 * It must not be nested with write_lock_irq(&tasklist_lock),
@@ -1243,33 +1273,78 @@ extern void normalize_rt_tasks(void);
 #endif
-/* try_to_freeze
- *
- * Checks whether we need to enter the refrigerator
- * and returns 1 if we did so.
- */
 #ifdef CONFIG_PM
-extern void refrigerator(unsigned long);
+/*
+ * Check if a process has been frozen
+ */
+static inline int frozen(struct task_struct *p)
+{
+        return p->flags & PF_FROZEN;
+}
+/*
+ * Check if there is a request to freeze a process
+ */
+static inline int freezing(struct task_struct *p)
+{
+        return p->flags & PF_FREEZE;
+}
+/*
+ * Request that a process be frozen
+ * FIXME: SMP problem. We may not modify other process' flags!
+ */
+static inline void freeze(struct task_struct *p)
+{
+        p->flags |= PF_FREEZE;
+}
+/*
+ * Wake up a frozen process
+ */
+static inline int thaw_process(struct task_struct *p)
+{
+        if (frozen(p)) {
+                p->flags &= ~PF_FROZEN;
+                wake_up_process(p);
+                return 1;
+        }
+        return 0;
+}
+/*
+ * freezing is complete, mark process as frozen
+ */
+static inline void frozen_process(struct task_struct *p)
+{
+        p->flags = (p->flags & ~PF_FREEZE) | PF_FROZEN;
+}
+extern void refrigerator(void);
 extern int freeze_processes(void);
 extern void thaw_processes(void);
-static inline int try_to_freeze(unsigned long refrigerator_flags)
+static inline int try_to_freeze(void)
 {
-        if (unlikely(current->flags & PF_FREEZE)) {
+        if (freezing(current)) {
-                refrigerator(refrigerator_flags);
+                refrigerator();
                return 1;
        } else
                return 0;
 }
 #else
-static inline void refrigerator(unsigned long flag) {}
+static inline int frozen(struct task_struct *p) { return 0; }
+static inline int freezing(struct task_struct *p) { return 0; }
+static inline void freeze(struct task_struct *p) { BUG(); }
+static inline int thaw_process(struct task_struct *p) { return 1; }
+static inline void frozen_process(struct task_struct *p) { BUG(); }
+static inline void refrigerator(void) {}
 static inline int freeze_processes(void) { BUG(); return 0; }
 static inline void thaw_processes(void) {}
-static inline int try_to_freeze(unsigned long refrigerator_flags)
+static inline int try_to_freeze(void) { return 0; }
-{
-        return 0;
-}
 #endif /* CONFIG_PM */
 #endif /* __KERNEL__ */
diff --git a/include/linux/seccomp.h b/include/linux/seccomp.h
index 3a2702bbb1d6..dc89116bb1ca 100644
--- a/include/linux/seccomp.h
+++ b/include/linux/seccomp.h
@@ -19,6 +19,11 @@ static inline void secure_computing(int this_syscall)
                __secure_computing(this_syscall);
 }
+static inline int has_secure_computing(struct thread_info *ti)
+{
+        return unlikely(test_ti_thread_flag(ti, TIF_SECCOMP));
+}
 #else /* CONFIG_SECCOMP */
 #if (__GNUC__ > 2)
@@ -28,6 +33,11 @@ static inline void secure_computing(int this_syscall)
 #endif
 #define secure_computing(x) do { } while (0)
+/* static inline to preserve typechecking */
+static inline int has_secure_computing(struct thread_info *ti)
+{
+        return 0;
+}
 #endif /* CONFIG_SECCOMP */
diff --git a/include/linux/serial.h b/include/linux/serial.h
index 00145822fb74..9f2d85284d0b 100644
--- a/include/linux/serial.h
+++ b/include/linux/serial.h
@@ -174,9 +174,11 @@ struct serial_icounter_struct {
 #ifdef __KERNEL__
+#include <linux/compiler.h>
 /* Export to allow PCMCIA to use this - Dave Hinds */
-extern int register_serial(struct serial_struct *req);
+extern int __deprecated register_serial(struct serial_struct *req);
-extern void unregister_serial(int line);
+extern void __deprecated unregister_serial(int line);
 /* Allow architectures to override entries in serial8250_ports[] at run time: */
 struct uart_port;       /* forward declaration */
diff --git a/include/linux/serialP.h b/include/linux/serialP.h
index 2307f11d8a6b..2b2f35a64d75 100644
--- a/include/linux/serialP.h
+++ b/include/linux/serialP.h
@@ -19,7 +19,6 @@
 * For definitions of the flags field, see tty.h
 */
-#include <linux/version.h>
 #include <linux/config.h>
 #include <linux/termios.h>
 #include <linux/workqueue.h>
diff --git a/include/linux/serial_8250.h b/include/linux/serial_8250.h
index 823181af6ddf..3e3c1fa35b06 100644
--- a/include/linux/serial_8250.h
+++ b/include/linux/serial_8250.h
@@ -22,6 +22,7 @@ struct plat_serial8250_port {
        unsigned int    uartclk;        /* UART clock rate */
        unsigned char   regshift;       /* register shift */
        unsigned char   iotype;         /* UPIO_* */
+        unsigned char   hub6;
        unsigned int    flags;          /* UPF_* flags */
 };
diff --git a/include/linux/serial_core.h b/include/linux/serial_core.h
index d6025af7efac..f6fca8f2f3ca 100644
--- a/include/linux/serial_core.h
+++ b/include/linux/serial_core.h
@@ -104,7 +104,7 @@
 #define PORT_MPSC       63
 /* TXX9 type number */
-#define PORT_TXX9       64
+#define PORT_TXX9       64
 /* NEC VR4100 series SIU/DSIU */
 #define PORT_VR41XX_SIU         65
@@ -122,6 +122,7 @@
 #ifdef __KERNEL__
 #include <linux/config.h>
+#include <linux/compiler.h>
 #include <linux/interrupt.h>
 #include <linux/circ_buf.h>
 #include <linux/spinlock.h>
@@ -359,8 +360,8 @@ struct tty_driver *uart_console_device(struct console *co, int *index);
 */
 int uart_register_driver(struct uart_driver *uart);
 void uart_unregister_driver(struct uart_driver *uart);
-void uart_unregister_port(struct uart_driver *reg, int line);
+void __deprecated uart_unregister_port(struct uart_driver *reg, int line);
-int uart_register_port(struct uart_driver *reg, struct uart_port *port);
+int __deprecated uart_register_port(struct uart_driver *reg, struct uart_port *port);
 int uart_add_one_port(struct uart_driver *reg, struct uart_port *port);
 int uart_remove_one_port(struct uart_driver *reg, struct uart_port *port);
 int uart_match_port(struct uart_port *port1, struct uart_port *port2);
diff --git a/include/linux/serio.h b/include/linux/serio.h
index a2d3b9ae06f4..aa4d6493a034 100644
--- a/include/linux/serio.h
+++ b/include/linux/serio.h
@@ -83,6 +83,7 @@ static inline void serio_register_port(struct serio *serio)
 }
 void serio_unregister_port(struct serio *serio);
+void serio_unregister_child_port(struct serio *serio);
 void __serio_unregister_port_delayed(struct serio *serio, struct module *owner);
 static inline void serio_unregister_port_delayed(struct serio *serio)
 {
@@ -153,6 +154,11 @@ static inline int serio_pin_driver(struct serio *serio)
        return down_interruptible(&serio->drv_sem);
 }
+static inline void serio_pin_driver_uninterruptible(struct serio *serio)
+{
+        down(&serio->drv_sem);
+}
 static inline void serio_unpin_driver(struct serio *serio)
 {
        up(&serio->drv_sem);
diff --git a/include/linux/skbuff.h b/include/linux/skbuff.h
index d7c839a21842..948527e42a60 100644
--- a/include/linux/skbuff.h
+++ b/include/linux/skbuff.h
@@ -27,6 +27,7 @@
 #include <linux/highmem.h>
 #include <linux/poll.h>
 #include <linux/net.h>
+#include <linux/textsearch.h>
 #include <net/checksum.h>
 #define HAVE_ALLOC_SKB          /* For the drivers to know */
@@ -182,7 +183,6 @@ struct skb_shared_info {
 *      @priority: Packet queueing priority
 *      @users: User count - see {datagram,tcp}.c
 *      @protocol: Packet protocol from driver
- *      @security: Security level of packet
 *      @truesize: Buffer size 
 *      @head: Head of buffer
 *      @data: Data head pointer
@@ -248,18 +248,18 @@ struct sk_buff {
                                data_len,
                                mac_len,
                                csum;
-        unsigned char           local_df,
-                                cloned:1,
-                                nohdr:1,
-                                pkt_type,
-                                ip_summed;
        __u32                   priority;
-        unsigned short          protocol,
+        __u8                    local_df:1,
-                                security;
+                                cloned:1,
+                                ip_summed:2,
+                                nohdr:1;
+                                /* 3 bits spare */
+        __u8                    pkt_type;
+        __be16                  protocol;
        void                    (*destructor)(struct sk_buff *skb);
 #ifdef CONFIG_NETFILTER
-        unsigned long           nfmark;
+        unsigned long           nfmark;
        __u32                   nfcache;
        __u32                   nfctinfo;
        struct nf_conntrack     *nfct;
@@ -300,20 +300,26 @@ struct sk_buff {
 #include <asm/system.h>
 extern void            __kfree_skb(struct sk_buff *skb);
-extern struct sk_buff *alloc_skb(unsigned int size, int priority);
+extern struct sk_buff *alloc_skb(unsigned int size,
+                                 unsigned int __nocast priority);
 extern struct sk_buff *alloc_skb_from_cache(kmem_cache_t *cp,
-                                            unsigned int size, int priority);
+                                            unsigned int size,
+                                            unsigned int __nocast priority);
 extern void            kfree_skbmem(struct sk_buff *skb);
-extern struct sk_buff *skb_clone(struct sk_buff *skb, int priority);
+extern struct sk_buff *skb_clone(struct sk_buff *skb,
-extern struct sk_buff *skb_copy(const struct sk_buff *skb, int priority);
+                                 unsigned int __nocast priority);
-extern struct sk_buff *pskb_copy(struct sk_buff *skb, int gfp_mask);
+extern struct sk_buff *skb_copy(const struct sk_buff *skb,
+                                unsigned int __nocast priority);
+extern struct sk_buff *pskb_copy(struct sk_buff *skb,
+                                 unsigned int __nocast gfp_mask);
 extern int             pskb_expand_head(struct sk_buff *skb,
-                                        int nhead, int ntail, int gfp_mask);
+                                        int nhead, int ntail,
+                                        unsigned int __nocast gfp_mask);
 extern struct sk_buff *skb_realloc_headroom(struct sk_buff *skb,
                                            unsigned int headroom);
 extern struct sk_buff *skb_copy_expand(const struct sk_buff *skb,
                                       int newheadroom, int newtailroom,
-                                       int priority);
+                                       unsigned int __nocast priority);
 extern struct sk_buff *         skb_pad(struct sk_buff *skb, int pad);
 #define dev_kfree_skb(a)        kfree_skb(a)
 extern void           skb_over_panic(struct sk_buff *skb, int len,
@@ -321,6 +327,28 @@ extern void	      skb_over_panic(struct sk_buff *skb, int len,
 extern void           skb_under_panic(struct sk_buff *skb, int len,
                                      void *here);
+struct skb_seq_state
+{
+        __u32           lower_offset;
+        __u32           upper_offset;
+        __u32           frag_idx;
+        __u32           stepped_offset;
+        struct sk_buff  *root_skb;
+        struct sk_buff  *cur_skb;
+        __u8            *frag_data;
+};
+extern void           skb_prepare_seq_read(struct sk_buff *skb,
+                                           unsigned int from, unsigned int to,
+                                           struct skb_seq_state *st);
+extern unsigned int   skb_seq_read(unsigned int consumed, const u8 **data,
+                                   struct skb_seq_state *st);
+extern void           skb_abort_seq_read(struct skb_seq_state *st);
+extern unsigned int   skb_find_text(struct sk_buff *skb, unsigned int from,
+                                    unsigned int to, struct ts_config *config,
+                                    struct ts_state *state);
 /* Internal */
 #define skb_shinfo(SKB)         ((struct skb_shared_info *)((SKB)->end))
@@ -442,7 +470,8 @@ static inline int skb_shared(const struct sk_buff *skb)
 *
 *      NULL is returned on a memory allocation failure.
 */
-static inline struct sk_buff *skb_share_check(struct sk_buff *skb, int pri)
+static inline struct sk_buff *skb_share_check(struct sk_buff *skb,
+                                              unsigned int __nocast pri)
 {
        might_sleep_if(pri & __GFP_WAIT);
        if (skb_shared(skb)) {
@@ -473,7 +502,8 @@ static inline struct sk_buff *skb_share_check(struct sk_buff *skb, int pri)
 *
 *      %NULL is returned on a memory allocation failure.
 */
-static inline struct sk_buff *skb_unshare(struct sk_buff *skb, int pri)
+static inline struct sk_buff *skb_unshare(struct sk_buff *skb,
+                                          unsigned int __nocast pri)
 {
        might_sleep_if(pri & __GFP_WAIT);
        if (skb_cloned(skb)) {
@@ -979,7 +1009,7 @@ static inline void __skb_queue_purge(struct sk_buff_head *list)
 *      %NULL is returned in there is no free memory.
 */
 static inline struct sk_buff *__dev_alloc_skb(unsigned int length,
-                                              int gfp_mask)
+                                              unsigned int __nocast gfp_mask)
 {
        struct sk_buff *skb = alloc_skb(length + 16, gfp_mask);
        if (likely(skb))
@@ -1092,8 +1122,8 @@ static inline int skb_can_coalesce(struct sk_buff *skb, int i,
 *      If there is no free memory -ENOMEM is returned, otherwise zero
 *      is returned and the old skb data released.
 */
-extern int __skb_linearize(struct sk_buff *skb, int gfp);
+extern int __skb_linearize(struct sk_buff *skb, unsigned int __nocast gfp);
-static inline int skb_linearize(struct sk_buff *skb, int gfp)
+static inline int skb_linearize(struct sk_buff *skb, unsigned int __nocast gfp)
 {
        return __skb_linearize(skb, gfp);
 }
@@ -1188,7 +1218,7 @@ static inline void *skb_header_pointer(const struct sk_buff *skb, int offset,
 {
        int hlen = skb_headlen(skb);
-        if (offset + len <= hlen)
+        if (hlen - offset >= len)
                return skb->data + offset;
        if (skb_copy_bits(skb, offset, buffer, len) < 0)
diff --git a/include/linux/slab.h b/include/linux/slab.h
index 76cf7e60216c..80b2dfde2e80 100644
--- a/include/linux/slab.h
+++ b/include/linux/slab.h
@@ -65,7 +65,7 @@ extern void *kmem_cache_alloc(kmem_cache_t *, unsigned int __nocast);
 extern void kmem_cache_free(kmem_cache_t *, void *);
 extern unsigned int kmem_cache_size(kmem_cache_t *);
 extern const char *kmem_cache_name(kmem_cache_t *);
-extern kmem_cache_t *kmem_find_general_cachep(size_t size, int gfpflags);
+extern kmem_cache_t *kmem_find_general_cachep(size_t size, unsigned int __nocast gfpflags);
 /* Size description struct for general caches. */
 struct cache_sizes {
@@ -105,13 +105,13 @@ extern unsigned int ksize(const void *);
 #ifdef CONFIG_NUMA
 extern void *kmem_cache_alloc_node(kmem_cache_t *, int flags, int node);
-extern void *kmalloc_node(size_t size, int flags, int node);
+extern void *kmalloc_node(size_t size, unsigned int __nocast flags, int node);
 #else
 static inline void *kmem_cache_alloc_node(kmem_cache_t *cachep, int flags, int node)
 {
        return kmem_cache_alloc(cachep, flags);
 }
-static inline void *kmalloc_node(size_t size, int flags, int node)
+static inline void *kmalloc_node(size_t size, unsigned int __nocast flags, int node)
 {
        return kmalloc(size, flags);
 }
diff --git a/include/linux/string.h b/include/linux/string.h
index b9fc59469956..dab2652acbd8 100644
--- a/include/linux/string.h
+++ b/include/linux/string.h
@@ -88,6 +88,8 @@ extern int memcmp(const void *,const void *,__kernel_size_t);
 extern void * memchr(const void *,int,__kernel_size_t);
 #endif
+extern char *kstrdup(const char *s, unsigned int __nocast gfp);
 #ifdef __cplusplus
 }
 #endif
diff --git a/include/linux/sunrpc/clnt.h b/include/linux/sunrpc/clnt.h
index 2709caf4d128..ab151bbb66df 100644
--- a/include/linux/sunrpc/clnt.h
+++ b/include/linux/sunrpc/clnt.h
@@ -111,6 +111,11 @@ struct rpc_procinfo {
 struct rpc_clnt *rpc_create_client(struct rpc_xprt *xprt, char *servname,
                                struct rpc_program *info,
                                u32 version, rpc_authflavor_t authflavor);
+struct rpc_clnt *rpc_new_client(struct rpc_xprt *xprt, char *servname,
+                                struct rpc_program *info,
+                                u32 version, rpc_authflavor_t authflavor);
+struct rpc_clnt *rpc_bind_new_program(struct rpc_clnt *,
+                                struct rpc_program *, int);
 struct rpc_clnt *rpc_clone_client(struct rpc_clnt *);
 int             rpc_shutdown_client(struct rpc_clnt *);
 int             rpc_destroy_client(struct rpc_clnt *);
@@ -129,6 +134,7 @@ void		rpc_clnt_sigmask(struct rpc_clnt *clnt, sigset_t *oldset);
 void            rpc_clnt_sigunmask(struct rpc_clnt *clnt, sigset_t *oldset);
 void            rpc_setbufsize(struct rpc_clnt *, unsigned int, unsigned int);
 size_t          rpc_max_payload(struct rpc_clnt *);
+int             rpc_ping(struct rpc_clnt *clnt, int flags);
 static __inline__
 int rpc_call(struct rpc_clnt *clnt, u32 proc, void *argp, void *resp, int flags)
diff --git a/include/linux/sunrpc/sched.h b/include/linux/sunrpc/sched.h
index 99d17ed7cebb..4d77e90d0b30 100644
--- a/include/linux/sunrpc/sched.h
+++ b/include/linux/sunrpc/sched.h
@@ -31,7 +31,6 @@ struct rpc_wait_queue;
 struct rpc_wait {
        struct list_head        list;           /* wait queue links */
        struct list_head        links;          /* Links to related tasks */
-        wait_queue_head_t       waitq;          /* sync: sleep on this q */
        struct rpc_wait_queue * rpc_waitq;      /* RPC wait queue we're on */
 };
diff --git a/include/linux/sunrpc/svc.h b/include/linux/sunrpc/svc.h
index 37003970cf2e..5af8800e0ce3 100644
--- a/include/linux/sunrpc/svc.h
+++ b/include/linux/sunrpc/svc.h
@@ -185,6 +185,17 @@ xdr_ressize_check(struct svc_rqst *rqstp, u32 *p)
        return vec->iov_len <= PAGE_SIZE;
 }
+static inline struct page *
+svc_take_res_page(struct svc_rqst *rqstp)
+{
+        if (rqstp->rq_arghi <= rqstp->rq_argused)
+                return NULL;
+        rqstp->rq_arghi--;
+        rqstp->rq_respages[rqstp->rq_resused] =
+                rqstp->rq_argpages[rqstp->rq_arghi];
+        return rqstp->rq_respages[rqstp->rq_resused++];
+}
 static inline int svc_take_page(struct svc_rqst *rqstp)
 {
        if (rqstp->rq_arghi <= rqstp->rq_argused)
@@ -240,9 +251,10 @@ struct svc_deferred_req {
 };
 /*
- * RPC program
+ * List of RPC programs on the same transport endpoint
 */
 struct svc_program {
+        struct svc_program *    pg_next;        /* other programs (same xprt) */
        u32                     pg_prog;        /* program number */
        unsigned int            pg_lovers;      /* lowest version */
        unsigned int            pg_hivers;      /* lowest version */
diff --git a/include/linux/sunrpc/xdr.h b/include/linux/sunrpc/xdr.h
index 541dcf838abf..23448d0fb5bc 100644
--- a/include/linux/sunrpc/xdr.h
+++ b/include/linux/sunrpc/xdr.h
@@ -146,7 +146,8 @@ extern void xdr_shift_buf(struct xdr_buf *, size_t);
 extern void xdr_buf_from_iov(struct kvec *, struct xdr_buf *);
 extern int xdr_buf_subsegment(struct xdr_buf *, struct xdr_buf *, int, int);
 extern int xdr_buf_read_netobj(struct xdr_buf *, struct xdr_netobj *, int);
-extern int read_bytes_from_xdr_buf(struct xdr_buf *buf, int base, void *obj, int len);
+extern int read_bytes_from_xdr_buf(struct xdr_buf *, int, void *, int);
+extern int write_bytes_to_xdr_buf(struct xdr_buf *, int, void *, int);
 /*
 * Helper structure for copying from an sk_buff.
@@ -160,7 +161,7 @@ typedef struct {
 typedef size_t (*skb_read_actor_t)(skb_reader_t *desc, void *to, size_t len);
-extern void xdr_partial_copy_from_skb(struct xdr_buf *, unsigned int,
+extern ssize_t xdr_partial_copy_from_skb(struct xdr_buf *, unsigned int,
                skb_reader_t *, skb_read_actor_t);
 struct socket;
@@ -168,6 +169,23 @@ struct sockaddr;
 extern int xdr_sendpages(struct socket *, struct sockaddr *, int,
                struct xdr_buf *, unsigned int, int);
+extern int xdr_encode_word(struct xdr_buf *, int, u32);
+extern int xdr_decode_word(struct xdr_buf *, int, u32 *);
+struct xdr_array2_desc;
+typedef int (*xdr_xcode_elem_t)(struct xdr_array2_desc *desc, void *elem);
+struct xdr_array2_desc {
+        unsigned int elem_size;
+        unsigned int array_len;
+        unsigned int array_maxlen;
+        xdr_xcode_elem_t xcode;
+};
+extern int xdr_decode_array2(struct xdr_buf *buf, unsigned int base,
+                             struct xdr_array2_desc *desc);
+extern int xdr_encode_array2(struct xdr_buf *buf, unsigned int base,
+                             struct xdr_array2_desc *desc);
 /*
 * Provide some simple tools for XDR buffer overflow-checking etc.
 */
diff --git a/include/linux/suspend.h b/include/linux/suspend.h
index 2bf0d5fabcdb..f2e96fdfaae0 100644
--- a/include/linux/suspend.h
+++ b/include/linux/suspend.h
@@ -58,7 +58,7 @@ static inline int software_suspend(void)
 }
 #endif
-#ifdef CONFIG_SMP
+#ifdef CONFIG_SUSPEND_SMP
 extern void disable_nonboot_cpus(void);
 extern void enable_nonboot_cpus(void);
 #else
diff --git a/include/linux/swap.h b/include/linux/swap.h
index 2343f999e6e1..bfe3e763ccf2 100644
--- a/include/linux/swap.h
+++ b/include/linux/swap.h
@@ -7,6 +7,7 @@
 #include <linux/mmzone.h>
 #include <linux/list.h>
 #include <linux/sched.h>
 #include <asm/atomic.h>
 #include <asm/page.h>
@@ -148,7 +149,7 @@ struct swap_list_t {
 #define vm_swap_full() (nr_swap_pages*2 < total_swap_pages)
 /* linux/mm/oom_kill.c */
-extern void out_of_memory(unsigned int __nocast gfp_mask);
+extern void out_of_memory(unsigned int __nocast gfp_mask, int order);
 /* linux/mm/memory.c */
 extern void swapin_readahead(swp_entry_t, unsigned long, struct vm_area_struct *);
@@ -253,6 +254,8 @@ static inline void put_swap_token(struct mm_struct *mm)
 #define si_swapinfo(val) \
        do { (val)->freeswap = (val)->totalswap = 0; } while (0)
+/* only sparc can not include linux/pagemap.h in this file
+ * so leave page_cache_release and release_pages undeclared... */
 #define free_page_and_swap_cache(page) \
        page_cache_release(page)
 #define free_pages_and_swap_cache(pages, nr) \
diff --git a/include/linux/syscalls.h b/include/linux/syscalls.h
index c39f6f72cbbc..425f58c8ea4a 100644
--- a/include/linux/syscalls.h
+++ b/include/linux/syscalls.h
@@ -159,8 +159,9 @@ asmlinkage long sys_shutdown(int, int);
 asmlinkage long sys_reboot(int magic1, int magic2, unsigned int cmd,
                                void __user *arg);
 asmlinkage long sys_restart_syscall(void);
-asmlinkage long sys_kexec_load(void *entry, unsigned long nr_segments,
+asmlinkage long sys_kexec_load(unsigned long entry, unsigned long nr_segments,
-                        struct kexec_segment *segments, unsigned long flags);
+                                struct kexec_segment __user *segments,
+                                unsigned long flags);
 asmlinkage long sys_exit(int error_code);
 asmlinkage void sys_exit_group(int error_code);
@@ -505,4 +506,7 @@ asmlinkage long sys_request_key(const char __user *_type,
 asmlinkage long sys_keyctl(int cmd, unsigned long arg2, unsigned long arg3,
                           unsigned long arg4, unsigned long arg5);
+asmlinkage long sys_ioprio_set(int which, int who, int ioprio);
+asmlinkage long sys_ioprio_get(int which, int who);
 #endif
diff --git a/include/linux/sysctl.h b/include/linux/sysctl.h
index a17745c80a91..e82be96d4906 100644
--- a/include/linux/sysctl.h
+++ b/include/linux/sysctl.h
@@ -70,6 +70,14 @@ enum
        CTL_BUS_ISA=1           /* ISA */
 };
+/* /proc/sys/fs/inotify/ */
+enum
+{
+        INOTIFY_MAX_USER_INSTANCES=1,   /* max instances per user */
+        INOTIFY_MAX_USER_WATCHES=2,     /* max watches per user */
+        INOTIFY_MAX_QUEUED_EVENTS=3     /* max queued events per instance */
+};
 /* CTL_KERN names: */
 enum
 {
@@ -136,6 +144,8 @@ enum
        KERN_UNKNOWN_NMI_PANIC=66, /* int: unknown nmi panic flag */
        KERN_BOOTLOADER_TYPE=67, /* int: boot loader type */
        KERN_RANDOMIZE=68, /* int: randomize virtual address space */
+        KERN_SETUID_DUMPABLE=69, /* int: behaviour of dumps for setuid core */
+        KERN_SPIN_RETRY=70,     /* int: number of spinlock retries */
 };
@@ -242,6 +252,7 @@ enum
        NET_CORE_MOD_CONG=16,
        NET_CORE_DEV_WEIGHT=17,
        NET_CORE_SOMAXCONN=18,
+        NET_CORE_BUDGET=19,
 };
 /* /proc/sys/net/ethernet */
@@ -332,21 +343,14 @@ enum
        NET_TCP_FRTO=92,
        NET_TCP_LOW_LATENCY=93,
        NET_IPV4_IPFRAG_SECRET_INTERVAL=94,
-        NET_TCP_WESTWOOD=95,
        NET_IPV4_IGMP_MAX_MSF=96,
        NET_TCP_NO_METRICS_SAVE=97,
-        NET_TCP_VEGAS=98,
-        NET_TCP_VEGAS_ALPHA=99,
-        NET_TCP_VEGAS_BETA=100,
-        NET_TCP_VEGAS_GAMMA=101,
-        NET_TCP_BIC=102,
-        NET_TCP_BIC_FAST_CONVERGENCE=103,
-        NET_TCP_BIC_LOW_WINDOW=104,
        NET_TCP_DEFAULT_WIN_SCALE=105,
        NET_TCP_MODERATE_RCVBUF=106,
        NET_TCP_TSO_WIN_DIVISOR=107,
        NET_TCP_BIC_BETA=108,
        NET_IPV4_ICMP_ERRORS_USE_INBOUND_IFADDR=109,
+        NET_TCP_CONG_CONTROL=110,
 };
 enum {
@@ -646,6 +650,7 @@ enum {
        NET_SCTP_ADDIP_ENABLE            = 13,
        NET_SCTP_PRSCTP_ENABLE           = 14,
        NET_SCTP_SNDBUF_POLICY           = 15,
+        NET_SCTP_SACK_TIMEOUT            = 16,
 };
 /* /proc/sys/net/bridge */
@@ -680,6 +685,7 @@ enum
        FS_XFS=17,      /* struct: control xfs parameters */
        FS_AIO_NR=18,   /* current system-wide number of aio requests */
        FS_AIO_MAX_NR=19,       /* system-wide maximum number of aio requests */
+        FS_INOTIFY=20,  /* inotify submenu */
 };
 /* /proc/sys/fs/quota/ */
diff --git a/include/linux/tc_ematch/tc_em_meta.h b/include/linux/tc_ematch/tc_em_meta.h
index a6b2cc530af5..081b1ee8516e 100644
--- a/include/linux/tc_ematch/tc_em_meta.h
+++ b/include/linux/tc_ematch/tc_em_meta.h
@@ -41,19 +41,14 @@ enum
        TCF_META_ID_LOADAVG_1,
        TCF_META_ID_LOADAVG_2,
        TCF_META_ID_DEV,
-        TCF_META_ID_INDEV,
-        TCF_META_ID_REALDEV,
        TCF_META_ID_PRIORITY,
        TCF_META_ID_PROTOCOL,
-        TCF_META_ID_SECURITY,
        TCF_META_ID_PKTTYPE,
        TCF_META_ID_PKTLEN,
        TCF_META_ID_DATALEN,
        TCF_META_ID_MACLEN,
        TCF_META_ID_NFMARK,
        TCF_META_ID_TCINDEX,
-        TCF_META_ID_TCVERDICT,
-        TCF_META_ID_TCCLASSID,
        TCF_META_ID_RTCLASSID,
        TCF_META_ID_RTIIF,
        TCF_META_ID_SK_FAMILY,
diff --git a/include/linux/tc_ematch/tc_em_text.h b/include/linux/tc_ematch/tc_em_text.h
new file mode 100644
index 000000000000..7cd43e99c7f5
--- /dev/null
+++ b/include/linux/tc_ematch/tc_em_text.h
@@ -0,0 +1,19 @@
+#ifndef __LINUX_TC_EM_TEXT_H
+#define __LINUX_TC_EM_TEXT_H
+#include <linux/pkt_cls.h>
+#define TC_EM_TEXT_ALGOSIZ      16
+struct tcf_em_text
+{
+        char            algo[TC_EM_TEXT_ALGOSIZ];
+        __u16           from_offset;
+        __u16           to_offset;
+        __u16           pattern_len;
+        __u8            from_layer:4;
+        __u8            to_layer:4;
+        __u8            pad;
+};
+#endif
diff --git a/include/linux/tcp.h b/include/linux/tcp.h
index 97a7c9e03df5..e4fd82e42104 100644
--- a/include/linux/tcp.h
+++ b/include/linux/tcp.h
@@ -127,6 +127,7 @@ enum {
 #define TCP_WINDOW_CLAMP        10      /* Bound advertised window */
 #define TCP_INFO                11      /* Information about this connection. */
 #define TCP_QUICKACK            12      /* Block/reenable quick acks */
+#define TCP_CONGESTION          13      /* Congestion control algorithm */
 #define TCPI_OPT_TIMESTAMPS     1
 #define TCPI_OPT_SACK           2
@@ -203,13 +204,6 @@ struct tcp_sack_block {
        __u32   end_seq;
 };
-enum tcp_congestion_algo {
-        TCP_RENO=0,
-        TCP_VEGAS,
-        TCP_WESTWOOD,
-        TCP_BIC,
-};
 struct tcp_options_received {
 /*      PAWS/RTTM data  */
        long    ts_recent_stamp;/* Time we stored ts_recent (for aging) */
@@ -292,7 +286,7 @@ struct tcp_sock {
        __u32   max_window;     /* Maximal window ever seen from peer   */
        __u32   pmtu_cookie;    /* Last pmtu seen by socket             */
        __u32   mss_cache;      /* Cached effective mss, not including SACKS */
-        __u16   mss_cache_std;  /* Like mss_cache, but without TSO */
+        __u16   xmit_size_goal; /* Goal for segmenting output packets   */
        __u16   ext_header_len; /* Network protocol overhead (IP/IPv6 options) */
        __u8    ca_state;       /* State of fast-retransmit machine     */
        __u8    retransmits;    /* Number of unrecovered RTO timeouts.  */
@@ -305,7 +299,7 @@ struct tcp_sock {
        __u8    reordering;     /* Packet reordering metric.            */
        __u8    frto_counter;   /* Number of new acks after RTO */
-        __u8    adv_cong;       /* Using Vegas, Westwood, or BIC */
+        __u8    unused;
        __u8    defer_accept;   /* User waits for some data after accept() */
 /* RTT measurement */
@@ -401,37 +395,10 @@ struct tcp_sock {
                __u32   time;
        } rcvq_space;
-/* TCP Westwood structure */
+        /* Pluggable TCP congestion control hook */
-        struct {
+        struct tcp_congestion_ops *ca_ops;
-                __u32    bw_ns_est;        /* first bandwidth estimation..not too smoothed 8) */
+        u32     ca_priv[16];
-                __u32    bw_est;           /* bandwidth estimate */
+#define TCP_CA_PRIV_SIZE        (16*sizeof(u32))
-                __u32    rtt_win_sx;       /* here starts a new evaluation... */
-                __u32    bk;
-                __u32    snd_una;          /* used for evaluating the number of acked bytes */
-                __u32    cumul_ack;
-                __u32    accounted;
-                __u32    rtt;
-                __u32    rtt_min;          /* minimum observed RTT */
-        } westwood;
-/* Vegas variables */
-        struct {
-                __u32   beg_snd_nxt;    /* right edge during last RTT */
-                __u32   beg_snd_una;    /* left edge  during last RTT */
-                __u32   beg_snd_cwnd;   /* saves the size of the cwnd */
-                __u8    doing_vegas_now;/* if true, do vegas for this RTT */
-                __u16   cntRTT;         /* # of RTTs measured within last RTT */
-                __u32   minRTT;         /* min of RTTs measured within last RTT (in usec) */
-                __u32   baseRTT;        /* the min of all Vegas RTT measurements seen (in usec) */
-        } vegas;
-        /* BI TCP Parameters */
-        struct {
-                __u32   cnt;            /* increase cwnd by 1 after this number of ACKs */
-                __u32   last_max_cwnd;  /* last maximium snd_cwnd */
-                __u32   last_cwnd;      /* the last snd_cwnd */
-                __u32   last_stamp;     /* time when updated last_cwnd */
-        } bictcp;
 };
 static inline struct tcp_sock *tcp_sk(const struct sock *sk)
@@ -439,6 +406,11 @@ static inline struct tcp_sock *tcp_sk(const struct sock *sk)
        return (struct tcp_sock *)sk;
 }
+static inline void *tcp_ca(const struct tcp_sock *tp)
+{
+        return (void *) tp->ca_priv;
+}
 #endif
 #endif  /* _LINUX_TCP_H */
diff --git a/include/linux/tcp_diag.h b/include/linux/tcp_diag.h
index ceee962e1d15..7a5996743946 100644
--- a/include/linux/tcp_diag.h
+++ b/include/linux/tcp_diag.h
@@ -99,9 +99,10 @@ enum
        TCPDIAG_MEMINFO,
        TCPDIAG_INFO,
        TCPDIAG_VEGASINFO,
+        TCPDIAG_CONG,
 };
-#define TCPDIAG_MAX TCPDIAG_VEGASINFO
+#define TCPDIAG_MAX TCPDIAG_CONG
 /* TCPDIAG_MEM */
@@ -123,5 +124,4 @@ struct tcpvegas_info {
        __u32   tcpv_minrtt;
 };
 #endif /* _TCP_DIAG_H_ */
diff --git a/include/linux/textsearch.h b/include/linux/textsearch.h
new file mode 100644
index 000000000000..941f45ac117a
--- /dev/null
+++ b/include/linux/textsearch.h
@@ -0,0 +1,180 @@
+#ifndef __LINUX_TEXTSEARCH_H
+#define __LINUX_TEXTSEARCH_H
+#ifdef __KERNEL__
+#include <linux/types.h>
+#include <linux/list.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/err.h>
+struct ts_config;
+/**
+ * TS_AUTOLOAD - Automatically load textsearch modules when needed
+ */
+#define TS_AUTOLOAD     1
+/**
+ * struct ts_state - search state
+ * @offset: offset for next match
+ * @cb: control buffer, for persistant variables of get_next_block()
+ */
+struct ts_state
+{
+        unsigned int            offset;
+        char                    cb[40];
+};
+/**
+ * struct ts_ops - search module operations
+ * @name: name of search algorithm
+ * @init: initialization function to prepare a search
+ * @find: find the next occurrence of the pattern
+ * @destroy: destroy algorithm specific parts of a search configuration
+ * @get_pattern: return head of pattern
+ * @get_pattern_len: return length of pattern
+ * @owner: module reference to algorithm
+ */
+struct ts_ops
+{
+        const char              *name;
+        struct ts_config *      (*init)(const void *, unsigned int, int);
+        unsigned int            (*find)(struct ts_config *,
+                                        struct ts_state *);
+        void                    (*destroy)(struct ts_config *);
+        void *                  (*get_pattern)(struct ts_config *);
+        unsigned int            (*get_pattern_len)(struct ts_config *);
+        struct module           *owner;
+        struct list_head        list;
+};
+/**
+ * struct ts_config - search configuration
+ * @ops: operations of chosen algorithm
+ * @get_next_block: callback to fetch the next block to search in
+ * @finish: callback to finalize a search
+ */
+struct ts_config
+{
+        struct ts_ops           *ops;
+        /**
+         * get_next_block - fetch next block of data
+         * @consumed: number of bytes consumed by the caller
+         * @dst: destination buffer
+         * @conf: search configuration
+         * @state: search state
+         *
+         * Called repeatedly until 0 is returned. Must assign the
+         * head of the next block of data to &*dst and return the length
+         * of the block or 0 if at the end. consumed == 0 indicates
+         * a new search. May store/read persistant values in state->cb.
+         */
+        unsigned int            (*get_next_block)(unsigned int consumed,
+                                                  const u8 **dst,
+                                                  struct ts_config *conf,
+                                                  struct ts_state *state);
+        /**
+         * finish - finalize/clean a series of get_next_block() calls
+         * @conf: search configuration
+         * @state: search state
+         *
+         * Called after the last use of get_next_block(), may be used
+         * to cleanup any leftovers.
+         */
+        void                    (*finish)(struct ts_config *conf,
+                                          struct ts_state *state);
+};
+/**
+ * textsearch_next - continue searching for a pattern
+ * @conf: search configuration
+ * @state: search state
+ *
+ * Continues a search looking for more occurrences of the pattern.
+ * textsearch_find() must be called to find the first occurrence
+ * in order to reset the state.
+ *
+ * Returns the position of the next occurrence of the pattern or
+ * UINT_MAX if not match was found.
+ */ 
+static inline unsigned int textsearch_next(struct ts_config *conf,
+                                           struct ts_state *state)
+{
+        unsigned int ret = conf->ops->find(conf, state);
+        if (conf->finish)
+                conf->finish(conf, state);
+        return ret;
+}
+/**
+ * textsearch_find - start searching for a pattern
+ * @conf: search configuration
+ * @state: search state
+ *
+ * Returns the position of first occurrence of the pattern or
+ * UINT_MAX if no match was found.
+ */ 
+static inline unsigned int textsearch_find(struct ts_config *conf,
+                                           struct ts_state *state)
+{
+        state->offset = 0;
+        return textsearch_next(conf, state);
+}
+/**
+ * textsearch_get_pattern - return head of the pattern
+ * @conf: search configuration
+ */
+static inline void *textsearch_get_pattern(struct ts_config *conf)
+{
+        return conf->ops->get_pattern(conf);
+}
+/**
+ * textsearch_get_pattern_len - return length of the pattern
+ * @conf: search configuration
+ */
+static inline unsigned int textsearch_get_pattern_len(struct ts_config *conf)
+{
+        return conf->ops->get_pattern_len(conf);
+}
+extern int textsearch_register(struct ts_ops *);
+extern int textsearch_unregister(struct ts_ops *);
+extern struct ts_config *textsearch_prepare(const char *, const void *,
+                                            unsigned int, int, int);
+extern void textsearch_destroy(struct ts_config *conf);
+extern unsigned int textsearch_find_continuous(struct ts_config *,
+                                               struct ts_state *,
+                                               const void *, unsigned int);
+#define TS_PRIV_ALIGNTO 8
+#define TS_PRIV_ALIGN(len) (((len) + TS_PRIV_ALIGNTO-1) & ~(TS_PRIV_ALIGNTO-1))
+static inline struct ts_config *alloc_ts_config(size_t payload, int gfp_mask)
+{
+        struct ts_config *conf;
+        conf = kmalloc(TS_PRIV_ALIGN(sizeof(*conf)) + payload, gfp_mask);
+        if (conf == NULL)
+                return ERR_PTR(-ENOMEM);
+        memset(conf, 0, TS_PRIV_ALIGN(sizeof(*conf)) + payload);
+        return conf;
+}
+static inline void *ts_config_priv(struct ts_config *conf)
+{
+        return ((u8 *) conf + TS_PRIV_ALIGN(sizeof(struct ts_config)));
+}
+#endif /* __KERNEL__ */
+#endif
diff --git a/include/linux/textsearch_fsm.h b/include/linux/textsearch_fsm.h
new file mode 100644
index 000000000000..fdfa078c66e5
--- /dev/null
+++ b/include/linux/textsearch_fsm.h
@@ -0,0 +1,48 @@
+#ifndef __LINUX_TEXTSEARCH_FSM_H
+#define __LINUX_TEXTSEARCH_FSM_H
+#include <linux/types.h>
+enum {
+        TS_FSM_SPECIFIC,        /* specific character */
+        TS_FSM_WILDCARD,        /* any character */
+        TS_FSM_DIGIT,           /* isdigit() */
+        TS_FSM_XDIGIT,          /* isxdigit() */
+        TS_FSM_PRINT,           /* isprint() */
+        TS_FSM_ALPHA,           /* isalpha() */
+        TS_FSM_ALNUM,           /* isalnum() */
+        TS_FSM_ASCII,           /* isascii() */
+        TS_FSM_CNTRL,           /* iscntrl() */
+        TS_FSM_GRAPH,           /* isgraph() */
+        TS_FSM_LOWER,           /* islower() */
+        TS_FSM_UPPER,           /* isupper() */
+        TS_FSM_PUNCT,           /* ispunct() */
+        TS_FSM_SPACE,           /* isspace() */
+        __TS_FSM_TYPE_MAX,
+};
+#define TS_FSM_TYPE_MAX (__TS_FSM_TYPE_MAX - 1)
+enum {
+        TS_FSM_SINGLE,          /* 1 occurrence */
+        TS_FSM_PERHAPS,         /* 1 or 0 occurrence */
+        TS_FSM_ANY,             /* 0..n occurrences */
+        TS_FSM_MULTI,           /* 1..n occurrences */
+        TS_FSM_HEAD_IGNORE,     /* 0..n ignored occurrences at head */
+        __TS_FSM_RECUR_MAX,
+};
+#define TS_FSM_RECUR_MAX (__TS_FSM_RECUR_MAX - 1)
+/**
+ * struct ts_fsm_token - state machine token (state)
+ * @type: type of token
+ * @recur: number of recurrences
+ * @value: character value for TS_FSM_SPECIFIC
+ */
+struct ts_fsm_token
+{
+        __u16           type;
+        __u8            recur;
+        __u8            value;
+};
+#endif
diff --git a/include/linux/timer.h b/include/linux/timer.h
index 90db1cc62ddd..221f81ac2002 100644
--- a/include/linux/timer.h
+++ b/include/linux/timer.h
@@ -6,45 +6,33 @@
 #include <linux/spinlock.h>
 #include <linux/stddef.h>
-struct tvec_t_base_s;
+struct timer_base_s;
 struct timer_list {
        struct list_head entry;
        unsigned long expires;
-        spinlock_t lock;
        unsigned long magic;
        void (*function)(unsigned long);
        unsigned long data;
-        struct tvec_t_base_s *base;
+        struct timer_base_s *base;
 };
 #define TIMER_MAGIC     0x4b87ad6e
+extern struct timer_base_s __init_timer_base;
 #define TIMER_INITIALIZER(_function, _expires, _data) {         \
                .function = (_function),                        \
                .expires = (_expires),                          \
                .data = (_data),                                \
-                .base = NULL,                                   \
+                .base = &__init_timer_base,                     \
                .magic = TIMER_MAGIC,                           \
-                .lock = SPIN_LOCK_UNLOCKED,                     \
        }
-/***
+void fastcall init_timer(struct timer_list * timer);
- * init_timer - initialize a timer.
- * @timer: the timer to be initialized
- *
- * init_timer() must be done to a timer prior calling *any* of the
- * other timer functions.
- */
-static inline void init_timer(struct timer_list * timer)
-{
-        timer->base = NULL;
-        timer->magic = TIMER_MAGIC;
-        spin_lock_init(&timer->lock);
-}
 /***
 * timer_pending - is a timer pending?
@@ -58,7 +46,7 @@ static inline void init_timer(struct timer_list * timer)
 */
 static inline int timer_pending(const struct timer_list * timer)
 {
-        return timer->base != NULL;
+        return timer->entry.next != NULL;
 }
 extern void add_timer_on(struct timer_list *timer, int cpu);
@@ -88,13 +76,15 @@ static inline void add_timer(struct timer_list * timer)
 }
 #ifdef CONFIG_SMP
+  extern int try_to_del_timer_sync(struct timer_list *timer);
  extern int del_timer_sync(struct timer_list *timer);
-  extern int del_singleshot_timer_sync(struct timer_list *timer);
 #else
-# define del_timer_sync(t) del_timer(t)
+# define try_to_del_timer_sync(t)       del_timer(t)
-# define del_singleshot_timer_sync(t) del_timer(t)
+# define del_timer_sync(t)              del_timer(t)
 #endif
+#define del_singleshot_timer_sync(t) del_timer_sync(t)
 extern void init_timers(void);
 extern void run_local_timers(void);
 extern void it_real_fn(unsigned long);
diff --git a/include/linux/topology.h b/include/linux/topology.h
index d70e8972c67f..0320225e96da 100644
--- a/include/linux/topology.h
+++ b/include/linux/topology.h
@@ -89,6 +89,11 @@
        .cache_hot_time         = 0,                    \
        .cache_nice_tries       = 0,                    \
        .per_cpu_gain           = 25,                   \
+        .busy_idx               = 0,                    \
+        .idle_idx               = 0,                    \
+        .newidle_idx            = 1,                    \
+        .wake_idx               = 0,                    \
+        .forkexec_idx           = 0,                    \
        .flags                  = SD_LOAD_BALANCE       \
                                | SD_BALANCE_NEWIDLE    \
                                | SD_BALANCE_EXEC       \
@@ -115,12 +120,15 @@
        .cache_hot_time         = (5*1000000/2),        \
        .cache_nice_tries       = 1,                    \
        .per_cpu_gain           = 100,                  \
+        .busy_idx               = 2,                    \
+        .idle_idx               = 1,                    \
+        .newidle_idx            = 2,                    \
+        .wake_idx               = 1,                    \
+        .forkexec_idx           = 1,                    \
        .flags                  = SD_LOAD_BALANCE       \
                                | SD_BALANCE_NEWIDLE    \
                                | SD_BALANCE_EXEC       \
-                                | SD_WAKE_AFFINE        \
+                                | SD_WAKE_AFFINE,       \
-                                | SD_WAKE_IDLE          \
-                                | SD_WAKE_BALANCE,      \
        .last_balance           = jiffies,              \
        .balance_interval       = 1,                    \
        .nr_balance_failed      = 0,                    \
diff --git a/include/linux/tty.h b/include/linux/tty.h
index 1b76106272d3..59ff42c629ec 100644
--- a/include/linux/tty.h
+++ b/include/linux/tty.h
@@ -345,6 +345,7 @@ extern int tty_check_change(struct tty_struct * tty);
 extern void stop_tty(struct tty_struct * tty);
 extern void start_tty(struct tty_struct * tty);
 extern int tty_register_ldisc(int disc, struct tty_ldisc *new_ldisc);
+extern int tty_unregister_ldisc(int disc);
 extern int tty_register_driver(struct tty_driver *driver);
 extern int tty_unregister_driver(struct tty_driver *driver);
 extern void tty_register_device(struct tty_driver *driver, unsigned index, struct device *dev);
diff --git a/include/linux/uinput.h b/include/linux/uinput.h
index 4c2c82336d10..84876077027f 100644
--- a/include/linux/uinput.h
+++ b/include/linux/uinput.h
@@ -42,8 +42,7 @@ struct uinput_request {
        int                     code;   /* UI_FF_UPLOAD, UI_FF_ERASE */
        int                     retval;
-        wait_queue_head_t       waitq;
+        struct completion       done;
-        int                     completed;
        union {
                int             effect_id;
@@ -62,7 +61,7 @@ struct uinput_device {
        struct uinput_request   *requests[UINPUT_NUM_REQUESTS];
        wait_queue_head_t       requests_waitq;
-        struct semaphore        requests_sem;
+        spinlock_t              requests_lock;
 };
 #endif  /* __KERNEL__ */
diff --git a/include/linux/usb.h b/include/linux/usb.h
index 3d508bf08402..724637792996 100644
--- a/include/linux/usb.h
+++ b/include/linux/usb.h
@@ -290,7 +290,7 @@ struct usb_bus {
        struct class_device *class_dev; /* class device for this bus */
        struct kref kref;               /* handles reference counting this bus */
        void (*release)(struct usb_bus *bus);   /* function to destroy this bus's memory */
-#if defined(CONFIG_USB_MON) || defined(CONFIG_USB_MON_MODULE)
+#if defined(CONFIG_USB_MON)
        struct mon_bus *mon_bus;        /* non-null when associated */
        int monitored;                  /* non-zero when monitored */
 #endif
@@ -938,17 +938,17 @@ static inline void usb_fill_int_urb (struct urb *urb,
 }
 extern void usb_init_urb(struct urb *urb);
-extern struct urb *usb_alloc_urb(int iso_packets, int mem_flags);
+extern struct urb *usb_alloc_urb(int iso_packets, unsigned mem_flags);
 extern void usb_free_urb(struct urb *urb);
 #define usb_put_urb usb_free_urb
 extern struct urb *usb_get_urb(struct urb *urb);
-extern int usb_submit_urb(struct urb *urb, int mem_flags);
+extern int usb_submit_urb(struct urb *urb, unsigned mem_flags);
 extern int usb_unlink_urb(struct urb *urb);
 extern void usb_kill_urb(struct urb *urb);
 #define HAVE_USB_BUFFERS
 void *usb_buffer_alloc (struct usb_device *dev, size_t size,
-        int mem_flags, dma_addr_t *dma);
+        unsigned mem_flags, dma_addr_t *dma);
 void usb_buffer_free (struct usb_device *dev, size_t size,
        void *addr, dma_addr_t dma);
@@ -1055,7 +1055,7 @@ int usb_sg_init (
        struct scatterlist      *sg,
        int                     nents,
        size_t                  length,
-        int                     mem_flags
+        unsigned                mem_flags
 );
 void usb_sg_cancel (struct usb_sg_request *io);
 void usb_sg_wait (struct usb_sg_request *io);
diff --git a/include/linux/usb_cdc.h b/include/linux/usb_cdc.h
index f22d6beecc73..ba617c372455 100644
--- a/include/linux/usb_cdc.h
+++ b/include/linux/usb_cdc.h
@@ -34,6 +34,7 @@
 #define USB_CDC_ACM_TYPE                0x02            /* acm_descriptor */
 #define USB_CDC_UNION_TYPE              0x06            /* union_desc */
 #define USB_CDC_COUNTRY_TYPE            0x07
+#define USB_CDC_NETWORK_TERMINAL_TYPE   0x0a            /* network_terminal_desc */
 #define USB_CDC_ETHERNET_TYPE           0x0f            /* ether_desc */
 #define USB_CDC_WHCM_TYPE               0x11
 #define USB_CDC_MDLM_TYPE               0x12            /* mdlm_desc */
@@ -83,6 +84,18 @@ struct usb_cdc_union_desc {
        /* ... and there could be other slave interfaces */
 } __attribute__ ((packed));
+/* "Network Channel Terminal Functional Descriptor" from CDC spec 5.2.3.11 */
+struct usb_cdc_network_terminal_desc {
+        __u8    bLength;
+        __u8    bDescriptorType;
+        __u8    bDescriptorSubType;
+        __u8    bEntityId;
+        __u8    iName;
+        __u8    bChannelIndex;
+        __u8    bPhysicalInterface;
+} __attribute__ ((packed));
 /* "Ethernet Networking Functional Descriptor" from CDC spec 5.2.3.16 */
 struct usb_cdc_ether_desc {
        __u8    bLength;
diff --git a/include/linux/usb_ch9.h b/include/linux/usb_ch9.h
index f5fe94e09a03..ee21e6bf3867 100644
--- a/include/linux/usb_ch9.h
+++ b/include/linux/usb_ch9.h
@@ -6,17 +6,20 @@
 *
 * - the master/host side Linux-USB kernel driver API;
 * - the "usbfs" user space API; and
- * - (eventually) a Linux "gadget" slave/device side driver API.
+ * - the Linux "gadget" slave/device/peripheral side driver API.
 *
 * USB 2.0 adds an additional "On The Go" (OTG) mode, which lets systems
 * act either as a USB master/host or as a USB slave/device.  That means
- * the master and slave side APIs will benefit from working well together.
+ * the master and slave side APIs benefit from working well together.
+ *
+ * There's also "Wireless USB", using low power short range radios for
+ * peripheral interconnection but otherwise building on the USB framework.
 */
 #ifndef __LINUX_USB_CH9_H
 #define __LINUX_USB_CH9_H
-#include <asm/types.h>          /* __u8 etc */
+#include <linux/types.h>        /* __u8 etc */
 /*-------------------------------------------------------------------------*/
@@ -68,6 +71,18 @@
 #define USB_REQ_SET_INTERFACE           0x0B
 #define USB_REQ_SYNCH_FRAME             0x0C
+#define USB_REQ_SET_ENCRYPTION          0x0D    /* Wireless USB */
+#define USB_REQ_GET_ENCRYPTION          0x0E
+#define USB_REQ_SET_HANDSHAKE           0x0F
+#define USB_REQ_GET_HANDSHAKE           0x10
+#define USB_REQ_SET_CONNECTION          0x11
+#define USB_REQ_SET_SECURITY_DATA       0x12
+#define USB_REQ_GET_SECURITY_DATA       0x13
+#define USB_REQ_SET_WUSB_DATA           0x14
+#define USB_REQ_LOOPBACK_DATA_WRITE     0x15
+#define USB_REQ_LOOPBACK_DATA_READ      0x16
+#define USB_REQ_SET_INTERFACE_DS        0x17
 /*
 * USB feature flags are written using USB_REQ_{CLEAR,SET}_FEATURE, and
 * are read as a bit array returned by USB_REQ_GET_STATUS.  (So there
@@ -75,10 +90,12 @@
 */
 #define USB_DEVICE_SELF_POWERED         0       /* (read only) */
 #define USB_DEVICE_REMOTE_WAKEUP        1       /* dev may initiate wakeup */
-#define USB_DEVICE_TEST_MODE            2       /* (high speed only) */
+#define USB_DEVICE_TEST_MODE            2       /* (wired high speed only) */
-#define USB_DEVICE_B_HNP_ENABLE         3       /* dev may initiate HNP */
+#define USB_DEVICE_BATTERY              2       /* (wireless) */
-#define USB_DEVICE_A_HNP_SUPPORT        4       /* RH port supports HNP */
+#define USB_DEVICE_B_HNP_ENABLE         3       /* (otg) dev may initiate HNP */
-#define USB_DEVICE_A_ALT_HNP_SUPPORT    5       /* other RH port does */
+#define USB_DEVICE_WUSB_DEVICE          3       /* (wireless)*/
+#define USB_DEVICE_A_HNP_SUPPORT        4       /* (otg) RH port supports HNP */
+#define USB_DEVICE_A_ALT_HNP_SUPPORT    5       /* (otg) other RH port does */
 #define USB_DEVICE_DEBUG_MODE           6       /* (special devices only) */
 #define USB_ENDPOINT_HALT               0       /* IN/OUT will STALL */
@@ -135,6 +152,13 @@ struct usb_ctrlrequest {
 #define USB_DT_OTG                      0x09
 #define USB_DT_DEBUG                    0x0a
 #define USB_DT_INTERFACE_ASSOCIATION    0x0b
+/* these are from the Wireless USB spec */
+#define USB_DT_SECURITY                 0x0c
+#define USB_DT_KEY                      0x0d
+#define USB_DT_ENCRYPTION_TYPE          0x0e
+#define USB_DT_BOS                      0x0f
+#define USB_DT_DEVICE_CAPABILITY        0x10
+#define USB_DT_WIRELESS_ENDPOINT_COMP   0x11
 /* conventional codes for class-specific descriptors */
 #define USB_DT_CS_DEVICE                0x21
@@ -192,6 +216,7 @@ struct usb_device_descriptor {
 #define USB_CLASS_CSCID                 0x0b    /* chip+ smart card */
 #define USB_CLASS_CONTENT_SEC           0x0d    /* content security */
 #define USB_CLASS_VIDEO                 0x0e
+#define USB_CLASS_WIRELESS_CONTROLLER   0xe0
 #define USB_CLASS_APP_SPEC              0xfe
 #define USB_CLASS_VENDOR_SPEC           0xff
@@ -223,6 +248,7 @@ struct usb_config_descriptor {
 #define USB_CONFIG_ATT_ONE              (1 << 7)        /* must be set */
 #define USB_CONFIG_ATT_SELFPOWER        (1 << 6)        /* self powered */
 #define USB_CONFIG_ATT_WAKEUP           (1 << 5)        /* can wakeup */
+#define USB_CONFIG_ATT_BATTERY          (1 << 4)        /* battery powered */
 /*-------------------------------------------------------------------------*/
@@ -268,8 +294,8 @@ struct usb_endpoint_descriptor {
        __le16 wMaxPacketSize;
        __u8  bInterval;
-        // NOTE:  these two are _only_ in audio endpoints.
+        /* NOTE:  these two are _only_ in audio endpoints. */
-        // use USB_DT_ENDPOINT*_SIZE in bLength, not sizeof.
+        /* use USB_DT_ENDPOINT*_SIZE in bLength, not sizeof. */
        __u8  bRefresh;
        __u8  bSynchAddress;
 } __attribute__ ((packed));
@@ -289,6 +315,7 @@ struct usb_endpoint_descriptor {
 #define USB_ENDPOINT_XFER_ISOC          1
 #define USB_ENDPOINT_XFER_BULK          2
 #define USB_ENDPOINT_XFER_INT           3
+#define USB_ENDPOINT_MAX_ADJUSTABLE     0x80
 /*-------------------------------------------------------------------------*/
@@ -352,12 +379,154 @@ struct usb_interface_assoc_descriptor {
 /*-------------------------------------------------------------------------*/
+/* USB_DT_SECURITY:  group of wireless security descriptors, including
+ * encryption types available for setting up a CC/association.
+ */
+struct usb_security_descriptor {
+        __u8  bLength;
+        __u8  bDescriptorType;
+        __le16 wTotalLength;
+        __u8  bNumEncryptionTypes;
+};
+/*-------------------------------------------------------------------------*/
+/* USB_DT_KEY:  used with {GET,SET}_SECURITY_DATA; only public keys
+ * may be retrieved.
+ */
+struct usb_key_descriptor {
+        __u8  bLength;
+        __u8  bDescriptorType;
+        __u8  tTKID[3];
+        __u8  bReserved;
+        __u8  bKeyData[0];
+};
+/*-------------------------------------------------------------------------*/
+/* USB_DT_ENCRYPTION_TYPE:  bundled in DT_SECURITY groups */
+struct usb_encryption_descriptor {
+        __u8  bLength;
+        __u8  bDescriptorType;
+        __u8  bEncryptionType;
+#define USB_ENC_TYPE_UNSECURE           0
+#define USB_ENC_TYPE_WIRED              1       /* non-wireless mode */
+#define USB_ENC_TYPE_CCM_1              2       /* aes128/cbc session */
+#define USB_ENC_TYPE_RSA_1              3       /* rsa3072/sha1 auth */
+        __u8  bEncryptionValue;         /* use in SET_ENCRYPTION */
+        __u8  bAuthKeyIndex;
+};
+/*-------------------------------------------------------------------------*/
+/* USB_DT_BOS:  group of wireless capabilities */
+struct usb_bos_descriptor {
+        __u8  bLength;
+        __u8  bDescriptorType;
+        __le16 wTotalLength;
+        __u8  bNumDeviceCaps;
+};
+/*-------------------------------------------------------------------------*/
+/* USB_DT_DEVICE_CAPABILITY:  grouped with BOS */
+struct usb_dev_cap_header {
+        __u8  bLength;
+        __u8  bDescriptorType;
+        __u8  bDevCapabilityType;
+};
+#define USB_CAP_TYPE_WIRELESS_USB       1
+struct usb_wireless_cap_descriptor {    /* Ultra Wide Band */
+        __u8  bLength;
+        __u8  bDescriptorType;
+        __u8  bDevCapabilityType;
+        __u8  bmAttributes;
+#define USB_WIRELESS_P2P_DRD            (1 << 1)
+#define USB_WIRELESS_BEACON_MASK        (3 << 2)
+#define USB_WIRELESS_BEACON_SELF        (1 << 2)
+#define USB_WIRELESS_BEACON_DIRECTED    (2 << 2)
+#define USB_WIRELESS_BEACON_NONE        (3 << 2)
+        __le16 wPHYRates;       /* bit rates, Mbps */
+#define USB_WIRELESS_PHY_53             (1 << 0)        /* always set */
+#define USB_WIRELESS_PHY_80             (1 << 1)
+#define USB_WIRELESS_PHY_107            (1 << 2)        /* always set */
+#define USB_WIRELESS_PHY_160            (1 << 3)
+#define USB_WIRELESS_PHY_200            (1 << 4)        /* always set */
+#define USB_WIRELESS_PHY_320            (1 << 5)
+#define USB_WIRELESS_PHY_400            (1 << 6)
+#define USB_WIRELESS_PHY_480            (1 << 7)
+        __u8  bmTFITXPowerInfo; /* TFI power levels */
+        __u8  bmFFITXPowerInfo; /* FFI power levels */
+        __le16 bmBandGroup;
+        __u8  bReserved;
+};
+/*-------------------------------------------------------------------------*/
+/* USB_DT_WIRELESS_ENDPOINT_COMP:  companion descriptor associated with
+ * each endpoint descriptor for a wireless device
+ */
+struct usb_wireless_ep_comp_descriptor {
+        __u8  bLength;
+        __u8  bDescriptorType;
+        __u8  bMaxBurst;
+        __u8  bMaxSequence;
+        __le16 wMaxStreamDelay;
+        __le16 wOverTheAirPacketSize;
+        __u8  bOverTheAirInterval;
+        __u8  bmCompAttributes;
+#define USB_ENDPOINT_SWITCH_MASK        0x03    /* in bmCompAttributes */
+#define USB_ENDPOINT_SWITCH_NO          0
+#define USB_ENDPOINT_SWITCH_SWITCH      1
+#define USB_ENDPOINT_SWITCH_SCALE       2
+};
+/*-------------------------------------------------------------------------*/
+/* USB_REQ_SET_HANDSHAKE is a four-way handshake used between a wireless
+ * host and a device for connection set up, mutual authentication, and
+ * exchanging short lived session keys.  The handshake depends on a CC.
+ */
+struct usb_handshake {
+        __u8 bMessageNumber;
+        __u8 bStatus;
+        __u8 tTKID[3];
+        __u8 bReserved;
+        __u8 CDID[16];
+        __u8 nonce[16];
+        __u8 MIC[8];
+};
+/*-------------------------------------------------------------------------*/
+/* USB_REQ_SET_CONNECTION modifies or revokes a connection context (CC).
+ * A CC may also be set up using non-wireless secure channels (including
+ * wired USB!), and some devices may support CCs with multiple hosts.
+ */
+struct usb_connection_context {
+        __u8 CHID[16];          /* persistent host id */
+        __u8 CDID[16];          /* device id (unique w/in host context) */
+        __u8 CK[16];            /* connection key */
+};
+/*-------------------------------------------------------------------------*/
 /* USB 2.0 defines three speeds, here's how Linux identifies them */
 enum usb_device_speed {
        USB_SPEED_UNKNOWN = 0,                  /* enumerating */
        USB_SPEED_LOW, USB_SPEED_FULL,          /* usb 1.1 */
-        USB_SPEED_HIGH                          /* usb 2.0 */
+        USB_SPEED_HIGH,                         /* usb 2.0 */
+        USB_SPEED_VARIABLE,                     /* wireless (usb 2.5) */
 };
 enum usb_device_state {
diff --git a/include/linux/usb_gadget.h b/include/linux/usb_gadget.h
index 9bba9997947b..71e608607324 100644
--- a/include/linux/usb_gadget.h
+++ b/include/linux/usb_gadget.h
@@ -107,18 +107,18 @@ struct usb_ep_ops {
        int (*disable) (struct usb_ep *ep);
        struct usb_request *(*alloc_request) (struct usb_ep *ep,
-                int gfp_flags);
+                unsigned gfp_flags);
        void (*free_request) (struct usb_ep *ep, struct usb_request *req);
        void *(*alloc_buffer) (struct usb_ep *ep, unsigned bytes,
-                dma_addr_t *dma, int gfp_flags);
+                dma_addr_t *dma, unsigned gfp_flags);
        void (*free_buffer) (struct usb_ep *ep, void *buf, dma_addr_t dma,
                unsigned bytes);
        // NOTE:  on 2.6, drivers may also use dma_map() and
        // dma_sync_single_*() to directly manage dma overhead. 
        int (*queue) (struct usb_ep *ep, struct usb_request *req,
-                int gfp_flags);
+                unsigned gfp_flags);
        int (*dequeue) (struct usb_ep *ep, struct usb_request *req);
        int (*set_halt) (struct usb_ep *ep, int value);
@@ -214,7 +214,7 @@ usb_ep_disable (struct usb_ep *ep)
 * Returns the request, or null if one could not be allocated.
 */
 static inline struct usb_request *
-usb_ep_alloc_request (struct usb_ep *ep, int gfp_flags)
+usb_ep_alloc_request (struct usb_ep *ep, unsigned gfp_flags)
 {
        return ep->ops->alloc_request (ep, gfp_flags);
 }
@@ -254,7 +254,7 @@ usb_ep_free_request (struct usb_ep *ep, struct usb_request *req)
 */
 static inline void *
 usb_ep_alloc_buffer (struct usb_ep *ep, unsigned len, dma_addr_t *dma,
-        int gfp_flags)
+        unsigned gfp_flags)
 {
        return ep->ops->alloc_buffer (ep, len, dma, gfp_flags);
 }
@@ -330,7 +330,7 @@ usb_ep_free_buffer (struct usb_ep *ep, void *buf, dma_addr_t dma, unsigned len)
 * reported when the usb peripheral is disconnected.
 */
 static inline int
-usb_ep_queue (struct usb_ep *ep, struct usb_request *req, int gfp_flags)
+usb_ep_queue (struct usb_ep *ep, struct usb_request *req, unsigned gfp_flags)
 {
        return ep->ops->queue (ep, req, gfp_flags);
 }
@@ -711,7 +711,7 @@ usb_gadget_disconnect (struct usb_gadget *gadget)
 *      the hardware level driver. Most calls must be handled by
 *      the gadget driver, including descriptor and configuration
 *      management.  The 16 bit members of the setup data are in
- *      cpu order. Called in_interrupt; this may not sleep.  Driver
+ *      USB byte order. Called in_interrupt; this may not sleep.  Driver
 *      queues a response to ep0, or returns negative to stall.
 * @disconnect: Invoked after all transfers have been stopped,
 *      when the host is disconnected.  May be called in_interrupt; this
diff --git a/include/linux/usb_input.h b/include/linux/usb_input.h
new file mode 100644
index 000000000000..716e0cc16043
--- /dev/null
+++ b/include/linux/usb_input.h
@@ -0,0 +1,25 @@
+#ifndef __USB_INPUT_H
+#define __USB_INPUT_H
+/*
+ * Copyright (C) 2005 Dmitry Torokhov
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 as published by
+ * the Free Software Foundation.
+ */
+#include <linux/usb.h>
+#include <linux/input.h>
+#include <asm/byteorder.h>
+static inline void
+usb_to_input_id(const struct usb_device *dev, struct input_id *id)
+{
+        id->bustype = BUS_USB;
+        id->vendor = le16_to_cpu(dev->descriptor.idVendor);
+        id->product = le16_to_cpu(dev->descriptor.idProduct);
+        id->version = le16_to_cpu(dev->descriptor.bcdDevice);
+}
+#endif
diff --git a/include/linux/usb_isp116x.h b/include/linux/usb_isp116x.h
new file mode 100644
index 000000000000..5f5a9d9bd6c2
--- /dev/null
+++ b/include/linux/usb_isp116x.h
@@ -0,0 +1,47 @@
+/*
+ * Board initialization code should put one of these into dev->platform_data
+ * and place the isp116x onto platform_bus.
+ */
+struct isp116x_platform_data {
+        /* Enable internal resistors on downstream ports */
+        unsigned sel15Kres:1;
+        /* Chip's internal clock won't be stopped in suspended state.
+           Setting/unsetting this bit takes effect only if
+           'remote_wakeup_enable' below is not set. */
+        unsigned clknotstop:1;
+        /* On-chip overcurrent protection */
+        unsigned oc_enable:1;
+        /* INT output polarity */
+        unsigned int_act_high:1;
+        /* INT edge or level triggered */
+        unsigned int_edge_triggered:1;
+        /* WAKEUP pin connected - NOT SUPPORTED  */
+        /* unsigned remote_wakeup_connected:1; */
+        /* Wakeup by devices on usb bus enabled */
+        unsigned remote_wakeup_enable:1;
+        /* Switch or not to switch (keep always powered) */
+        unsigned no_power_switching:1;
+        /* Ganged port power switching (0) or individual port
+           power switching (1) */
+        unsigned power_switching_mode:1;
+        /* Given port_power, msec/2 after power on till power good */
+        u8 potpg;
+        /* Hardware reset set/clear. If implemented, this function must:
+           if set == 0,   deassert chip's HW reset pin
+           otherwise,     assert chip's HW reset pin       */
+        void (*reset) (struct device * dev, int set);
+        /* Hardware clock start/stop. If implemented, this function must:
+           if start == 0,    stop the external clock
+           otherwise,        start the external clock
+         */
+        void (*clock) (struct device * dev, int start);
+        /* Inter-io delay (ns). The chip is picky about access timings; it
+           expects at least:
+           150ns delay between consecutive accesses to DATA_REG,
+           300ns delay between access to ADDR_REG and DATA_REG
+           OE, WE MUST NOT be changed during these intervals
+         */
+        void (*delay) (struct device * dev, int delay);
+};
diff --git a/include/linux/videodev2.h b/include/linux/videodev2.h
index 4e0edce53760..acbfc525576d 100644
--- a/include/linux/videodev2.h
+++ b/include/linux/videodev2.h
@@ -221,6 +221,8 @@ struct v4l2_pix_format
 /*  Vendor-specific formats   */
 #define V4L2_PIX_FMT_WNVA     v4l2_fourcc('W','N','V','A') /* Winnov hw compress */
 #define V4L2_PIX_FMT_SN9C10X  v4l2_fourcc('S','9','1','0') /* SN9C10x compression */
+#define V4L2_PIX_FMT_PWC1     v4l2_fourcc('P','W','C','1') /* pwc older webcam */
+#define V4L2_PIX_FMT_PWC2     v4l2_fourcc('P','W','C','2') /* pwc newer webcam */
 /*
 *      F O R M A T   E N U M E R A T I O N
diff --git a/include/linux/wait.h b/include/linux/wait.h
index c9486c3efb4a..d38c9fecdc36 100644
--- a/include/linux/wait.h
+++ b/include/linux/wait.h
@@ -33,7 +33,7 @@ int default_wake_function(wait_queue_t *wait, unsigned mode, int sync, void *key
 struct __wait_queue {
        unsigned int flags;
 #define WQ_FLAG_EXCLUSIVE       0x01
-        struct task_struct * task;
+        void *private;
        wait_queue_func_t func;
        struct list_head task_list;
 };
@@ -60,7 +60,7 @@ typedef struct __wait_queue_head wait_queue_head_t;
 */
 #define __WAITQUEUE_INITIALIZER(name, tsk) {                            \
-        .task           = tsk,                                          \
+        .private        = tsk,                                          \
        .func           = default_wake_function,                        \
        .task_list      = { NULL, NULL } }
@@ -86,7 +86,7 @@ static inline void init_waitqueue_head(wait_queue_head_t *q)
 static inline void init_waitqueue_entry(wait_queue_t *q, struct task_struct *p)
 {
        q->flags = 0;
-        q->task = p;
+        q->private = p;
        q->func = default_wake_function;
 }
@@ -94,7 +94,7 @@ static inline void init_waitqueue_func_entry(wait_queue_t *q,
                                        wait_queue_func_t func)
 {
        q->flags = 0;
-        q->task = NULL;
+        q->private = NULL;
        q->func = func;
 }
@@ -110,7 +110,7 @@ static inline int waitqueue_active(wait_queue_head_t *q)
 * aio specifies a wait queue entry with an async notification
 * callback routine, not associated with any task.
 */
-#define is_sync_wait(wait)      (!(wait) || ((wait)->task))
+#define is_sync_wait(wait)      (!(wait) || ((wait)->private))
 extern void FASTCALL(add_wait_queue(wait_queue_head_t *q, wait_queue_t * wait));
 extern void FASTCALL(add_wait_queue_exclusive(wait_queue_head_t *q, wait_queue_t * wait));
@@ -384,7 +384,7 @@ int wake_bit_function(wait_queue_t *wait, unsigned mode, int sync, void *key);
 #define DEFINE_WAIT(name)                                               \
        wait_queue_t name = {                                           \
-                .task           = current,                              \
+                .private        = current,                              \
                .func           = autoremove_wake_function,             \
                .task_list      = LIST_HEAD_INIT((name).task_list),     \
        }
@@ -393,7 +393,7 @@ int wake_bit_function(wait_queue_t *wait, unsigned mode, int sync, void *key);
        struct wait_bit_queue name = {                                  \
                .key = __WAIT_BIT_KEY_INITIALIZER(word, bit),           \
                .wait   = {                                             \
-                        .task           = current,                      \
+                        .private        = current,                      \
                        .func           = wake_bit_function,            \
                        .task_list      =                               \
                                LIST_HEAD_INIT((name).wait.task_list),  \
@@ -402,7 +402,7 @@ int wake_bit_function(wait_queue_t *wait, unsigned mode, int sync, void *key);
 #define init_wait(wait)                                                 \
        do {                                                            \
-                (wait)->task = current;                                 \
+                (wait)->private = current;                              \
                (wait)->func = autoremove_wake_function;                \
                INIT_LIST_HEAD(&(wait)->task_list);                     \
        } while (0)
diff --git a/include/linux/wanrouter.h b/include/linux/wanrouter.h
index 3e89f0f15f49..1b6b76a4eb54 100644
--- a/include/linux/wanrouter.h
+++ b/include/linux/wanrouter.h
@@ -516,8 +516,7 @@ struct wan_device {
 /* Public functions available for device drivers */
 extern int register_wan_device(struct wan_device *wandev);
 extern int unregister_wan_device(char *name);
-unsigned short wanrouter_type_trans(struct sk_buff *skb,
+__be16 wanrouter_type_trans(struct sk_buff *skb, struct net_device *dev);
-                                    struct net_device *dev);
 int wanrouter_encapsulate(struct sk_buff *skb, struct net_device *dev,
                          unsigned short type);
diff --git a/include/linux/watchdog.h b/include/linux/watchdog.h
index 88ba0d29f8c8..1192ed8f4fe8 100644
--- a/include/linux/watchdog.h
+++ b/include/linux/watchdog.h
@@ -47,4 +47,14 @@ struct watchdog_info {
 #define WDIOS_ENABLECARD        0x0002  /* Turn on the watchdog timer */
 #define WDIOS_TEMPPANIC         0x0004  /* Kernel panic on temperature trip */
+#ifdef __KERNEL__
+#ifdef CONFIG_WATCHDOG_NOWAYOUT
+#define WATCHDOG_NOWAYOUT       1
+#else
+#define WATCHDOG_NOWAYOUT       0
+#endif
+#endif  /* __KERNEL__ */
 #endif  /* ifndef _LINUX_WATCHDOG_H */
diff --git a/include/linux/writeback.h b/include/linux/writeback.h
index 1262cb43c3ab..542dbaee6512 100644
--- a/include/linux/writeback.h
+++ b/include/linux/writeback.h
@@ -14,11 +14,13 @@ extern struct list_head inode_unused;
 * Yes, writeback.h requires sched.h
 * No, sched.h is not included from here.
 */
-static inline int current_is_pdflush(void)
+static inline int task_is_pdflush(struct task_struct *task)
 {
-        return current->flags & PF_FLUSHER;
+        return task->flags & PF_FLUSHER;
 }
+#define current_is_pdflush()    task_is_pdflush(current)
 /*
 * fs/fs-writeback.c
 */
@@ -83,7 +85,7 @@ static inline void wait_on_inode(struct inode *inode)
 /*
 * mm/page-writeback.c
 */
-int wakeup_bdflush(long nr_pages);
+int wakeup_pdflush(long nr_pages);
 void laptop_io_completion(void);
 void laptop_sync_completion(void);
 void throttle_vm_writeout(void);
diff --git a/include/linux/x25.h b/include/linux/x25.h
index 7531cfed5885..16d44931afa0 100644
--- a/include/linux/x25.h
+++ b/include/linux/x25.h
@@ -4,6 +4,8 @@
 *      History
 *      mar/20/00       Daniela Squassoni Disabling/enabling of facilities 
 *                                        negotiation.
+ *      apr/02/05       Shaun Pereira Selective sub address matching with
+ *                                      call user data
 */
 #ifndef X25_KERNEL_H
@@ -16,6 +18,9 @@
 #define SIOCX25GCALLUSERDATA    (SIOCPROTOPRIVATE + 4)
 #define SIOCX25SCALLUSERDATA    (SIOCPROTOPRIVATE + 5)
 #define SIOCX25GCAUSEDIAG       (SIOCPROTOPRIVATE + 6)
+#define SIOCX25SCUDMATCHLEN     (SIOCPROTOPRIVATE + 7)
+#define SIOCX25CALLACCPTAPPRV   (SIOCPROTOPRIVATE + 8)
+#define SIOCX25SENDCALLACCPT    (SIOCPROTOPRIVATE + 9)
 /*
 *      Values for {get,set}sockopt.
@@ -109,4 +114,11 @@ struct x25_causediag {
        unsigned char   diagnostic;
 };
+/*
+ *      Further optional call user data match length selection
+ */
+struct x25_subaddr {
+        unsigned int cudmatchlength;
+};
 #endif
diff --git a/include/linux/xattr_acl.h b/include/linux/xattr_acl.h
deleted file mode 100644
index 7a1f9b93a45f..000000000000
--- a/include/linux/xattr_acl.h
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
-  File: linux/xattr_acl.h
-  (extended attribute representation of access control lists)
-  (C) 2000 Andreas Gruenbacher, <a.gruenbacher@computer.org>
-*/
-#ifndef _LINUX_XATTR_ACL_H
-#define _LINUX_XATTR_ACL_H
-#include <linux/posix_acl.h>
-#define XATTR_NAME_ACL_ACCESS   "system.posix_acl_access"
-#define XATTR_NAME_ACL_DEFAULT  "system.posix_acl_default"
-#define XATTR_ACL_VERSION       0x0002
-typedef struct {
-        __u16           e_tag;
-        __u16           e_perm;
-        __u32           e_id;
-} xattr_acl_entry;
-typedef struct {
-        __u32           a_version;
-        xattr_acl_entry a_entries[0];
-} xattr_acl_header;
-static inline size_t xattr_acl_size(int count)
-{
-        return sizeof(xattr_acl_header) + count * sizeof(xattr_acl_entry);
-}
-static inline int xattr_acl_count(size_t size)
-{
-        if (size < sizeof(xattr_acl_header))
-                return -1;
-        size -= sizeof(xattr_acl_header);
-        if (size % sizeof(xattr_acl_entry))
-                return -1;
-        return size / sizeof(xattr_acl_entry);
-}
-struct posix_acl * posix_acl_from_xattr(const void *value, size_t size);
-int posix_acl_to_xattr(const struct posix_acl *acl, void *buffer, size_t size);
-#endif /* _LINUX_XATTR_ACL_H */
diff --git a/include/linux/zlib.h b/include/linux/zlib.h
index 850076ea14d3..74f7b78c22d2 100644
--- a/include/linux/zlib.h
+++ b/include/linux/zlib.h
@@ -506,6 +506,11 @@ extern int zlib_deflateReset (z_streamp strm);
   stream state was inconsistent (such as zalloc or state being NULL).
 */
+static inline unsigned long deflateBound(unsigned long s)
+{
+        return s + ((s + 7) >> 3) + ((s + 63) >> 6) + 11;
+}
 extern int zlib_deflateParams (z_streamp strm, int level, int strategy);
 /*
     Dynamically update the compression level and compression strategy.  The