Automatic merge with /usr/src/ntfs-2.6.git.

27 files changed, 826 insertions, 201 deletions

diff --git a/fs/Kconfig b/fs/Kconfig
index 8157f2e2d515..062177956239 100644
--- a/fs/Kconfig
+++ b/fs/Kconfig
@@ -734,6 +734,12 @@ config PROC_KCORE
         bool "/proc/kcore support" if !ARM
         depends on PROC_FS && MMU
 
+config PROC_VMCORE
+        bool "/proc/vmcore support (EXPERIMENTAL)"
+        depends on PROC_FS && EMBEDDED && EXPERIMENTAL && CRASH_DUMP
+        help
+        Exports the dump image of crashed kernel in ELF format.
+
 config SYSFS
         bool "sysfs file system support" if EMBEDDED
         default y
diff --git a/fs/afs/kafsasyncd.c b/fs/afs/kafsasyncd.c
index 6fc88ae8ad94..7ac07d0d47b9 100644
--- a/fs/afs/kafsasyncd.c
+++ b/fs/afs/kafsasyncd.c
@@ -116,7 +116,7 @@ static int kafsasyncd(void *arg)
                 remove_wait_queue(&kafsasyncd_sleepq, &myself);
                 set_current_state(TASK_RUNNING);
 
-                try_to_freeze(PF_FREEZE);
+                try_to_freeze();
 
                 /* discard pending signals */
                 afs_discard_my_signals();
diff --git a/fs/afs/kafstimod.c b/fs/afs/kafstimod.c
index 86e710dd057e..65bc05ab8182 100644
--- a/fs/afs/kafstimod.c
+++ b/fs/afs/kafstimod.c
@@ -91,7 +91,7 @@ static int kafstimod(void *arg)
                         complete_and_exit(&kafstimod_dead, 0);
                 }
 
-                try_to_freeze(PF_FREEZE);
+                try_to_freeze();
 
                 /* discard pending signals */
                 afs_discard_my_signals();
diff --git a/fs/dquot.c b/fs/dquot.c
index 37212b039a4a..b9732335bcdc 100644
--- a/fs/dquot.c
+++ b/fs/dquot.c
@@ -409,13 +409,10 @@ out_dqlock:
  * for this sb+type at all. */
 static void invalidate_dquots(struct super_block *sb, int type)
 {
-        struct dquot *dquot;
-        struct list_head *head;
+        struct dquot *dquot, *tmp;
 
         spin_lock(&dq_list_lock);
-        for (head = inuse_list.next; head != &inuse_list;) {
-                dquot = list_entry(head, struct dquot, dq_inuse);
-                head = head->next;
+        list_for_each_entry_safe(dquot, tmp, &inuse_list, dq_inuse) {
                 if (dquot->dq_sb != sb)
                         continue;
                 if (dquot->dq_type != type)
diff --git a/fs/jbd/journal.c b/fs/jbd/journal.c
index 1e6f2e2ad4a3..5e7b43949517 100644
--- a/fs/jbd/journal.c
+++ b/fs/jbd/journal.c
@@ -167,7 +167,7 @@ loop:
         }
 
         wake_up(&journal->j_wait_done_commit);
-        if (current->flags & PF_FREEZE) {
+        if (freezing(current)) {
                 /*
                  * The simpler the better. Flushing journal isn't a
                  * good idea, because that depends on threads that may
@@ -175,7 +175,7 @@ loop:
                  */
                 jbd_debug(1, "Now suspending kjournald\n");
                 spin_unlock(&journal->j_state_lock);
-                refrigerator(PF_FREEZE);
+                refrigerator();
                 spin_lock(&journal->j_state_lock);
         } else {
                 /*
diff --git a/fs/jffs/intrep.c b/fs/jffs/intrep.c
index 8cc6893fc56c..fc589ddd0762 100644
--- a/fs/jffs/intrep.c
+++ b/fs/jffs/intrep.c
@@ -175,8 +175,64 @@ jffs_hexdump(struct mtd_info *mtd, loff_t pos, int size)
         }
 }
 
+/* Print the contents of a node.  */
+static void
+jffs_print_node(struct jffs_node *n)
+{
+        D(printk("jffs_node: 0x%p\n", n));
+        D(printk("{\n"));
+        D(printk("        0x%08x, /* version  */\n", n->version));
+        D(printk("        0x%08x, /* data_offset  */\n", n->data_offset));
+        D(printk("        0x%08x, /* data_size  */\n", n->data_size));
+        D(printk("        0x%08x, /* removed_size  */\n", n->removed_size));
+        D(printk("        0x%08x, /* fm_offset  */\n", n->fm_offset));
+        D(printk("        0x%02x,       /* name_size  */\n", n->name_size));
+        D(printk("        0x%p, /* fm,  fm->offset: %u  */\n",
+                 n->fm, (n->fm ? n->fm->offset : 0)));
+        D(printk("        0x%p, /* version_prev  */\n", n->version_prev));
+        D(printk("        0x%p, /* version_next  */\n", n->version_next));
+        D(printk("        0x%p, /* range_prev  */\n", n->range_prev));
+        D(printk("        0x%p, /* range_next  */\n", n->range_next));
+        D(printk("}\n"));
+}
+
 #endif
 
+/* Print the contents of a raw inode.  */
+static void
+jffs_print_raw_inode(struct jffs_raw_inode *raw_inode)
+{
+        D(printk("jffs_raw_inode: inode number: %u\n", raw_inode->ino));
+        D(printk("{\n"));
+        D(printk("        0x%08x, /* magic  */\n", raw_inode->magic));
+        D(printk("        0x%08x, /* ino  */\n", raw_inode->ino));
+        D(printk("        0x%08x, /* pino  */\n", raw_inode->pino));
+        D(printk("        0x%08x, /* version  */\n", raw_inode->version));
+        D(printk("        0x%08x, /* mode  */\n", raw_inode->mode));
+        D(printk("        0x%04x,     /* uid  */\n", raw_inode->uid));
+        D(printk("        0x%04x,     /* gid  */\n", raw_inode->gid));
+        D(printk("        0x%08x, /* atime  */\n", raw_inode->atime));
+        D(printk("        0x%08x, /* mtime  */\n", raw_inode->mtime));
+        D(printk("        0x%08x, /* ctime  */\n", raw_inode->ctime));
+        D(printk("        0x%08x, /* offset  */\n", raw_inode->offset));
+        D(printk("        0x%08x, /* dsize  */\n", raw_inode->dsize));
+        D(printk("        0x%08x, /* rsize  */\n", raw_inode->rsize));
+        D(printk("        0x%02x,       /* nsize  */\n", raw_inode->nsize));
+        D(printk("        0x%02x,       /* nlink  */\n", raw_inode->nlink));
+        D(printk("        0x%02x,       /* spare  */\n",
+                 raw_inode->spare));
+        D(printk("        %u,          /* rename  */\n",
+                 raw_inode->rename));
+        D(printk("        %u,          /* deleted  */\n",
+                 raw_inode->deleted));
+        D(printk("        0x%02x,       /* accurate  */\n",
+                 raw_inode->accurate));
+        D(printk("        0x%08x, /* dchksum  */\n", raw_inode->dchksum));
+        D(printk("        0x%04x,     /* nchksum  */\n", raw_inode->nchksum));
+        D(printk("        0x%04x,     /* chksum  */\n", raw_inode->chksum));
+        D(printk("}\n"));
+}
+
 #define flash_safe_acquire(arg)
 #define flash_safe_release(arg)
 
@@ -2507,64 +2563,6 @@ jffs_update_file(struct jffs_file *f, struct jffs_node *node)
         return 0;
 }
 
-/* Print the contents of a node.  */
-void
-jffs_print_node(struct jffs_node *n)
-{
-        D(printk("jffs_node: 0x%p\n", n));
-        D(printk("{\n"));
-        D(printk("        0x%08x, /* version  */\n", n->version));
-        D(printk("        0x%08x, /* data_offset  */\n", n->data_offset));
-        D(printk("        0x%08x, /* data_size  */\n", n->data_size));
-        D(printk("        0x%08x, /* removed_size  */\n", n->removed_size));
-        D(printk("        0x%08x, /* fm_offset  */\n", n->fm_offset));
-        D(printk("        0x%02x,       /* name_size  */\n", n->name_size));
-        D(printk("        0x%p, /* fm,  fm->offset: %u  */\n",
-                 n->fm, (n->fm ? n->fm->offset : 0)));
-        D(printk("        0x%p, /* version_prev  */\n", n->version_prev));
-        D(printk("        0x%p, /* version_next  */\n", n->version_next));
-        D(printk("        0x%p, /* range_prev  */\n", n->range_prev));
-        D(printk("        0x%p, /* range_next  */\n", n->range_next));
-        D(printk("}\n"));
-}
-
-
-/* Print the contents of a raw inode.  */
-void
-jffs_print_raw_inode(struct jffs_raw_inode *raw_inode)
-{
-        D(printk("jffs_raw_inode: inode number: %u\n", raw_inode->ino));
-        D(printk("{\n"));
-        D(printk("        0x%08x, /* magic  */\n", raw_inode->magic));
-        D(printk("        0x%08x, /* ino  */\n", raw_inode->ino));
-        D(printk("        0x%08x, /* pino  */\n", raw_inode->pino));
-        D(printk("        0x%08x, /* version  */\n", raw_inode->version));
-        D(printk("        0x%08x, /* mode  */\n", raw_inode->mode));
-        D(printk("        0x%04x,     /* uid  */\n", raw_inode->uid));
-        D(printk("        0x%04x,     /* gid  */\n", raw_inode->gid));
-        D(printk("        0x%08x, /* atime  */\n", raw_inode->atime));
-        D(printk("        0x%08x, /* mtime  */\n", raw_inode->mtime));
-        D(printk("        0x%08x, /* ctime  */\n", raw_inode->ctime));
-        D(printk("        0x%08x, /* offset  */\n", raw_inode->offset));
-        D(printk("        0x%08x, /* dsize  */\n", raw_inode->dsize));
-        D(printk("        0x%08x, /* rsize  */\n", raw_inode->rsize));
-        D(printk("        0x%02x,       /* nsize  */\n", raw_inode->nsize));
-        D(printk("        0x%02x,       /* nlink  */\n", raw_inode->nlink));
-        D(printk("        0x%02x,       /* spare  */\n",
-                 raw_inode->spare));
-        D(printk("        %u,          /* rename  */\n",
-                 raw_inode->rename));
-        D(printk("        %u,          /* deleted  */\n",
-                 raw_inode->deleted));
-        D(printk("        0x%02x,       /* accurate  */\n",
-                 raw_inode->accurate));
-        D(printk("        0x%08x, /* dchksum  */\n", raw_inode->dchksum));
-        D(printk("        0x%04x,     /* nchksum  */\n", raw_inode->nchksum));
-        D(printk("        0x%04x,     /* chksum  */\n", raw_inode->chksum));
-        D(printk("}\n"));
-}
-
-
 /* Print the contents of a file.  */
 #if 0
 int
diff --git a/fs/jffs/intrep.h b/fs/jffs/intrep.h
index 4ae97b17911c..5c7abe0e2695 100644
--- a/fs/jffs/intrep.h
+++ b/fs/jffs/intrep.h
@@ -49,8 +49,6 @@ int jffs_garbage_collect_thread(void *c);
 void jffs_garbage_collect_trigger(struct jffs_control *c);
 
 /* For debugging purposes.  */
-void jffs_print_node(struct jffs_node *n);
-void jffs_print_raw_inode(struct jffs_raw_inode *raw_inode);
 #if 0
 int jffs_print_file(struct jffs_file *f);
 #endif  /*  0  */
diff --git a/fs/jffs/jffs_fm.c b/fs/jffs/jffs_fm.c
index 0cab8da49d3c..053e3a98a276 100644
--- a/fs/jffs/jffs_fm.c
+++ b/fs/jffs/jffs_fm.c
@@ -31,6 +31,60 @@ static void jffs_free_fm(struct jffs_fm *n);
 extern kmem_cache_t     *fm_cache;
 extern kmem_cache_t     *node_cache;
 
+#if CONFIG_JFFS_FS_VERBOSE > 0
+void
+jffs_print_fmcontrol(struct jffs_fmcontrol *fmc)
+{
+        D(printk("struct jffs_fmcontrol: 0x%p\n", fmc));
+        D(printk("{\n"));
+        D(printk("        %u, /* flash_size  */\n", fmc->flash_size));
+        D(printk("        %u, /* used_size  */\n", fmc->used_size));
+        D(printk("        %u, /* dirty_size  */\n", fmc->dirty_size));
+        D(printk("        %u, /* free_size  */\n", fmc->free_size));
+        D(printk("        %u, /* sector_size  */\n", fmc->sector_size));
+        D(printk("        %u, /* min_free_size  */\n", fmc->min_free_size));
+        D(printk("        %u, /* max_chunk_size  */\n", fmc->max_chunk_size));
+        D(printk("        0x%p, /* mtd  */\n", fmc->mtd));
+        D(printk("        0x%p, /* head  */    "
+                 "(head->offset = 0x%08x)\n",
+                 fmc->head, (fmc->head ? fmc->head->offset : 0)));
+        D(printk("        0x%p, /* tail  */    "
+                 "(tail->offset + tail->size = 0x%08x)\n",
+                 fmc->tail,
+                 (fmc->tail ? fmc->tail->offset + fmc->tail->size : 0)));
+        D(printk("        0x%p, /* head_extra  */\n", fmc->head_extra));
+        D(printk("        0x%p, /* tail_extra  */\n", fmc->tail_extra));
+        D(printk("}\n"));
+}
+#endif  /*  CONFIG_JFFS_FS_VERBOSE > 0  */
+
+#if CONFIG_JFFS_FS_VERBOSE > 2
+static void
+jffs_print_fm(struct jffs_fm *fm)
+{
+        D(printk("struct jffs_fm: 0x%p\n", fm));
+        D(printk("{\n"));
+        D(printk("       0x%08x, /* offset  */\n", fm->offset));
+        D(printk("       %u, /* size  */\n", fm->size));
+        D(printk("       0x%p, /* prev  */\n", fm->prev));
+        D(printk("       0x%p, /* next  */\n", fm->next));
+        D(printk("       0x%p, /* nodes  */\n", fm->nodes));
+        D(printk("}\n"));
+}
+#endif  /*  CONFIG_JFFS_FS_VERBOSE > 2  */
+
+#if 0
+void
+jffs_print_node_ref(struct jffs_node_ref *ref)
+{
+        D(printk("struct jffs_node_ref: 0x%p\n", ref));
+        D(printk("{\n"));
+        D(printk("       0x%p, /* node  */\n", ref->node));
+        D(printk("       0x%p, /* next  */\n", ref->next));
+        D(printk("}\n"));
+}
+#endif  /*  0  */
+
 /* This function creates a new shiny flash memory control structure.  */
 struct jffs_fmcontrol *
 jffs_build_begin(struct jffs_control *c, int unit)
@@ -742,54 +796,3 @@ int jffs_get_node_inuse(void)
 {
         return no_jffs_node;
 }
-
-void
-jffs_print_fmcontrol(struct jffs_fmcontrol *fmc)
-{
-        D(printk("struct jffs_fmcontrol: 0x%p\n", fmc));
-        D(printk("{\n"));
-        D(printk("        %u, /* flash_size  */\n", fmc->flash_size));
-        D(printk("        %u, /* used_size  */\n", fmc->used_size));
-        D(printk("        %u, /* dirty_size  */\n", fmc->dirty_size));
-        D(printk("        %u, /* free_size  */\n", fmc->free_size));
-        D(printk("        %u, /* sector_size  */\n", fmc->sector_size));
-        D(printk("        %u, /* min_free_size  */\n", fmc->min_free_size));
-        D(printk("        %u, /* max_chunk_size  */\n", fmc->max_chunk_size));
-        D(printk("        0x%p, /* mtd  */\n", fmc->mtd));
-        D(printk("        0x%p, /* head  */    "
-                 "(head->offset = 0x%08x)\n",
-                 fmc->head, (fmc->head ? fmc->head->offset : 0)));
-        D(printk("        0x%p, /* tail  */    "
-                 "(tail->offset + tail->size = 0x%08x)\n",
-                 fmc->tail,
-                 (fmc->tail ? fmc->tail->offset + fmc->tail->size : 0)));
-        D(printk("        0x%p, /* head_extra  */\n", fmc->head_extra));
-        D(printk("        0x%p, /* tail_extra  */\n", fmc->tail_extra));
-        D(printk("}\n"));
-}
-
-void
-jffs_print_fm(struct jffs_fm *fm)
-{
-        D(printk("struct jffs_fm: 0x%p\n", fm));
-        D(printk("{\n"));
-        D(printk("       0x%08x, /* offset  */\n", fm->offset));
-        D(printk("       %u, /* size  */\n", fm->size));
-        D(printk("       0x%p, /* prev  */\n", fm->prev));
-        D(printk("       0x%p, /* next  */\n", fm->next));
-        D(printk("       0x%p, /* nodes  */\n", fm->nodes));
-        D(printk("}\n"));
-}
-
-#if 0
-void
-jffs_print_node_ref(struct jffs_node_ref *ref)
-{
-        D(printk("struct jffs_node_ref: 0x%p\n", ref));
-        D(printk("{\n"));
-        D(printk("       0x%p, /* node  */\n", ref->node));
-        D(printk("       0x%p, /* next  */\n", ref->next));
-        D(printk("}\n"));
-}
-#endif  /*  0  */
-
diff --git a/fs/jffs/jffs_fm.h b/fs/jffs/jffs_fm.h
index bc291c431822..f64151e74122 100644
--- a/fs/jffs/jffs_fm.h
+++ b/fs/jffs/jffs_fm.h
@@ -139,8 +139,9 @@ int jffs_add_node(struct jffs_node *node);
 void jffs_fmfree_partly(struct jffs_fmcontrol *fmc, struct jffs_fm *fm,
                         __u32 size);
 
+#if CONFIG_JFFS_FS_VERBOSE > 0
 void jffs_print_fmcontrol(struct jffs_fmcontrol *fmc);
-void jffs_print_fm(struct jffs_fm *fm);
+#endif
 #if 0
 void jffs_print_node_ref(struct jffs_node_ref *ref);
 #endif  /*  0  */
diff --git a/fs/jffs2/background.c b/fs/jffs2/background.c
index 1be6de27dd81..638836b277d4 100644
--- a/fs/jffs2/background.c
+++ b/fs/jffs2/background.c
@@ -92,7 +92,7 @@ static int jffs2_garbage_collect_thread(void *_c)
                         schedule();
                 }
 
-                if (try_to_freeze(0))
+                if (try_to_freeze())
                         continue;
 
                 cond_resched();
diff --git a/fs/jfs/jfs_logmgr.c b/fs/jfs/jfs_logmgr.c
index 7c8387ed4192..79d07624bfe1 100644
--- a/fs/jfs/jfs_logmgr.c
+++ b/fs/jfs/jfs_logmgr.c
@@ -2359,9 +2359,9 @@ int jfsIOWait(void *arg)
                         lbmStartIO(bp);
                         spin_lock_irq(&log_redrive_lock);
                 }
-                if (current->flags & PF_FREEZE) {
+                if (freezing(current)) {
                         spin_unlock_irq(&log_redrive_lock);
-                        refrigerator(PF_FREEZE);
+                        refrigerator();
                 } else {
                         add_wait_queue(&jfs_IO_thread_wait, &wq);
                         set_current_state(TASK_INTERRUPTIBLE);
diff --git a/fs/jfs/jfs_txnmgr.c b/fs/jfs/jfs_txnmgr.c
index 8cbaaff1d5fa..121c981ff453 100644
--- a/fs/jfs/jfs_txnmgr.c
+++ b/fs/jfs/jfs_txnmgr.c
@@ -2788,9 +2788,9 @@ int jfs_lazycommit(void *arg)
                 /* In case a wakeup came while all threads were active */
                 jfs_commit_thread_waking = 0;
 
-                if (current->flags & PF_FREEZE) {
+                if (freezing(current)) {
                         LAZY_UNLOCK(flags);
-                        refrigerator(PF_FREEZE);
+                        refrigerator();
                 } else {
                         DECLARE_WAITQUEUE(wq, current);
 
@@ -2987,9 +2987,9 @@ int jfs_sync(void *arg)
                 /* Add anon_list2 back to anon_list */
                 list_splice_init(&TxAnchor.anon_list2, &TxAnchor.anon_list);
 
-                if (current->flags & PF_FREEZE) {
+                if (freezing(current)) {
                         TXN_UNLOCK();
-                        refrigerator(PF_FREEZE);
+                        refrigerator();
                 } else {
                         DECLARE_WAITQUEUE(wq, current);
 
diff --git a/fs/libfs.c b/fs/libfs.c
index 5025563e7379..58101dff2c66 100644
--- a/fs/libfs.c
+++ b/fs/libfs.c
@@ -183,6 +183,7 @@ struct file_operations simple_dir_operations = {
         .llseek         = dcache_dir_lseek,
         .read           = generic_read_dir,
         .readdir        = dcache_readdir,
+        .fsync          = simple_sync_file,
 };
 
 struct inode_operations simple_dir_inode_operations = {
diff --git a/fs/lockd/clntproc.c b/fs/lockd/clntproc.c
index fd77ed1d710d..14b3ce87fa29 100644
--- a/fs/lockd/clntproc.c
+++ b/fs/lockd/clntproc.c
@@ -313,7 +313,7 @@ static int nlm_wait_on_grace(wait_queue_head_t *queue)
         prepare_to_wait(queue, &wait, TASK_INTERRUPTIBLE);
         if (!signalled ()) {
                 schedule_timeout(NLMCLNT_GRACE_WAIT);
-                try_to_freeze(PF_FREEZE);
+                try_to_freeze();
                 if (!signalled ())
                         status = 0;
         }
diff --git a/fs/ncpfs/dir.c b/fs/ncpfs/dir.c
index 2dc2d8693968..a9f7a8ab1d59 100644
--- a/fs/ncpfs/dir.c
+++ b/fs/ncpfs/dir.c
@@ -705,18 +705,6 @@ ncp_do_readdir(struct file *filp, void *dirent, filldir_t filldir,
                 DPRINTK("ncp_do_readdir: init failed, err=%d\n", err);
                 return;
         }
-#ifdef USE_OLD_SLOW_DIRECTORY_LISTING
-        for (;;) {
-                err = ncp_search_for_file_or_subdir(server, &seq, &entry.i);
-                if (err) {
-                        DPRINTK("ncp_do_readdir: search failed, err=%d\n", err);
-                        break;
-                }
-                entry.volume = entry.i.volNumber;
-                if (!ncp_fill_cache(filp, dirent, filldir, ctl, &entry))
-                        break;
-        }
-#else
         /* We MUST NOT use server->buffer_size handshaked with server if we are
            using UDP, as for UDP server uses max. buffer size determined by
            MTU, and for TCP server uses hardwired value 65KB (== 66560 bytes). 
@@ -754,7 +742,6 @@ ncp_do_readdir(struct file *filp, void *dirent, filldir_t filldir,
                 }
         } while (more);
         vfree(buf);
-#endif
         return;
 }
 
diff --git a/fs/ncpfs/ncplib_kernel.c b/fs/ncpfs/ncplib_kernel.c
index e4eb5ed4bee4..c755e1848a42 100644
--- a/fs/ncpfs/ncplib_kernel.c
+++ b/fs/ncpfs/ncplib_kernel.c
@@ -845,46 +845,6 @@ out:
         return result;
 }
 
-/* Search for everything */
-int ncp_search_for_file_or_subdir(struct ncp_server *server,
-                                  struct nw_search_sequence *seq,
-                                  struct nw_info_struct *target)
-{
-        int result;
-
-        ncp_init_request(server);
-        ncp_add_byte(server, 3);        /* subfunction */
-        ncp_add_byte(server, server->name_space[seq->volNumber]);
-        ncp_add_byte(server, 0);        /* data stream (???) */
-        ncp_add_word(server, cpu_to_le16(0x8006));      /* Search attribs */
-        ncp_add_dword(server, RIM_ALL);         /* return info mask */
-        ncp_add_mem(server, seq, 9);
-#ifdef CONFIG_NCPFS_NFS_NS
-        if (server->name_space[seq->volNumber] == NW_NS_NFS) {
-                ncp_add_byte(server, 0);        /* 0 byte pattern */
-        } else 
-#endif
-        {
-                ncp_add_byte(server, 2);        /* 2 byte pattern */
-                ncp_add_byte(server, 0xff);     /* following is a wildcard */
-                ncp_add_byte(server, '*');
-        }
-        
-        if ((result = ncp_request(server, 87)) != 0)
-                goto out;
-        memcpy(seq, ncp_reply_data(server, 0), sizeof(*seq));
-        ncp_extract_file_info(ncp_reply_data(server, 10), target);
-
-        ncp_unlock_server(server);
-        
-        result = ncp_obtain_nfs_info(server, target);
-        return result;
-
-out:
-        ncp_unlock_server(server);
-        return result;
-}
-
 int ncp_search_for_fileset(struct ncp_server *server,
                            struct nw_search_sequence *seq,
                            int* more,
diff --git a/fs/ncpfs/ncplib_kernel.h b/fs/ncpfs/ncplib_kernel.h
index 05ec2e9d90c6..9e4dc30c2435 100644
--- a/fs/ncpfs/ncplib_kernel.h
+++ b/fs/ncpfs/ncplib_kernel.h
@@ -87,9 +87,6 @@ int ncp_open_create_file_or_subdir(struct ncp_server *, struct inode *, char *,
 
 int ncp_initialize_search(struct ncp_server *, struct inode *,
                       struct nw_search_sequence *target);
-int ncp_search_for_file_or_subdir(struct ncp_server *server,
-                              struct nw_search_sequence *seq,
-                              struct nw_info_struct *target);
 int ncp_search_for_fileset(struct ncp_server *server,
                            struct nw_search_sequence *seq,
                            int* more, int* cnt,
diff --git a/fs/partitions/Makefile b/fs/partitions/Makefile
index 4c83c17969e1..66d5cc26fafb 100644
--- a/fs/partitions/Makefile
+++ b/fs/partitions/Makefile
@@ -17,4 +17,3 @@ obj-$(CONFIG_SUN_PARTITION) += sun.o
 obj-$(CONFIG_ULTRIX_PARTITION) += ultrix.o
 obj-$(CONFIG_IBM_PARTITION) += ibm.o
 obj-$(CONFIG_EFI_PARTITION) += efi.o
-obj-$(CONFIG_NEC98_PARTITION) += nec98.o msdos.o
diff --git a/fs/partitions/check.c b/fs/partitions/check.c
index 2cab98a9a621..77e178f13162 100644
--- a/fs/partitions/check.c
+++ b/fs/partitions/check.c
@@ -79,9 +79,6 @@ static int (*check_part[])(struct parsed_partitions *, struct block_device *) =
 #ifdef CONFIG_LDM_PARTITION
         ldm_partition,          /* this must come before msdos */
 #endif
-#ifdef CONFIG_NEC98_PARTITION
-        nec98_partition,        /* must be come before `msdos_partition' */
-#endif
 #ifdef CONFIG_MSDOS_PARTITION
         msdos_partition,
 #endif
diff --git a/fs/partitions/check.h b/fs/partitions/check.h
index 43adcc68e471..17ae8ecd9e8b 100644
--- a/fs/partitions/check.h
+++ b/fs/partitions/check.h
@@ -30,7 +30,3 @@ put_partition(struct parsed_partitions *p, int n, sector_t from, sector_t size)
 
 extern int warn_no_part;
 
-extern void parse_bsd(struct parsed_partitions *state,
-                        struct block_device *bdev, u32 offset, u32 size,
-                        int origin, char *flavour, int max_partitions);
-
diff --git a/fs/partitions/msdos.c b/fs/partitions/msdos.c
index 584a27b2bbd5..9935d254186e 100644
--- a/fs/partitions/msdos.c
+++ b/fs/partitions/msdos.c
@@ -202,12 +202,12 @@ parse_solaris_x86(struct parsed_partitions *state, struct block_device *bdev,
 #endif
 }
 
-#if defined(CONFIG_BSD_DISKLABEL) || defined(CONFIG_NEC98_PARTITION)
+#if defined(CONFIG_BSD_DISKLABEL)
 /* 
  * Create devices for BSD partitions listed in a disklabel, under a
  * dos-like partition. See parse_extended() for more information.
  */
-void
+static void
 parse_bsd(struct parsed_partitions *state, struct block_device *bdev,
                 u32 offset, u32 size, int origin, char *flavour,
                 int max_partitions)
diff --git a/fs/proc/Makefile b/fs/proc/Makefile
index 738b9b602932..7431d7ba2d09 100644
--- a/fs/proc/Makefile
+++ b/fs/proc/Makefile
@@ -11,4 +11,5 @@ proc-y       += inode.o root.o base.o generic.o array.o \
                 kmsg.o proc_tty.o proc_misc.o
 
 proc-$(CONFIG_PROC_KCORE)       += kcore.o
+proc-$(CONFIG_PROC_VMCORE)      += vmcore.o
 proc-$(CONFIG_PROC_DEVICETREE)  += proc_devtree.o
diff --git a/fs/proc/proc_misc.c b/fs/proc/proc_misc.c
index 94b570ad037d..a3453555a94e 100644
--- a/fs/proc/proc_misc.c
+++ b/fs/proc/proc_misc.c
@@ -44,6 +44,7 @@
 #include <linux/jiffies.h>
 #include <linux/sysrq.h>
 #include <linux/vmalloc.h>
+#include <linux/crash_dump.h>
 #include <asm/uaccess.h>
 #include <asm/pgtable.h>
 #include <asm/io.h>
@@ -618,6 +619,11 @@ void __init proc_misc_init(void)
                                 (size_t)high_memory - PAGE_OFFSET + PAGE_SIZE;
         }
 #endif
+#ifdef CONFIG_PROC_VMCORE
+        proc_vmcore = create_proc_entry("vmcore", S_IRUSR, NULL);
+        if (proc_vmcore)
+                proc_vmcore->proc_fops = &proc_vmcore_operations;
+#endif
 #ifdef CONFIG_MAGIC_SYSRQ
         entry = create_proc_entry("sysrq-trigger", S_IWUSR, NULL);
         if (entry)
diff --git a/fs/proc/vmcore.c b/fs/proc/vmcore.c
new file mode 100644
index 000000000000..3b2e7b69e63a
--- /dev/null
+++ b/fs/proc/vmcore.c
@@ -0,0 +1,669 @@
+/*
+ *      fs/proc/vmcore.c Interface for accessing the crash
+ *                               dump from the system's previous life.
+ *      Heavily borrowed from fs/proc/kcore.c
+ *      Created by: Hariprasad Nellitheertha (hari@in.ibm.com)
+ *      Copyright (C) IBM Corporation, 2004. All rights reserved
+ *
+ */
+
+#include <linux/config.h>
+#include <linux/mm.h>
+#include <linux/proc_fs.h>
+#include <linux/user.h>
+#include <linux/a.out.h>
+#include <linux/elf.h>
+#include <linux/elfcore.h>
+#include <linux/proc_fs.h>
+#include <linux/highmem.h>
+#include <linux/bootmem.h>
+#include <linux/init.h>
+#include <linux/crash_dump.h>
+#include <linux/list.h>
+#include <asm/uaccess.h>
+#include <asm/io.h>
+
+/* List representing chunks of contiguous memory areas and their offsets in
+ * vmcore file.
+ */
+static LIST_HEAD(vmcore_list);
+
+/* Stores the pointer to the buffer containing kernel elf core headers. */
+static char *elfcorebuf;
+static size_t elfcorebuf_sz;
+
+/* Total size of vmcore file. */
+static u64 vmcore_size;
+
+struct proc_dir_entry *proc_vmcore = NULL;
+
+/* Reads a page from the oldmem device from given offset. */
+static ssize_t read_from_oldmem(char *buf, size_t count,
+                             loff_t *ppos, int userbuf)
+{
+        unsigned long pfn, offset;
+        size_t nr_bytes;
+        ssize_t read = 0, tmp;
+
+        if (!count)
+                return 0;
+
+        offset = (unsigned long)(*ppos % PAGE_SIZE);
+        pfn = (unsigned long)(*ppos / PAGE_SIZE);
+        if (pfn > saved_max_pfn)
+                return -EINVAL;
+
+        do {
+                if (count > (PAGE_SIZE - offset))
+                        nr_bytes = PAGE_SIZE - offset;
+                else
+                        nr_bytes = count;
+
+                tmp = copy_oldmem_page(pfn, buf, nr_bytes, offset, userbuf);
+                if (tmp < 0)
+                        return tmp;
+                *ppos += nr_bytes;
+                count -= nr_bytes;
+                buf += nr_bytes;
+                read += nr_bytes;
+                ++pfn;
+                offset = 0;
+        } while (count);
+
+        return read;
+}
+
+/* Maps vmcore file offset to respective physical address in memroy. */
+static u64 map_offset_to_paddr(loff_t offset, struct list_head *vc_list,
+                                        struct vmcore **m_ptr)
+{
+        struct vmcore *m;
+        u64 paddr;
+
+        list_for_each_entry(m, vc_list, list) {
+                u64 start, end;
+                start = m->offset;
+                end = m->offset + m->size - 1;
+                if (offset >= start && offset <= end) {
+                        paddr = m->paddr + offset - start;
+                        *m_ptr = m;
+                        return paddr;
+                }
+        }
+        *m_ptr = NULL;
+        return 0;
+}
+
+/* Read from the ELF header and then the crash dump. On error, negative value is
+ * returned otherwise number of bytes read are returned.
+ */
+static ssize_t read_vmcore(struct file *file, char __user *buffer,
+                                size_t buflen, loff_t *fpos)
+{
+        ssize_t acc = 0, tmp;
+        size_t tsz, nr_bytes;
+        u64 start;
+        struct vmcore *curr_m = NULL;
+
+        if (buflen == 0 || *fpos >= vmcore_size)
+                return 0;
+
+        /* trim buflen to not go beyond EOF */
+        if (buflen > vmcore_size - *fpos)
+                buflen = vmcore_size - *fpos;
+
+        /* Read ELF core header */
+        if (*fpos < elfcorebuf_sz) {
+                tsz = elfcorebuf_sz - *fpos;
+                if (buflen < tsz)
+                        tsz = buflen;
+                if (copy_to_user(buffer, elfcorebuf + *fpos, tsz))
+                        return -EFAULT;
+                buflen -= tsz;
+                *fpos += tsz;
+                buffer += tsz;
+                acc += tsz;
+
+                /* leave now if filled buffer already */
+                if (buflen == 0)
+                        return acc;
+        }
+
+        start = map_offset_to_paddr(*fpos, &vmcore_list, &curr_m);
+        if (!curr_m)
+                return -EINVAL;
+        if ((tsz = (PAGE_SIZE - (start & ~PAGE_MASK))) > buflen)
+                tsz = buflen;
+
+        /* Calculate left bytes in current memory segment. */
+        nr_bytes = (curr_m->size - (start - curr_m->paddr));
+        if (tsz > nr_bytes)
+                tsz = nr_bytes;
+
+        while (buflen) {
+                tmp = read_from_oldmem(buffer, tsz, &start, 1);
+                if (tmp < 0)
+                        return tmp;
+                buflen -= tsz;
+                *fpos += tsz;
+                buffer += tsz;
+                acc += tsz;
+                if (start >= (curr_m->paddr + curr_m->size)) {
+                        if (curr_m->list.next == &vmcore_list)
+                                return acc;     /*EOF*/
+                        curr_m = list_entry(curr_m->list.next,
+                                                struct vmcore, list);
+                        start = curr_m->paddr;
+                }
+                if ((tsz = (PAGE_SIZE - (start & ~PAGE_MASK))) > buflen)
+                        tsz = buflen;
+                /* Calculate left bytes in current memory segment. */
+                nr_bytes = (curr_m->size - (start - curr_m->paddr));
+                if (tsz > nr_bytes)
+                        tsz = nr_bytes;
+        }
+        return acc;
+}
+
+static int open_vmcore(struct inode *inode, struct file *filp)
+{
+        return 0;
+}
+
+struct file_operations proc_vmcore_operations = {
+        .read           = read_vmcore,
+        .open           = open_vmcore,
+};
+
+static struct vmcore* __init get_new_element(void)
+{
+        struct vmcore *p;
+
+        p = kmalloc(sizeof(*p), GFP_KERNEL);
+        if (p)
+                memset(p, 0, sizeof(*p));
+        return p;
+}
+
+static u64 __init get_vmcore_size_elf64(char *elfptr)
+{
+        int i;
+        u64 size;
+        Elf64_Ehdr *ehdr_ptr;
+        Elf64_Phdr *phdr_ptr;
+
+        ehdr_ptr = (Elf64_Ehdr *)elfptr;
+        phdr_ptr = (Elf64_Phdr*)(elfptr + sizeof(Elf64_Ehdr));
+        size = sizeof(Elf64_Ehdr) + ((ehdr_ptr->e_phnum) * sizeof(Elf64_Phdr));
+        for (i = 0; i < ehdr_ptr->e_phnum; i++) {
+                size += phdr_ptr->p_memsz;
+                phdr_ptr++;
+        }
+        return size;
+}
+
+static u64 __init get_vmcore_size_elf32(char *elfptr)
+{
+        int i;
+        u64 size;
+        Elf32_Ehdr *ehdr_ptr;
+        Elf32_Phdr *phdr_ptr;
+
+        ehdr_ptr = (Elf32_Ehdr *)elfptr;
+        phdr_ptr = (Elf32_Phdr*)(elfptr + sizeof(Elf32_Ehdr));
+        size = sizeof(Elf32_Ehdr) + ((ehdr_ptr->e_phnum) * sizeof(Elf32_Phdr));
+        for (i = 0; i < ehdr_ptr->e_phnum; i++) {
+                size += phdr_ptr->p_memsz;
+                phdr_ptr++;
+        }
+        return size;
+}
+
+/* Merges all the PT_NOTE headers into one. */
+static int __init merge_note_headers_elf64(char *elfptr, size_t *elfsz,
+                                                struct list_head *vc_list)
+{
+        int i, nr_ptnote=0, rc=0;
+        char *tmp;
+        Elf64_Ehdr *ehdr_ptr;
+        Elf64_Phdr phdr, *phdr_ptr;
+        Elf64_Nhdr *nhdr_ptr;
+        u64 phdr_sz = 0, note_off;
+
+        ehdr_ptr = (Elf64_Ehdr *)elfptr;
+        phdr_ptr = (Elf64_Phdr*)(elfptr + sizeof(Elf64_Ehdr));
+        for (i = 0; i < ehdr_ptr->e_phnum; i++, phdr_ptr++) {
+                int j;
+                void *notes_section;
+                struct vmcore *new;
+                u64 offset, max_sz, sz, real_sz = 0;
+                if (phdr_ptr->p_type != PT_NOTE)
+                        continue;
+                nr_ptnote++;
+                max_sz = phdr_ptr->p_memsz;
+                offset = phdr_ptr->p_offset;
+                notes_section = kmalloc(max_sz, GFP_KERNEL);
+                if (!notes_section)
+                        return -ENOMEM;
+                rc = read_from_oldmem(notes_section, max_sz, &offset, 0);
+                if (rc < 0) {
+                        kfree(notes_section);
+                        return rc;
+                }
+                nhdr_ptr = notes_section;
+                for (j = 0; j < max_sz; j += sz) {
+                        if (nhdr_ptr->n_namesz == 0)
+                                break;
+                        sz = sizeof(Elf64_Nhdr) +
+                                ((nhdr_ptr->n_namesz + 3) & ~3) +
+                                ((nhdr_ptr->n_descsz + 3) & ~3);
+                        real_sz += sz;
+                        nhdr_ptr = (Elf64_Nhdr*)((char*)nhdr_ptr + sz);
+                }
+
+                /* Add this contiguous chunk of notes section to vmcore list.*/
+                new = get_new_element();
+                if (!new) {
+                        kfree(notes_section);
+                        return -ENOMEM;
+                }
+                new->paddr = phdr_ptr->p_offset;
+                new->size = real_sz;
+                list_add_tail(&new->list, vc_list);
+                phdr_sz += real_sz;
+                kfree(notes_section);
+        }
+
+        /* Prepare merged PT_NOTE program header. */
+        phdr.p_type    = PT_NOTE;
+        phdr.p_flags   = 0;
+        note_off = sizeof(Elf64_Ehdr) +
+                        (ehdr_ptr->e_phnum - nr_ptnote +1) * sizeof(Elf64_Phdr);
+        phdr.p_offset  = note_off;
+        phdr.p_vaddr   = phdr.p_paddr = 0;
+        phdr.p_filesz  = phdr.p_memsz = phdr_sz;
+        phdr.p_align   = 0;
+
+        /* Add merged PT_NOTE program header*/
+        tmp = elfptr + sizeof(Elf64_Ehdr);
+        memcpy(tmp, &phdr, sizeof(phdr));
+        tmp += sizeof(phdr);
+
+        /* Remove unwanted PT_NOTE program headers. */
+        i = (nr_ptnote - 1) * sizeof(Elf64_Phdr);
+        *elfsz = *elfsz - i;
+        memmove(tmp, tmp+i, ((*elfsz)-sizeof(Elf64_Ehdr)-sizeof(Elf64_Phdr)));
+
+        /* Modify e_phnum to reflect merged headers. */
+        ehdr_ptr->e_phnum = ehdr_ptr->e_phnum - nr_ptnote + 1;
+
+        return 0;
+}
+
+/* Merges all the PT_NOTE headers into one. */
+static int __init merge_note_headers_elf32(char *elfptr, size_t *elfsz,
+                                                struct list_head *vc_list)
+{
+        int i, nr_ptnote=0, rc=0;
+        char *tmp;
+        Elf32_Ehdr *ehdr_ptr;
+        Elf32_Phdr phdr, *phdr_ptr;
+        Elf32_Nhdr *nhdr_ptr;
+        u64 phdr_sz = 0, note_off;
+
+        ehdr_ptr = (Elf32_Ehdr *)elfptr;
+        phdr_ptr = (Elf32_Phdr*)(elfptr + sizeof(Elf32_Ehdr));
+        for (i = 0; i < ehdr_ptr->e_phnum; i++, phdr_ptr++) {
+                int j;
+                void *notes_section;
+                struct vmcore *new;
+                u64 offset, max_sz, sz, real_sz = 0;
+                if (phdr_ptr->p_type != PT_NOTE)
+                        continue;
+                nr_ptnote++;
+                max_sz = phdr_ptr->p_memsz;
+                offset = phdr_ptr->p_offset;
+                notes_section = kmalloc(max_sz, GFP_KERNEL);
+                if (!notes_section)
+                        return -ENOMEM;
+                rc = read_from_oldmem(notes_section, max_sz, &offset, 0);
+                if (rc < 0) {
+                        kfree(notes_section);
+                        return rc;
+                }
+                nhdr_ptr = notes_section;
+                for (j = 0; j < max_sz; j += sz) {
+                        if (nhdr_ptr->n_namesz == 0)
+                                break;
+                        sz = sizeof(Elf32_Nhdr) +
+                                ((nhdr_ptr->n_namesz + 3) & ~3) +
+                                ((nhdr_ptr->n_descsz + 3) & ~3);
+                        real_sz += sz;
+                        nhdr_ptr = (Elf32_Nhdr*)((char*)nhdr_ptr + sz);
+                }
+
+                /* Add this contiguous chunk of notes section to vmcore list.*/
+                new = get_new_element();
+                if (!new) {
+                        kfree(notes_section);
+                        return -ENOMEM;
+                }
+                new->paddr = phdr_ptr->p_offset;
+                new->size = real_sz;
+                list_add_tail(&new->list, vc_list);
+                phdr_sz += real_sz;
+                kfree(notes_section);
+        }
+
+        /* Prepare merged PT_NOTE program header. */
+        phdr.p_type    = PT_NOTE;
+        phdr.p_flags   = 0;
+        note_off = sizeof(Elf32_Ehdr) +
+                        (ehdr_ptr->e_phnum - nr_ptnote +1) * sizeof(Elf32_Phdr);
+        phdr.p_offset  = note_off;
+        phdr.p_vaddr   = phdr.p_paddr = 0;
+        phdr.p_filesz  = phdr.p_memsz = phdr_sz;
+        phdr.p_align   = 0;
+
+        /* Add merged PT_NOTE program header*/
+        tmp = elfptr + sizeof(Elf32_Ehdr);
+        memcpy(tmp, &phdr, sizeof(phdr));
+        tmp += sizeof(phdr);
+
+        /* Remove unwanted PT_NOTE program headers. */
+        i = (nr_ptnote - 1) * sizeof(Elf32_Phdr);
+        *elfsz = *elfsz - i;
+        memmove(tmp, tmp+i, ((*elfsz)-sizeof(Elf32_Ehdr)-sizeof(Elf32_Phdr)));
+
+        /* Modify e_phnum to reflect merged headers. */
+        ehdr_ptr->e_phnum = ehdr_ptr->e_phnum - nr_ptnote + 1;
+
+        return 0;
+}
+
+/* Add memory chunks represented by program headers to vmcore list. Also update
+ * the new offset fields of exported program headers. */
+static int __init process_ptload_program_headers_elf64(char *elfptr,
+                                                size_t elfsz,
+                                                struct list_head *vc_list)
+{
+        int i;
+        Elf64_Ehdr *ehdr_ptr;
+        Elf64_Phdr *phdr_ptr;
+        loff_t vmcore_off;
+        struct vmcore *new;
+
+        ehdr_ptr = (Elf64_Ehdr *)elfptr;
+        phdr_ptr = (Elf64_Phdr*)(elfptr + sizeof(Elf64_Ehdr)); /* PT_NOTE hdr */
+
+        /* First program header is PT_NOTE header. */
+        vmcore_off = sizeof(Elf64_Ehdr) +
+                        (ehdr_ptr->e_phnum) * sizeof(Elf64_Phdr) +
+                        phdr_ptr->p_memsz; /* Note sections */
+
+        for (i = 0; i < ehdr_ptr->e_phnum; i++, phdr_ptr++) {
+                if (phdr_ptr->p_type != PT_LOAD)
+                        continue;
+
+                /* Add this contiguous chunk of memory to vmcore list.*/
+                new = get_new_element();
+                if (!new)
+                        return -ENOMEM;
+                new->paddr = phdr_ptr->p_offset;
+                new->size = phdr_ptr->p_memsz;
+                list_add_tail(&new->list, vc_list);
+
+                /* Update the program header offset. */
+                phdr_ptr->p_offset = vmcore_off;
+                vmcore_off = vmcore_off + phdr_ptr->p_memsz;
+        }
+        return 0;
+}
+
+static int __init process_ptload_program_headers_elf32(char *elfptr,
+                                                size_t elfsz,
+                                                struct list_head *vc_list)
+{
+        int i;
+        Elf32_Ehdr *ehdr_ptr;
+        Elf32_Phdr *phdr_ptr;
+        loff_t vmcore_off;
+        struct vmcore *new;
+
+        ehdr_ptr = (Elf32_Ehdr *)elfptr;
+        phdr_ptr = (Elf32_Phdr*)(elfptr + sizeof(Elf32_Ehdr)); /* PT_NOTE hdr */
+
+        /* First program header is PT_NOTE header. */
+        vmcore_off = sizeof(Elf32_Ehdr) +
+                        (ehdr_ptr->e_phnum) * sizeof(Elf32_Phdr) +
+                        phdr_ptr->p_memsz; /* Note sections */
+
+        for (i = 0; i < ehdr_ptr->e_phnum; i++, phdr_ptr++) {
+                if (phdr_ptr->p_type != PT_LOAD)
+                        continue;
+
+                /* Add this contiguous chunk of memory to vmcore list.*/
+                new = get_new_element();
+                if (!new)
+                        return -ENOMEM;
+                new->paddr = phdr_ptr->p_offset;
+                new->size = phdr_ptr->p_memsz;
+                list_add_tail(&new->list, vc_list);
+
+                /* Update the program header offset */
+                phdr_ptr->p_offset = vmcore_off;
+                vmcore_off = vmcore_off + phdr_ptr->p_memsz;
+        }
+        return 0;
+}
+
+/* Sets offset fields of vmcore elements. */
+static void __init set_vmcore_list_offsets_elf64(char *elfptr,
+                                                struct list_head *vc_list)
+{
+        loff_t vmcore_off;
+        Elf64_Ehdr *ehdr_ptr;
+        struct vmcore *m;
+
+        ehdr_ptr = (Elf64_Ehdr *)elfptr;
+
+        /* Skip Elf header and program headers. */
+        vmcore_off = sizeof(Elf64_Ehdr) +
+                        (ehdr_ptr->e_phnum) * sizeof(Elf64_Phdr);
+
+        list_for_each_entry(m, vc_list, list) {
+                m->offset = vmcore_off;
+                vmcore_off += m->size;
+        }
+}
+
+/* Sets offset fields of vmcore elements. */
+static void __init set_vmcore_list_offsets_elf32(char *elfptr,
+                                                struct list_head *vc_list)
+{
+        loff_t vmcore_off;
+        Elf32_Ehdr *ehdr_ptr;
+        struct vmcore *m;
+
+        ehdr_ptr = (Elf32_Ehdr *)elfptr;
+
+        /* Skip Elf header and program headers. */
+        vmcore_off = sizeof(Elf32_Ehdr) +
+                        (ehdr_ptr->e_phnum) * sizeof(Elf32_Phdr);
+
+        list_for_each_entry(m, vc_list, list) {
+                m->offset = vmcore_off;
+                vmcore_off += m->size;
+        }
+}
+
+static int __init parse_crash_elf64_headers(void)
+{
+        int rc=0;
+        Elf64_Ehdr ehdr;
+        u64 addr;
+
+        addr = elfcorehdr_addr;
+
+        /* Read Elf header */
+        rc = read_from_oldmem((char*)&ehdr, sizeof(Elf64_Ehdr), &addr, 0);
+        if (rc < 0)
+                return rc;
+
+        /* Do some basic Verification. */
+        if (memcmp(ehdr.e_ident, ELFMAG, SELFMAG) != 0 ||
+                (ehdr.e_type != ET_CORE) ||
+                !elf_check_arch(&ehdr) ||
+                ehdr.e_ident[EI_CLASS] != ELFCLASS64 ||
+                ehdr.e_ident[EI_VERSION] != EV_CURRENT ||
+                ehdr.e_version != EV_CURRENT ||
+                ehdr.e_ehsize != sizeof(Elf64_Ehdr) ||
+                ehdr.e_phentsize != sizeof(Elf64_Phdr) ||
+                ehdr.e_phnum == 0) {
+                printk(KERN_WARNING "Warning: Core image elf header is not"
+                                        "sane\n");
+                return -EINVAL;
+        }
+
+        /* Read in all elf headers. */
+        elfcorebuf_sz = sizeof(Elf64_Ehdr) + ehdr.e_phnum * sizeof(Elf64_Phdr);
+        elfcorebuf = kmalloc(elfcorebuf_sz, GFP_KERNEL);
+        if (!elfcorebuf)
+                return -ENOMEM;
+        addr = elfcorehdr_addr;
+        rc = read_from_oldmem(elfcorebuf, elfcorebuf_sz, &addr, 0);
+        if (rc < 0) {
+                kfree(elfcorebuf);
+                return rc;
+        }
+
+        /* Merge all PT_NOTE headers into one. */
+        rc = merge_note_headers_elf64(elfcorebuf, &elfcorebuf_sz, &vmcore_list);
+        if (rc) {
+                kfree(elfcorebuf);
+                return rc;
+        }
+        rc = process_ptload_program_headers_elf64(elfcorebuf, elfcorebuf_sz,
+                                                        &vmcore_list);
+        if (rc) {
+                kfree(elfcorebuf);
+                return rc;
+        }
+        set_vmcore_list_offsets_elf64(elfcorebuf, &vmcore_list);
+        return 0;
+}
+
+static int __init parse_crash_elf32_headers(void)
+{
+        int rc=0;
+        Elf32_Ehdr ehdr;
+        u64 addr;
+
+        addr = elfcorehdr_addr;
+
+        /* Read Elf header */
+        rc = read_from_oldmem((char*)&ehdr, sizeof(Elf32_Ehdr), &addr, 0);
+        if (rc < 0)
+                return rc;
+
+        /* Do some basic Verification. */
+        if (memcmp(ehdr.e_ident, ELFMAG, SELFMAG) != 0 ||
+                (ehdr.e_type != ET_CORE) ||
+                !elf_check_arch(&ehdr) ||
+                ehdr.e_ident[EI_CLASS] != ELFCLASS32||
+                ehdr.e_ident[EI_VERSION] != EV_CURRENT ||
+                ehdr.e_version != EV_CURRENT ||
+                ehdr.e_ehsize != sizeof(Elf32_Ehdr) ||
+                ehdr.e_phentsize != sizeof(Elf32_Phdr) ||
+                ehdr.e_phnum == 0) {
+                printk(KERN_WARNING "Warning: Core image elf header is not"
+                                        "sane\n");
+                return -EINVAL;
+        }
+
+        /* Read in all elf headers. */
+        elfcorebuf_sz = sizeof(Elf32_Ehdr) + ehdr.e_phnum * sizeof(Elf32_Phdr);
+        elfcorebuf = kmalloc(elfcorebuf_sz, GFP_KERNEL);
+        if (!elfcorebuf)
+                return -ENOMEM;
+        addr = elfcorehdr_addr;
+        rc = read_from_oldmem(elfcorebuf, elfcorebuf_sz, &addr, 0);
+        if (rc < 0) {
+                kfree(elfcorebuf);
+                return rc;
+        }
+
+        /* Merge all PT_NOTE headers into one. */
+        rc = merge_note_headers_elf32(elfcorebuf, &elfcorebuf_sz, &vmcore_list);
+        if (rc) {
+                kfree(elfcorebuf);
+                return rc;
+        }
+        rc = process_ptload_program_headers_elf32(elfcorebuf, elfcorebuf_sz,
+                                                                &vmcore_list);
+        if (rc) {
+                kfree(elfcorebuf);
+                return rc;
+        }
+        set_vmcore_list_offsets_elf32(elfcorebuf, &vmcore_list);
+        return 0;
+}
+
+static int __init parse_crash_elf_headers(void)
+{
+        unsigned char e_ident[EI_NIDENT];
+        u64 addr;
+        int rc=0;
+
+        addr = elfcorehdr_addr;
+        rc = read_from_oldmem(e_ident, EI_NIDENT, &addr, 0);
+        if (rc < 0)
+                return rc;
+        if (memcmp(e_ident, ELFMAG, SELFMAG) != 0) {
+                printk(KERN_WARNING "Warning: Core image elf header"
+                                        " not found\n");
+                return -EINVAL;
+        }
+
+        if (e_ident[EI_CLASS] == ELFCLASS64) {
+                rc = parse_crash_elf64_headers();
+                if (rc)
+                        return rc;
+
+                /* Determine vmcore size. */
+                vmcore_size = get_vmcore_size_elf64(elfcorebuf);
+        } else if (e_ident[EI_CLASS] == ELFCLASS32) {
+                rc = parse_crash_elf32_headers();
+                if (rc)
+                        return rc;
+
+                /* Determine vmcore size. */
+                vmcore_size = get_vmcore_size_elf32(elfcorebuf);
+        } else {
+                printk(KERN_WARNING "Warning: Core image elf header is not"
+                                        " sane\n");
+                return -EINVAL;
+        }
+        return 0;
+}
+
+/* Init function for vmcore module. */
+static int __init vmcore_init(void)
+{
+        int rc = 0;
+
+        /* If elfcorehdr= has been passed in cmdline, then capture the dump.*/
+        if (!(elfcorehdr_addr < ELFCORE_ADDR_MAX))
+                return rc;
+        rc = parse_crash_elf_headers();
+        if (rc) {
+                printk(KERN_WARNING "Kdump: vmcore not initialized\n");
+                return rc;
+        }
+
+        /* Initialize /proc/vmcore size if proc is already up. */
+        if (proc_vmcore)
+                proc_vmcore->size = vmcore_size;
+        return 0;
+}
+module_init(vmcore_init)
diff --git a/fs/reiserfs/inode.c b/fs/reiserfs/inode.c
index 0d5817f81972..289d864fe731 100644
--- a/fs/reiserfs/inode.c
+++ b/fs/reiserfs/inode.c
@@ -254,6 +254,7 @@ static int _get_block_create_0 (struct inode * inode, long block,
     char * p = NULL;
     int chars;
     int ret ;
+    int result ;
     int done = 0 ;
     unsigned long offset ;
 
@@ -262,10 +263,13 @@ static int _get_block_create_0 (struct inode * inode, long block,
                   (loff_t)block * inode->i_sb->s_blocksize + 1, TYPE_ANY, 3);
 
 research:
-    if (search_for_position_by_key (inode->i_sb, &key, &path) != POSITION_FOUND) {
+    result = search_for_position_by_key (inode->i_sb, &key, &path) ;
+    if (result != POSITION_FOUND) {
         pathrelse (&path);
         if (p)
             kunmap(bh_result->b_page) ;
+        if (result == IO_ERROR)
+            return -EIO;
         // We do not return -ENOENT if there is a hole but page is uptodate, because it means
         // That there is some MMAPED data associated with it that is yet to be written to disk.
         if ((args & GET_BLOCK_NO_HOLE) && !PageUptodate(bh_result->b_page) ) {
@@ -382,8 +386,9 @@ research:
 
         // update key to look for the next piece
         set_cpu_key_k_offset (&key, cpu_key_k_offset (&key) + chars);
-        if (search_for_position_by_key (inode->i_sb, &key, &path) != POSITION_FOUND)
-            // we read something from tail, even if now we got IO_ERROR
+        result = search_for_position_by_key (inode->i_sb, &key, &path);
+        if (result != POSITION_FOUND)
+            // i/o error most likely
             break;
         bh = get_last_bh (&path);
         ih = get_ih (&path);
@@ -394,6 +399,10 @@ research:
 
 finished:
     pathrelse (&path);
+
+    if (result == IO_ERROR)
+        return -EIO;
+
     /* this buffer has valid data, but isn't valid for io.  mapping it to
      * block #0 tells the rest of reiserfs it just has a tail in it
      */
diff --git a/fs/xfs/linux-2.6/xfs_buf.c b/fs/xfs/linux-2.6/xfs_buf.c
index c60e69431e11..df0cba239dd5 100644
--- a/fs/xfs/linux-2.6/xfs_buf.c
+++ b/fs/xfs/linux-2.6/xfs_buf.c
@@ -1771,9 +1771,9 @@ xfsbufd(
 
         INIT_LIST_HEAD(&tmp);
         do {
-                if (unlikely(current->flags & PF_FREEZE)) {
+                if (unlikely(freezing(current))) {
                         xfsbufd_force_sleep = 1;
-                        refrigerator(PF_FREEZE);
+                        refrigerator();
                 } else {
                         xfsbufd_force_sleep = 0;
                 }
diff --git a/fs/xfs/linux-2.6/xfs_super.c b/fs/xfs/linux-2.6/xfs_super.c
index 5fe9af38aa20..f6dd7de25927 100644
--- a/fs/xfs/linux-2.6/xfs_super.c
+++ b/fs/xfs/linux-2.6/xfs_super.c
@@ -483,7 +483,7 @@ xfssyncd(
                 set_current_state(TASK_INTERRUPTIBLE);
                 timeleft = schedule_timeout(timeleft);
                 /* swsusp */
-                try_to_freeze(PF_FREEZE);
+                try_to_freeze();
                 if (vfsp->vfs_flag & VFS_UMOUNT)
                         break;