linux-ntfs-dev — Development discussions and bug reports.

[Linux-NTFS-Dev] LDM 0.0.8 (Windows Dynamic Disks)

[Richard R. <ld...@fl...>]

Hi All,

This release has few changes and is low urgency.

Changes:
  Incorporated Al Viro's partition code cleanups
  Patches for 2.4 should now work
  More minor tidyups

Cheers,
  FlatCap (Rich)
  ld...@fl...

WWW: http://linux-ntfs.sf.net
IRC: #ntfs on irc.openprojects.net

Re: [Linux-NTFS-Dev] file content corrupt on a NTFS V3.1 partition.

[Frederic G. <ga...@fr...>]

Anton Altaparmakov wrote:

>No it is definitely not encrypted. Also it is definitely not corrupt or the 
>Linux ntfs driver would complain. However the files have been overwritten 
>with crap. The mostly likely result of a computer virus at work seeing what 
>boot.ini looks like. 
>
>btw. You can try running a virus scan on that disk. It may give you the 
>explanation you are looking for...
>  
>
Thank you for the answer. I'm really not a Windows expert... I should 
have thought to a virus before asking this to the mailing-list. It is 
indeed the only explanation...

>So you are out of luck. The data is lost. Sorry. You 
>should teach your friend about backups...
>
Or I should teach him about Linux, but this is another story...

Thanks again

PS : as often, my random .sig generator was right... My middle name is 
SpongeBob ;-)

-- 
Frederic Garzon <ga...@fr...> 
--
If I had a dollar for every brain that you don't have, I'd have one dollar. 
        - Squidward to SpongeBob

Re: [Linux-NTFS-Dev] file content corrupt on a NTFS V3.1 partition.

[Anton A. <ai...@ca...>]

Hi,

At 14:18 07/08/02, Frederic Garzon wrote:
>A colleague told me it was because of ACL protection : the content of a 
>disk could only be read by a windows whose SID was the same as the one who 
>created the partition.

That only applies if NTFS Encryption was turned on. It wasn't otherwise the 
ntfs driver would not have allowed you to read the data. I.e. you would 
have gotten ACCESS DENIED instead of binary data.

Also it is not just the SID which is important but that is irrelevant to 
the discussion.

>Is the disk completely broken ? is there a chance the files content was 
>"encrypted" by Windows XP (my friend, who is a computer newbie, told me he 
>did not install anything) ? I understand my questions are a bit naive, but 
>since I am not a windows expert, i'm a bit lost with this disk and partition...

No it is definitely not encrypted. Also it is definitely not corrupt or the 
Linux ntfs driver would complain. However the files have been overwritten 
with crap. The mostly likely result of a computer virus at work seeing what 
boot.ini looks like. So you are out of luck. The data is lost. Sorry. You 
should teach your friend about backups...

btw. You can try running a virus scan on that disk. It may give you the 
explanation you are looking for...

Best regards,

         Anton


-- 
   "I've not lost my mind. It's backed up on tape somewhere." - Unknown
-- 
Anton Altaparmakov <aia21 at cantab.net> (replace at with @)
Linux NTFS Maintainer / IRC: #ntfs on irc.openprojects.net
WWW: http://linux-ntfs.sf.net/ & http://www-stu.christs.cam.ac.uk/~aia21/

[Linux-NTFS-Dev] file content corrupt on a NTFS V3.1 partition.

[Frederic G. <ga...@fr...>]

Hello,

I try to read the content on a NTFS partition created by Win XP.

The disk belongs to a friend, and its Windows XP (on a packard bell 
computer) has crashed and can no longer boot (MBR broken, I guess...). 
The Packard Bell Support told him to reinstall Windows (using a diskette 
and their master CDROM). Because this procedure would erase all the data 
on the disk, my friend asked me to try to recover the content. The disk 
was correctly detected by the reinstall program, and the DOS fdisk could 
also see the disk.

I don't know much about Windows recovery (I abandoned M$ several years 
ago to use Linux), so I first tried to plug the disk into an NT Box at 
work. No success : The disk could be mounted, its directory structure 
could be browsed, but the files content was corrupt : when I tried to 
open any file, no system read error was reported, but the content was 
obviously wrong (binary data in boot.ini, etc...). A colleague told me 
it was because of ACL protection : the content of a disk could only be 
read by a windows whose SID was the same as the one who created the 
partition. So I tried to plug the disk into a Linux box whom ignores the 
ACL, to see what was wrong.

With linux, I have exactly the same problem : the partition can be 
mounted, I can see the directory structure, but many files are corrupt. 
Some files seem to be OK though, for example Explorer.exe :

[root@app1 WINDOWS]# file explorer.exe
explorer.exe: MS-DOS executable (EXE), OS/2 or MS Windows


Is the disk completely broken ? is there a chance the files content was 
"encrypted" by Windows XP (my friend, who is a computer newbie, told me 
he did not install anything) ? I understand my questions are a bit 
naive, but since I am not a windows expert, i'm a bit lost with this 
disk and partition...

The linux kernel is a 2.4.19 with the latest NTFS patch :
Aug  7 14:02:27 app1 kernel: NTFS driver 2.0.23b [Flags: R/O DEBUG MODULE].
Aug  7 14:02:37 app1 kernel: NTFS volume version 3.1.

NOTE : The content of the corrupt files  seems always to begin with the 
same byte pattern : several 0x00, then at offset 0x64 the string " run 
in DOS mode.". Sometimes the 0x00 are replaced by 0x01.

You will find in attachment the debug output of the ntfs module, an 
exemple of corrupt file, and the MBR of the disk.

Thanks in advance for your help and expertise.

-- 
Frederic Garzon <ga...@fr...> 

Re: [Linux-NTFS-Dev] HDD GUID

[Anton A. <ai...@ca...>]

At 16:41 06/08/02, Joseph Malicki wrote:
>They're actually the same as DCE RPC uuid's, and a portion of them is a
>random number (node is usually MAC address afaik).
>
>http://www.opengroup.org/onlinepubs/9629399/apdxa.htm

Wow! Great info! Thanks a lot!

Cheers,

         Anton


>-joe
>
>----- Original Message -----
>From: "Anton Altaparmakov" <ai...@ca...>
>To: "Michael N. Filippov" <mi...@id...>
>Cc: <lin...@li...>
>Sent: Tuesday, August 06, 2002 10:56 AM
>Subject: Re: [Linux-NTFS-Dev] HDD GUID
>
>
> > On Tue, 6 Aug 2002, Michael N. Filippov wrote:
> >
> > > Hello !
> > >
> > > In LDM documentation I see that each drive is addressed by GUID.
> > > Can anybody explain me how GUID for drive is calculated (if it
> > > is).
> >
> > Noone knows. The GUID is not random that is for sure. But it is somehow
> > related to the hardware in the machine, possibly to the ip address, the
> > time of day, and god knows what else...
> >
> > You can try asking MS but it is highly likely they will not tell you
> > because that would be a massive security flaw in windows...
> >
> > > Or how (if it is random) LDM driver knows that new inserted
> > > drive contains part of Volume.
> >
> > Each dynamic disk contains the COMPLETE LDM database. Therefore each disk
> > describes all the other disks. Also, IIRC, each disk stores its own GUID
> > so the LDM driver can tell them apart.
> >
> > Best regards,
> >
> > Anton
> > --
> > Anton Altaparmakov <aia21 at cantab.net> (replace at with @)
> > Linux NTFS maintainer / IRC: #ntfs on irc.openprojects.net
> > WWW: http://linux-ntfs.sf.net/ & http://www-stu.christs.cam.ac.uk/~aia21/
> >
> >
> >
> > -------------------------------------------------------
> > This sf.net email is sponsored by:ThinkGeek
> > Welcome to geek heaven.
> > http://thinkgeek.com/sf
> > _______________________________________________
> > Linux-NTFS-Dev mailing list
> > Lin...@li...
> > https://lists.sourceforge.net/lists/listinfo/linux-ntfs-dev
> >
>
>
>
>-------------------------------------------------------
>This sf.net email is sponsored by:ThinkGeek
>Welcome to geek heaven.
>http://thinkgeek.com/sf
>_______________________________________________
>Linux-NTFS-Dev mailing list
>Lin...@li...
>https://lists.sourceforge.net/lists/listinfo/linux-ntfs-dev

-- 
   "I've not lost my mind. It's backed up on tape somewhere." - Unknown
-- 
Anton Altaparmakov <aia21 at cantab.net> (replace at with @)
Linux NTFS Maintainer / IRC: #ntfs on irc.openprojects.net
WWW: http://linux-ntfs.sf.net/ & http://www-stu.christs.cam.ac.uk/~aia21/

Re: [Linux-NTFS-Dev] HDD GUID

[Joseph M. <jma...@st...>]

They're actually the same as DCE RPC uuid's, and a portion of them is a
random number (node is usually MAC address afaik).

http://www.opengroup.org/onlinepubs/9629399/apdxa.htm

-joe

----- Original Message -----
From: "Anton Altaparmakov" <ai...@ca...>
To: "Michael N. Filippov" <mi...@id...>
Cc: <lin...@li...>
Sent: Tuesday, August 06, 2002 10:56 AM
Subject: Re: [Linux-NTFS-Dev] HDD GUID


> On Tue, 6 Aug 2002, Michael N. Filippov wrote:
>
> > Hello !
> >
> > In LDM documentation I see that each drive is addressed by GUID.
> > Can anybody explain me how GUID for drive is calculated (if it
> > is).
>
> Noone knows. The GUID is not random that is for sure. But it is somehow
> related to the hardware in the machine, possibly to the ip address, the
> time of day, and god knows what else...
>
> You can try asking MS but it is highly likely they will not tell you
> because that would be a massive security flaw in windows...
>
> > Or how (if it is random) LDM driver knows that new inserted
> > drive contains part of Volume.
>
> Each dynamic disk contains the COMPLETE LDM database. Therefore each disk
> describes all the other disks. Also, IIRC, each disk stores its own GUID
> so the LDM driver can tell them apart.
>
> Best regards,
>
> Anton
> --
> Anton Altaparmakov <aia21 at cantab.net> (replace at with @)
> Linux NTFS maintainer / IRC: #ntfs on irc.openprojects.net
> WWW: http://linux-ntfs.sf.net/ & http://www-stu.christs.cam.ac.uk/~aia21/
>
>
>
> -------------------------------------------------------
> This sf.net email is sponsored by:ThinkGeek
> Welcome to geek heaven.
> http://thinkgeek.com/sf
> _______________________________________________
> Linux-NTFS-Dev mailing list
> Lin...@li...
> https://lists.sourceforge.net/lists/listinfo/linux-ntfs-dev
>

Re: [Linux-NTFS-Dev] HDD GUID

[Anton A. <ai...@ca...>]

On Tue, 6 Aug 2002, Michael N. Filippov wrote:

> Hello !
> 
> In LDM documentation I see that each drive is addressed by GUID.
> Can anybody explain me how GUID for drive is calculated (if it
> is).

Noone knows. The GUID is not random that is for sure. But it is somehow
related to the hardware in the machine, possibly to the ip address, the
time of day, and god knows what else...

You can try asking MS but it is highly likely they will not tell you
because that would be a massive security flaw in windows...

> Or how (if it is random) LDM driver knows that new inserted
> drive contains part of Volume.

Each dynamic disk contains the COMPLETE LDM database. Therefore each disk
describes all the other disks. Also, IIRC, each disk stores its own GUID
so the LDM driver can tell them apart.

Best regards,

	Anton
-- 
Anton Altaparmakov <aia21 at cantab.net> (replace at with @)
Linux NTFS maintainer / IRC: #ntfs on irc.openprojects.net
WWW: http://linux-ntfs.sf.net/ & http://www-stu.christs.cam.ac.uk/~aia21/

[Linux-NTFS-Dev] HDD GUID

[Michael N. F. <mi...@id...>]

Hello !

In LDM documentation I see that each drive is addressed by GUID.
Can anybody explain me how GUID for drive is calculated (if it
is). Or how (if it is random) LDM driver knows that new inserted
drive contains part of Volume.

Thanks in advance,
Michael

Re: [Linux-NTFS-Dev] Patch: linux-2.5.30/fs/ntfs BUG_ON(cond1 || cond2) bugs(!) and clean ups

[Pawel K. <pk...@li...>]

On Mon, 5 Aug 2002, Adam J. Richter wrote:

> >Thanks for the patch. Patch accepted and committed to my tree. It will b=
e
> >submitted with the next ntfs point release.
>
> =09Wow, thanks for the quick incorporation of my patch.

Just for the info. Along with other updates (few bits from 2.0.23, and
fixed kmap_pte and kmap_proto exports -- issue found by J=F6rg Prante) it i=
s
also included in upcoming NTFS backport to 2.4.x. Version 2.0.23b should
be available within an hour.

pkot
--=20
mailto:pk...@li... :: mailto:pk...@sl...
http://kt.linuxnews.pl/ :: Kernel Traffic po polsku

Re: [Linux-NTFS-Dev] Patch: linux-2.5.30/fs/ntfs BUG_ON(cond1 || cond2) bugs(!) and clean ups

[Adam J. R. <ad...@yg...>]

>Thanks for the patch. Patch accepted and committed to my tree. It will be 
>submitted with the next ntfs point release.

	Wow, thanks for the quick incorporation of my patch.

>I don't feel like this is 
>enough for a release so I will wait to gather some more things before 
>submitting so it may be a week or two, hope you don't mind the delay... If
>nothing comes up, I will just submit it on its own.

	No problem.  I agree that it's not urgent.

Adam J. Richter     __     ______________   575 Oroville Road
ad...@yg...     \ /                  Milpitas, California 95035
+1 408 309-6081         | g g d r a s i l   United States of America
                         "Free Software For The Rest Of Us."

Re: [Linux-NTFS-Dev] Patch: linux-2.5.30/fs/ntfs BUG_ON(cond1 || cond2) bugs(!) and clean ups

[Anton A. <ai...@ca...>]

At 21:41 05/08/02, Adam J. Richter wrote:
>         The following patch replaces all BUG_ON(condition1 || condition2)
>statements in fs/ntfs with separate BUG_ON statements, usually like so:
[snip]
>         I have attached the patch below.  I would like to get these
>changes into Linus's 2.5 tree.  Please let me know if you want to take
>it from here, if you want me to submit this patch to Linus or if you
>want me to do something else.

Thanks for the patch. Patch accepted and committed to my tree. It will be 
submitted with the next ntfs point release. I don't feel like this is 
enough for a release so I will wait to gather some more things before 
submitting so it may be a week or two, hope you don't mind the delay... If 
nothing comes up, I will just submit it on its own.

Note almost none of it applied because it was against 2.5.30 vanilla and 
ntfs has evolved two point releases since then and in fact some of your 
deltas were already there because mft_count has been eliminated. (-: But I 
did the changes by hand so no worries...

>Thanks for your time, and for maintaining the NT file system on Linux.

You are welcome. Thanks for your contribution. (-:

Best regards,

         Anton


-- 
   "I've not lost my mind. It's backed up on tape somewhere." - Unknown
-- 
Anton Altaparmakov <aia21 at cantab.net> (replace at with @)
Linux NTFS Maintainer / IRC: #ntfs on irc.openprojects.net
WWW: http://linux-ntfs.sf.net/ & http://www-stu.christs.cam.ac.uk/~aia21/

[Linux-NTFS-Dev] Patch: linux-2.5.30/fs/ntfs BUG_ON(cond1 || cond2) bugs(!) and clean ups

[Adam J. R. <ad...@yg...>]

	The following patch replaces all BUG_ON(condition1 || condition2)
statements in fs/ntfs with separate BUG_ON statements, usually like so:

		BUG_ON(condition1);
		BUG_ON(condition2);

	This provides more information if the BUG_ON statement is every
tripped.

	In addition, the fs/ntfs code had some
BUG_ON(...atomic_dec_and_test(...)) statements.  BUG_ON conditions should
not have side effects, because you are supposed to be able to compile out
BUG_ON statements to have the code run faster (which is an important
guarantee for encouraging developers to write BUG_ON statements).  I
have translated the offending cases to statements of the following form:

	if(...atomic_dec_and_test(...))
		BUG();

	I have attached the patch below.  I would like to get these
changes into Linus's 2.5 tree.  Please let me know if you want to take
it from here, if you want me to submit this patch to Linus or if you
want me to do something else.  Thanks for your time, and for maintaining
the NT file system on Linux.

-- 
Adam J. Richter     __     ______________   575 Oroville Road
ad...@yg...     \ /                  Milpitas, California 95035
+1 408 309-6081         | g g d r a s i l   United States of America
                         "Free Software For The Rest Of Us."

Re: [Linux-NTFS-Dev] NTFS 2.0.23a patch to 2.0.22b

[Pawel K. <pk...@li...>]

On Sun, 4 Aug 2002, Anton Altaparmakov wrote:

> This is an incremental patch from 2.0.22b to 2.0.23a for kernel 2.4.19-vanilla.

The whole patch linux-2.4.19-ntfs-2.0.23a.patch is already on the
SourceForge servers. See http://linux-ntfs.sf.net/downloads.html for the
detailes.

regards,
pkot
-- 
mailto:pk...@li... :: mailto:pk...@sl...
http://kt.linuxnews.pl/ :: Kernel Traffic po polsku

[Linux-NTFS-Dev] NTFS 2.0.23a patch to 2.0.22b

[Anton A. <ai...@ca...>]

This is an incremental patch from 2.0.22b to 2.0.23a for kernel 2.4.19-vanilla.

Have fun,

	Anton
-- 
Anton Altaparmakov <aia21 at cantab.net> (replace at with @)
Linux NTFS maintainer / IRC: #ntfs on irc.openprojects.net
WWW: http://linux-ntfs.sf.net/, http://www-stu.christs.cam.ac.uk/~aia21/

--- ntfs-2.0.22b-to-2.0.23a.patch ---
diff -urNp linux-2.4.19-tg3-ntfs-2.0.22b/Documentation/filesystems/ntfs.txt linux-2.4.19-tg3-ntfs-2.0.23a/Documentation/filesystems/ntfs.txt
--- linux-2.4.19-tg3-ntfs-2.0.22b/Documentation/filesystems/ntfs.txt	Sun Aug  4 21:13:10 2002
+++ linux-2.4.19-tg3-ntfs-2.0.23a/Documentation/filesystems/ntfs.txt	Sun Aug  4 21:14:52 2002
@@ -247,6 +247,14 @@ ChangeLog
 
 Note, a technical ChangeLog aimed at kernel hackers is in fs/ntfs/ChangeLog.
 
+2.0.23a:
+	- Massive internal locking changes to mft record locking. Fixes
+	  various race conditions and deadlocks.
+	- Fix ntfs over loopback for compressed files by adding an
+	  optimization barrier. (gcc was screwing up otherwise ?)
+	Thanks go to Christoph Hellwig for pointing these two out:
+	- Remove now unused function fs/ntfs/malloc.h::vmalloc_nofs().
+	- Fix ntfs_free() for ia64 and parisc.
 2.0.22a:
 	- Sync with NTFS 2.0.22 and kernel 2.4.19.
 2.0.22:
diff -urNp linux-2.4.19-tg3-ntfs-2.0.22b/fs/ntfs/ChangeLog linux-2.4.19-tg3-ntfs-2.0.23a/fs/ntfs/ChangeLog
--- linux-2.4.19-tg3-ntfs-2.0.22b/fs/ntfs/ChangeLog	Sun Aug  4 21:12:51 2002
+++ linux-2.4.19-tg3-ntfs-2.0.23a/fs/ntfs/ChangeLog	Sun Aug  4 21:31:43 2002
@@ -1,6 +1,20 @@
 ToDo:
 	- Find and fix bugs.
 
+2.0.23a - Major bug fixes (races, deadlocks, non-i386 architectures).
+
+	- Massive internal locking changes to mft record locking. Fixes lock
+	  recursion and replaces the mrec_lock read/write semaphore with a
+	  mutex. Also removes the now superfluous mft_count. This fixes several
+	  race conditions and deadlocks, especially in the future write code.
+	- Fix ntfs over loopback for compressed files by adding an
+	  optimization barrier. (gcc was screwing up otherwise ?)
+	- Miscellaneous cleanups all over the code and a fix or two in error
+	  handling code paths.
+	Thanks go to Christoph Hellwig for pointing out the following two:
+	- Remove now unused function fs/ntfs/malloc.h::vmalloc_nofs().
+	- Fix ntfs_free() for ia64 and parisc by checking for VMALLOC_END, too.
+
 2.0.22a - Updates of the backport.
 
 	- Sync with NTFS 2.0.22.
diff -urNp linux-2.4.19-tg3-ntfs-2.0.22b/fs/ntfs/Makefile linux-2.4.19-tg3-ntfs-2.0.23a/fs/ntfs/Makefile
--- linux-2.4.19-tg3-ntfs-2.0.22b/fs/ntfs/Makefile	Sun Aug  4 21:12:52 2002
+++ linux-2.4.19-tg3-ntfs-2.0.23a/fs/ntfs/Makefile	Sun Aug  4 21:14:51 2002
@@ -7,7 +7,7 @@ obj-y   := aops.o attrib.o compress.o de
 
 obj-m   := $(O_TARGET)
 
-EXTRA_CFLAGS = -DNTFS_VERSION=\"2.0.22a\"
+EXTRA_CFLAGS = -DNTFS_VERSION=\"2.0.23a\"
 
 ifeq ($(CONFIG_NTFS_DEBUG),y)
 EXTRA_CFLAGS += -DDEBUG
diff -urNp linux-2.4.19-tg3-ntfs-2.0.22b/fs/ntfs/aops.c linux-2.4.19-tg3-ntfs-2.0.23a/fs/ntfs/aops.c
--- linux-2.4.19-tg3-ntfs-2.0.22b/fs/ntfs/aops.c	Sun Aug  4 21:12:36 2002
+++ linux-2.4.19-tg3-ntfs-2.0.23a/fs/ntfs/aops.c	Sun Aug  4 21:14:30 2002
@@ -335,6 +335,8 @@ handle_zblock:
  * for it to be read in before we can do the copy.
  *
  * Return 0 on success and -errno on error.
+ *
+ * WARNING: Do not make this function static! It is used by mft.c!
  */
 int ntfs_readpage(struct file *file, struct page *page)
 {
@@ -375,8 +377,8 @@ int ntfs_readpage(struct file *file, str
 	else
 		base_ni = ni->_INE(base_ntfs_ino);
 
-	/* Map, pin and lock the mft record for reading. */
-	mrec = map_mft_record(READ, base_ni);
+	/* Map, pin, and lock the mft record. */
+	mrec = map_mft_record(base_ni);
 	if (unlikely(IS_ERR(mrec))) {
 		err = PTR_ERR(mrec);
 		goto err_out;
@@ -419,7 +421,7 @@ int ntfs_readpage(struct file *file, str
 put_unm_err_out:
 	put_attr_search_ctx(ctx);
 unm_err_out:
-	unmap_mft_record(READ, base_ni);
+	unmap_mft_record(base_ni);
 err_out:
 	unlock_page(page);
 	return err;
@@ -429,8 +431,8 @@ err_out:
  * ntfs_aops - general address space operations for inodes and attributes
  */
 struct address_space_operations ntfs_aops = {
-	readpage:	ntfs_readpage,		/* Fill page with data. */
-	sync_page:	block_sync_page,	/* Currently, just unplugs the
+	.readpage	= ntfs_readpage,	/* Fill page with data. */
+	.sync_page	= block_sync_page,	/* Currently, just unplugs the
 						   disk request queue. */
 };
 
diff -urNp linux-2.4.19-tg3-ntfs-2.0.22b/fs/ntfs/attrib.c linux-2.4.19-tg3-ntfs-2.0.23a/fs/ntfs/attrib.c
--- linux-2.4.19-tg3-ntfs-2.0.22b/fs/ntfs/attrib.c	Sun Aug  4 21:12:47 2002
+++ linux-2.4.19-tg3-ntfs-2.0.23a/fs/ntfs/attrib.c	Sun Aug  4 21:14:54 2002
@@ -947,7 +947,7 @@ int map_run_list(ntfs_inode *ni, VCN vcn
 	else
 		base_ni = ni->_INE(base_ntfs_ino);
 
-	mrec = map_mft_record(READ, base_ni);
+	mrec = map_mft_record(base_ni);
 	if (IS_ERR(mrec))
 		return PTR_ERR(mrec);
 	ctx = get_attr_search_ctx(base_ni, mrec);
@@ -978,7 +978,7 @@ int map_run_list(ntfs_inode *ni, VCN vcn
 	
 	put_attr_search_ctx(ctx);
 err_out:
-	unmap_mft_record(READ, base_ni);
+	unmap_mft_record(base_ni);
 	return err;
 }
 
@@ -1670,7 +1670,7 @@ void reinit_attr_search_ctx(attr_search_
 		return;
 	} /* Attribute list. */
 	if (ctx->ntfs_ino != ctx->base_ntfs_ino)
-		unmap_mft_record(READ, ctx->ntfs_ino);
+		unmap_extent_mft_record(ctx->ntfs_ino);
 	init_attr_search_ctx(ctx, ctx->base_ntfs_ino, ctx->base_mrec);
 	return;
 }
@@ -1703,7 +1703,7 @@ attr_search_context *get_attr_search_ctx
 void put_attr_search_ctx(attr_search_context *ctx)
 {
 	if (ctx->base_ntfs_ino && ctx->ntfs_ino != ctx->base_ntfs_ino)
-		unmap_mft_record(READ, ctx->ntfs_ino);
+		unmap_extent_mft_record(ctx->ntfs_ino);
 	kmem_cache_free(ntfs_attr_ctx_cache, ctx);
 	return;
 }
diff -urNp linux-2.4.19-tg3-ntfs-2.0.22b/fs/ntfs/compress.c linux-2.4.19-tg3-ntfs-2.0.23a/fs/ntfs/compress.c
--- linux-2.4.19-tg3-ntfs-2.0.22b/fs/ntfs/compress.c	Sun Aug  4 21:12:43 2002
+++ linux-2.4.19-tg3-ntfs-2.0.23a/fs/ntfs/compress.c	Sun Aug  4 21:24:37 2002
@@ -609,8 +609,27 @@ lock_retry_remap:
 		if (buffer_uptodate(tbh))
 			continue;
 		wait_on_buffer(tbh);
-		if (unlikely(!buffer_uptodate(tbh)))
-			goto read_err;
+		/*
+		 * We need an optimization barrier here, otherwise we start
+		 * hitting the below fixup code when accessing a loopback
+		 * mounted ntfs partition. This indicates either there is a
+		 * race condition in the loop driver or, more likely, gcc
+		 * overoptimises the code without the barrier and it doesn't
+		 * do the Right Thing(TM).
+		 */
+		barrier();
+		if (unlikely(!buffer_uptodate(tbh))) {
+			ntfs_warning(vol->sb, "Buffer is unlocked but not "
+					"uptodate! Unplugging the disk queue "
+					"and rescheduling.");
+			get_bh(tbh);
+			run_task_queue(&tq_disk);
+			schedule();
+			put_bh(tbh);
+			if (unlikely(!buffer_uptodate(tbh)))
+				goto read_err;
+			ntfs_warning(vol->sb, "Buffer is now uptodate. Good.");
+		}
 	}
 
 	/*
diff -urNp linux-2.4.19-tg3-ntfs-2.0.22b/fs/ntfs/dir.c linux-2.4.19-tg3-ntfs-2.0.23a/fs/ntfs/dir.c
--- linux-2.4.19-tg3-ntfs-2.0.22b/fs/ntfs/dir.c	Sun Aug  4 21:13:12 2002
+++ linux-2.4.19-tg3-ntfs-2.0.23a/fs/ntfs/dir.c	Sun Aug  4 21:14:53 2002
@@ -77,7 +77,7 @@ MFT_REF ntfs_lookup_inode_by_name(ntfs_i
 	u8 *index_end;
 	u64 mref;
 	attr_search_context *ctx;
-	int err = 0, rc;
+	int err, rc;
 	VCN vcn, old_vcn;
 	struct address_space *ia_mapping;
 	struct page *page;
@@ -85,23 +85,24 @@ MFT_REF ntfs_lookup_inode_by_name(ntfs_i
 	ntfs_name *name = NULL;
 
 	/* Get hold of the mft record for the directory. */
-	m = map_mft_record(READ, dir_ni);
-	if (IS_ERR(m))
-		goto map_err_out;
-
+	m = map_mft_record(dir_ni);
+	if (unlikely(IS_ERR(m))) {
+		ntfs_error(sb, "map_mft_record() failed with error code %ld.",
+				-PTR_ERR(m));
+		return ERR_MREF(PTR_ERR(m));
+	}
 	ctx = get_attr_search_ctx(dir_ni, m);
-	if (!ctx) {
+	if (unlikely(!ctx)) {
 		err = -ENOMEM;
-		goto unm_err_out;
+		goto err_out;
 	}
-
 	/* Find the index root attribute in the mft record. */
 	if (!lookup_attr(AT_INDEX_ROOT, I30, 4, CASE_SENSITIVE, 0, NULL, 0,
 			ctx)) {
 		ntfs_error(sb, "Index root attribute missing in directory "
 				"inode 0x%lx.", dir_ni->mft_no);
 		err = -EIO;
-		goto put_unm_err_out;
+		goto err_out;
 	}
 	/* Get to the index root value (it's been verified in read_inode). */
 	ir = (INDEX_ROOT*)((u8*)ctx->attr +
@@ -155,7 +156,7 @@ found_it:
 							GFP_NOFS);
 					if (!name) {
 						err = -ENOMEM;
-						goto put_unm_err_out;
+						goto err_out;
 					}
 				}
 				name->mref = le64_to_cpu(
@@ -170,7 +171,7 @@ found_it:
 			}
 			mref = le64_to_cpu(ie->_IIF(indexed_file));
 			put_attr_search_ctx(ctx);
-			unmap_mft_record(READ, dir_ni);
+			unmap_mft_record(dir_ni);
 			return mref;
 		}
 		/*
@@ -209,7 +210,7 @@ found_it:
 			name = kmalloc(name_size, GFP_NOFS);
 			if (!name) {
 				err = -ENOMEM;
-				goto put_unm_err_out;
+				goto err_out;
 			}
 			name->mref = le64_to_cpu(ie->_IIF(indexed_file));
 			name->type = type;
@@ -268,12 +269,12 @@ found_it:
 	if (!(ie->_IEH(flags) & INDEX_ENTRY_NODE)) {
 		if (name) {
 			put_attr_search_ctx(ctx);
-			unmap_mft_record(READ, dir_ni);
+			unmap_mft_record(dir_ni);
 			return name->mref;
 		}
 		ntfs_debug("Entry not found.");
 		err = -ENOENT;
-		goto put_unm_err_out;
+		goto err_out;
 	} /* Child node present, descend into it. */
 	/* Consistency check: Verify that an index allocation exists. */
 	if (!NInoIndexAllocPresent(dir_ni)) {
@@ -281,11 +282,19 @@ found_it:
 				"requires one. Directory inode 0x%lx is "
 				"corrupt or driver bug.", dir_ni->mft_no);
 		err = -EIO;
-		goto put_unm_err_out;
+		goto err_out;
 	}
 	/* Get the starting vcn of the index_block holding the child node. */
 	vcn = sle64_to_cpup((u8*)ie + le16_to_cpu(ie->_IEH(length)) - 8);
 	ia_mapping = VFS_I(dir_ni)->i_mapping;
+	/*
+	 * We are done with the index root and the mft record. Release them,
+	 * otherwise we deadlock with ntfs_map_page().
+	 */
+	put_attr_search_ctx(ctx);
+	unmap_mft_record(dir_ni);
+	m = NULL;
+	ctx = NULL;
 descend_into_child_node:
 	/*
 	 * Convert vcn to index into the index allocation attribute in units
@@ -297,7 +306,8 @@ descend_into_child_node:
 	if (IS_ERR(page)) {
 		ntfs_error(sb, "Failed to map directory index page, error %ld.",
 				-PTR_ERR(page));
-		goto put_unm_err_out;
+		err = PTR_ERR(page);
+		goto err_out;
 	}
 	kaddr = (u8*)page_address(page);
 fast_descend_into_child_node:
@@ -309,7 +319,7 @@ fast_descend_into_child_node:
 		ntfs_error(sb, "Out of bounds check failed. Corrupt directory "
 				"inode 0x%lx or driver bug.", dir_ni->mft_no);
 		err = -EIO;
-		goto unm_unm_err_out;
+		goto unm_err_out;
 	}
 	if (sle64_to_cpu(ia->index_block_vcn) != vcn) {
 		ntfs_error(sb, "Actual VCN (0x%Lx) of index buffer is "
@@ -319,7 +329,7 @@ fast_descend_into_child_node:
 				(long long)sle64_to_cpu(ia->index_block_vcn),
 				(long long)vcn, dir_ni->mft_no);
 		err = -EIO;
-		goto unm_unm_err_out;
+		goto unm_err_out;
 	}
 	if (le32_to_cpu(ia->index.allocated_size) + 0x18 !=
 			dir_ni->_IDM(index_block_size)) {
@@ -331,7 +341,7 @@ fast_descend_into_child_node:
 				le32_to_cpu(ia->index.allocated_size) + 0x18,
 				dir_ni->_IDM(index_block_size));
 		err = -EIO;
-		goto unm_unm_err_out;
+		goto unm_err_out;
 	}
 	index_end = (u8*)ia + dir_ni->_IDM(index_block_size);
 	if (index_end > kaddr + PAGE_CACHE_SIZE) {
@@ -340,7 +350,7 @@ fast_descend_into_child_node:
 				"Cannot access! This is probably a bug in the "
 				"driver.", (long long)vcn, dir_ni->mft_no);
 		err = -EIO;
-		goto unm_unm_err_out;
+		goto unm_err_out;
 	}
 	index_end = (u8*)&ia->index + le32_to_cpu(ia->index.index_length);
 	if (index_end > (u8*)ia + dir_ni->_IDM(index_block_size)) {
@@ -348,7 +358,7 @@ fast_descend_into_child_node:
 				"inode 0x%lx exceeds maximum size.",
 				(long long)vcn, dir_ni->mft_no);
 		err = -EIO;
-		goto unm_unm_err_out;
+		goto unm_err_out;
 	}
 	/* The first index entry. */
 	ie = (INDEX_ENTRY*)((u8*)&ia->index +
@@ -368,7 +378,7 @@ fast_descend_into_child_node:
 					"directory inode 0x%lx.",
 					dir_ni->mft_no);
 			err = -EIO;
-			goto unm_unm_err_out;
+			goto unm_err_out;
 		}
 		/*
 		 * The last entry cannot contain a name. It can however contain
@@ -404,7 +414,7 @@ found_it2:
 							GFP_NOFS);
 					if (!name) {
 						err = -ENOMEM;
-						goto unm_unm_err_out;
+						goto unm_err_out;
 					}
 				}
 				name->mref = le64_to_cpu(
@@ -419,8 +429,6 @@ found_it2:
 			}
 			mref = le64_to_cpu(ie->_IIF(indexed_file));
 			ntfs_unmap_page(page);
-			put_attr_search_ctx(ctx);
-			unmap_mft_record(READ, dir_ni);
 			return mref;
 		}
 		/*
@@ -460,7 +468,7 @@ found_it2:
 			name = kmalloc(name_size, GFP_NOFS);
 			if (!name) {
 				err = -ENOMEM;
-				goto put_unm_err_out;
+				goto unm_err_out;
 			}
 			name->mref = le64_to_cpu(ie->_IIF(indexed_file));
 			name->type = type;
@@ -520,7 +528,7 @@ found_it2:
 					"a leaf node in directory inode 0x%lx.",
 					dir_ni->mft_no);
 			err = -EIO;
-			goto unm_unm_err_out;
+			goto unm_err_out;
 		}
 		/* Child node present, descend into it. */
 		old_vcn = vcn;
@@ -540,7 +548,7 @@ found_it2:
 		ntfs_error(sb, "Negative child node vcn in directory inode "
 				"0x%lx.", dir_ni->mft_no);
 		err = -EIO;
-		goto unm_unm_err_out;
+		goto unm_err_out;
 	}
 	/*
 	 * No child node present, return -ENOENT, unless we have got a matching
@@ -549,31 +557,26 @@ found_it2:
 	 */
 	if (name) {
 		ntfs_unmap_page(page);
-		put_attr_search_ctx(ctx);
-		unmap_mft_record(READ, dir_ni);
 		return name->mref;
 	}
 	ntfs_debug("Entry not found.");
 	err = -ENOENT;
-unm_unm_err_out:
-	ntfs_unmap_page(page);
-put_unm_err_out:
-	put_attr_search_ctx(ctx);
 unm_err_out:
-	unmap_mft_record(READ, dir_ni);
+	ntfs_unmap_page(page);
+err_out:
+	if (ctx)
+		put_attr_search_ctx(ctx);
+	if (m)
+		unmap_mft_record(dir_ni);
 	if (name) {
 		kfree(name);
 		*res = NULL;
 	}
 	return ERR_MREF(err);
-map_err_out:
-	ntfs_error(sb, "map_mft_record(READ) failed with error code %ld.",
-			-PTR_ERR(m));
-	return ERR_MREF(PTR_ERR(m));
 dir_err_out:
 	ntfs_error(sb, "Corrupt directory. Aborting lookup.");
 	err = -EIO;
-	goto put_unm_err_out;
+	goto err_out;
 }
 
 #if 0
@@ -623,23 +626,24 @@ u64 ntfs_lookup_inode_by_name(ntfs_inode
 	u8 *kaddr;
 
 	/* Get hold of the mft record for the directory. */
-	m = map_mft_record(READ, dir_ni);
-	if (IS_ERR(m))
-		goto map_err_out;
-
+	m = map_mft_record(dir_ni);
+	if (IS_ERR(m)) {
+		ntfs_error(sb, "map_mft_record() failed with error code %ld.",
+				-PTR_ERR(m));
+		return ERR_MREF(PTR_ERR(m));
+	}
 	ctx = get_attr_search_ctx(dir_ni, m);
 	if (!ctx) {
 		err = -ENOMEM;
-		goto unm_err_out;
+		goto err_out;
 	}
-
 	/* Find the index root attribute in the mft record. */
 	if (!lookup_attr(AT_INDEX_ROOT, I30, 4, CASE_SENSITIVE, 0, NULL, 0,
 			ctx)) {
 		ntfs_error(sb, "Index root attribute missing in directory "
 				"inode 0x%lx.", dir_ni->mft_no);
 		err = -EIO;
-		goto put_unm_err_out;
+		goto err_out;
 	}
 	/* Get to the index root value (it's been verified in read_inode). */
 	ir = (INDEX_ROOT*)((u8*)ctx->attr +
@@ -690,7 +694,7 @@ u64 ntfs_lookup_inode_by_name(ntfs_inode
 found_it:
 			mref = le64_to_cpu(ie->_IIF(indexed_file));
 			put_attr_search_ctx(ctx);
-			unmap_mft_record(READ, dir_ni);
+			unmap_mft_record(dir_ni);
 			return mref;
 		}
 		/*
@@ -738,7 +742,7 @@ found_it:
 	if (!(ie->_IEH(flags) & INDEX_ENTRY_NODE)) {
 		/* No child node, return -ENOENT. */
 		err = -ENOENT;
-		goto put_unm_err_out;
+		goto err_out;
 	} /* Child node present, descend into it. */
 	/* Consistency check: Verify that an index allocation exists. */
 	if (!NInoIndexAllocPresent(dir_ni)) {
@@ -746,11 +750,19 @@ found_it:
 				"requires one. Directory inode 0x%lx is "
 				"corrupt or driver bug.", dir_ni->mft_no);
 		err = -EIO;
-		goto put_unm_err_out;
+		goto err_out;
 	}
 	/* Get the starting vcn of the index_block holding the child node. */
 	vcn = sle64_to_cpup((u8*)ie + le16_to_cpu(ie->_IEH(length)) - 8);
 	ia_mapping = VFS_I(dir_ni)->i_mapping;
+	/*
+	 * We are done with the index root and the mft record. Release them,
+	 * otherwise we deadlock with ntfs_map_page().
+	 */
+	put_attr_search_ctx(ctx);
+	unmap_mft_record(dir_ni);
+	m = NULL;
+	ctx = NULL;
 descend_into_child_node:
 	/*
 	 * Convert vcn to index into the index allocation attribute in units
@@ -762,7 +774,8 @@ descend_into_child_node:
 	if (IS_ERR(page)) {
 		ntfs_error(sb, "Failed to map directory index page, error %ld.",
 				-PTR_ERR(page));
-		goto put_unm_err_out;
+		err = PTR_ERR(page);
+		goto err_out;
 	}
 	kaddr = (u8*)page_address(page);
 fast_descend_into_child_node:
@@ -774,7 +787,7 @@ fast_descend_into_child_node:
 		ntfs_error(sb, "Out of bounds check failed. Corrupt directory "
 				"inode 0x%lx or driver bug.", dir_ni->mft_no);
 		err = -EIO;
-		goto unm_unm_err_out;
+		goto unm_err_out;
 	}
 	if (sle64_to_cpu(ia->index_block_vcn) != vcn) {
 		ntfs_error(sb, "Actual VCN (0x%Lx) of index buffer is "
@@ -784,7 +797,7 @@ fast_descend_into_child_node:
 				(long long)sle64_to_cpu(ia->index_block_vcn),
 				(long long)vcn, dir_ni->mft_no);
 		err = -EIO;
-		goto unm_unm_err_out;
+		goto unm_err_out;
 	}
 	if (le32_to_cpu(ia->index.allocated_size) + 0x18 !=
 			dir_ni->_IDM(index_block_size)) {
@@ -796,7 +809,7 @@ fast_descend_into_child_node:
 				le32_to_cpu(ia->index.allocated_size) + 0x18,
 				dir_ni->_IDM(index_block_size));
 		err = -EIO;
-		goto unm_unm_err_out;
+		goto unm_err_out;
 	}
 	index_end = (u8*)ia + dir_ni->_IDM(index_block_size);
 	if (index_end > kaddr + PAGE_CACHE_SIZE) {
@@ -805,7 +818,7 @@ fast_descend_into_child_node:
 				"Cannot access! This is probably a bug in the "
 				"driver.", (long long)vcn, dir_ni->mft_no);
 		err = -EIO;
-		goto unm_unm_err_out;
+		goto unm_err_out;
 	}
 	index_end = (u8*)&ia->index + le32_to_cpu(ia->index.index_length);
 	if (index_end > (u8*)ia + dir_ni->_IDM(index_block_size)) {
@@ -813,7 +826,7 @@ fast_descend_into_child_node:
 				"inode 0x%lx exceeds maximum size.",
 				(long long)vcn, dir_ni->mft_no);
 		err = -EIO;
-		goto unm_unm_err_out;
+		goto unm_err_out;
 	}
 	/* The first index entry. */
 	ie = (INDEX_ENTRY*)((u8*)&ia->index +
@@ -833,7 +846,7 @@ fast_descend_into_child_node:
 					"directory inode 0x%lx.",
 					dir_ni->mft_no);
 			err = -EIO;
-			goto unm_unm_err_out;
+			goto unm_err_out;
 		}
 		/*
 		 * The last entry cannot contain a name. It can however contain
@@ -866,8 +879,6 @@ fast_descend_into_child_node:
 found_it2:
 			mref = le64_to_cpu(ie->_IIF(indexed_file));
 			ntfs_unmap_page(page);
-			put_attr_search_ctx(ctx);
-			unmap_mft_record(READ, dir_ni);
 			return mref;
 		}
 		/*
@@ -918,7 +929,7 @@ found_it2:
 					"a leaf node in directory inode 0x%lx.",
 					dir_ni->mft_no);
 			err = -EIO;
-			goto unm_unm_err_out;
+			goto unm_err_out;
 		}
 		/* Child node present, descend into it. */
 		old_vcn = vcn;
@@ -938,26 +949,23 @@ found_it2:
 		ntfs_error(sb, "Negative child node vcn in directory inode "
 				"0x%lx.", dir_ni->mft_no);
 		err = -EIO;
-		goto unm_unm_err_out;
+		goto unm_err_out;
 	}
 	/* No child node, return -ENOENT. */
 	ntfs_debug("Entry not found.");
 	err = -ENOENT;
-unm_unm_err_out:
-	ntfs_unmap_page(page);
-put_unm_err_out:
-	put_attr_search_ctx(ctx);
 unm_err_out:
-	unmap_mft_record(READ, dir_ni);
+	ntfs_unmap_page(page);
+err_out:
+	if (ctx)
+		put_attr_search_ctx(ctx);
+	if (m)
+		unmap_mft_record(dir_ni);
 	return ERR_MREF(err);
-map_err_out:
-	ntfs_error(sb, "map_mft_record(READ) failed with error code %ld.",
-			-PTR_ERR(m));
-	return ERR_MREF(PTR_ERR(m));
 dir_err_out:
 	ntfs_error(sb, "Corrupt directory. Aborting lookup.");
 	err = -EIO;
-	goto put_unm_err_out;
+	goto err_out;
 }
 
 #endif
@@ -1092,22 +1100,8 @@ static int ntfs_readdir(struct file *fil
 			goto done;
 		fpos++;
 	}
-
-	/* Get hold of the mft record for the directory. */
-	m = map_mft_record(READ, ndir);
-	if (unlikely(IS_ERR(m))) {
-		err = PTR_ERR(m);
-		m = NULL;
-		ctx = NULL;
-		goto err_out;
-	}
-
-	ctx = get_attr_search_ctx(ndir, m);
-	if (unlikely(!ctx)) {
-		err = -ENOMEM;
-		goto err_out;
-	}
-
+	m = NULL;
+	ctx = NULL;
 	/*
 	 * Allocate a buffer to store the current name being processed
 	 * converted to format determined by current NLS.
@@ -1121,6 +1115,18 @@ static int ntfs_readdir(struct file *fil
 	/* Are we jumping straight into the index allocation attribute? */
 	if (fpos >= vol->mft_record_size)
 		goto skip_index_root;
+	/* Get hold of the mft record for the directory. */
+	m = map_mft_record(ndir);
+	if (unlikely(IS_ERR(m))) {
+		err = PTR_ERR(m);
+		m = NULL;
+		goto err_out;
+	}
+	ctx = get_attr_search_ctx(ndir, m);
+	if (unlikely(!ctx)) {
+		err = -ENOMEM;
+		goto err_out;
+	}
 	/* Get the offset into the index root attribute. */
 	ir_pos = (s64)fpos;
 	/* Find the index root attribute in the mft record. */
@@ -1159,9 +1165,21 @@ static int ntfs_readdir(struct file *fil
 		/* Submit the name to the filldir callback. */
 		rc = ntfs_filldir(vol, &fpos, ndir, INDEX_TYPE_ROOT, ir, ie,
 				name, dirent, filldir);
-		if (rc)
+		if (rc) {
+			put_attr_search_ctx(ctx);
+			unmap_mft_record(ndir);
 			goto abort;
+		}
 	}
+	/*
+	 * We are done with the index root and the mft record for that matter.
+	 * We need to release it, otherwise we deadlock on ntfs_attr_iget()
+	 * and/or ntfs_read_page().
+	 */
+	put_attr_search_ctx(ctx);
+	unmap_mft_record(ndir);
+	m = NULL;
+	ctx = NULL;
 	/* If there is no index allocation attribute we are finished. */
 	if (!NInoIndexAllocPresent(ndir))
 		goto EOD;
@@ -1340,8 +1358,6 @@ EOD:
 	/* We are finished, set fpos to EOD. */
 	fpos = vdir->i_size + vol->mft_record_size;
 abort:
-	put_attr_search_ctx(ctx);
-	unmap_mft_record(READ, ndir);
 	kfree(name);
 done:
 #ifdef DEBUG
@@ -1363,7 +1379,7 @@ err_out:
 	if (ctx)
 		put_attr_search_ctx(ctx);
 	if (m)
-		unmap_mft_record(READ, ndir);
+		unmap_mft_record(ndir);
 	if (!err)
 		err = -EIO;
 	ntfs_debug("Failed. Returning error code %i.", -err);
@@ -1397,9 +1413,9 @@ static int ntfs_dir_open(struct inode *v
 }
 
 struct file_operations ntfs_dir_ops = {
-	llseek:		generic_file_llseek,	/* Seek inside directory. */
-	read:		generic_read_dir,	/* Return -EISDIR. */
-	readdir:	ntfs_readdir,		/* Read directory contents. */
-	open:		ntfs_dir_open,		/* Open directory. */
+	.llseek		= generic_file_llseek,	/* Seek inside directory. */
+	.read		= generic_read_dir,	/* Return -EISDIR. */
+	.readdir	= ntfs_readdir,		/* Read directory contents. */
+	.open		= ntfs_dir_open,	/* Open directory. */
 };
 
diff -urNp linux-2.4.19-tg3-ntfs-2.0.22b/fs/ntfs/file.c linux-2.4.19-tg3-ntfs-2.0.23a/fs/ntfs/file.c
--- linux-2.4.19-tg3-ntfs-2.0.22b/fs/ntfs/file.c	Sun Aug  4 21:12:28 2002
+++ linux-2.4.19-tg3-ntfs-2.0.23a/fs/ntfs/file.c	Sun Aug  4 21:14:52 2002
@@ -49,10 +49,10 @@ static int ntfs_file_open(struct inode *
 }
 
 struct file_operations ntfs_file_ops = {
-	llseek:		generic_file_llseek,	/* Seek inside file. */
-	read:		generic_file_read,	/* Read from file. */
-	mmap:		generic_file_mmap,	/* Mmap file. */
-	open:		ntfs_file_open,		/* Open file. */
+	.llseek	= generic_file_llseek,	/* Seek inside file. */
+	.read	= generic_file_read,	/* Read from file. */
+	.mmap	= generic_file_mmap,	/* Mmap file. */
+	.open	= ntfs_file_open,	/* Open file. */
 };
 
 struct inode_operations ntfs_file_inode_ops = {};
diff -urNp linux-2.4.19-tg3-ntfs-2.0.22b/fs/ntfs/inode.c linux-2.4.19-tg3-ntfs-2.0.23a/fs/ntfs/inode.c
--- linux-2.4.19-tg3-ntfs-2.0.22b/fs/ntfs/inode.c	Sun Aug  4 21:12:52 2002
+++ linux-2.4.19-tg3-ntfs-2.0.23a/fs/ntfs/inode.c	Sun Aug  4 21:14:51 2002
@@ -252,7 +252,7 @@ static inline ntfs_inode *ntfs_alloc_ext
 void ntfs_destroy_extent_inode(ntfs_inode *ni)
 {
 	ntfs_debug("Entering.");
-	BUG_ON(atomic_read(&ni->mft_count) || !atomic_dec_and_test(&ni->count));
+	BUG_ON(ni->page || !atomic_dec_and_test(&ni->count));
 	kmem_cache_free(ntfs_inode_cache, ni);
 }
 
@@ -276,8 +276,7 @@ static void __ntfs_init_inode(struct sup
 	atomic_set(&ni->count, 1);
 	ni->vol = NTFS_SB(sb);
 	init_run_list(&ni->run_list);
-	init_rwsem(&ni->mrec_lock);
-	atomic_set(&ni->mft_count, 0);
+	init_MUTEX(&ni->mrec_lock);
 	ni->page = NULL;
 	ni->page_ofs = 0;
 	ni->attr_list_size = 0;
@@ -469,7 +468,7 @@ void ntfs_read_locked_inode(struct inode
 	vi->i_gid = vol->gid;
 	vi->i_mode = 0;
 
-	m = map_mft_record(READ, ni);
+	m = map_mft_record(ni);
 	if (IS_ERR(m)) {
 		err = PTR_ERR(m);
 		goto err_out;
@@ -755,6 +754,11 @@ skip_attr_list_load:
 			/* No index allocation. */
 			vi->i_size = ni->initialized_size =
 					ni->allocated_size = 0;
+			/* We are done with the mft record, so we release it. */
+			put_attr_search_ctx(ctx);
+			unmap_mft_record(ni);
+			m = NULL;
+			ctx = NULL;
 			goto skip_large_dir_stuff;
 		} /* LARGE_INDEX: Index allocation present. Setup state. */
 		NInoSetIndexAllocPresent(ni);
@@ -799,7 +803,14 @@ skip_attr_list_load:
 				ctx->attr->_ANR(initialized_size));
 		ni->allocated_size = sle64_to_cpu(
 				ctx->attr->_ANR(allocated_size));
-
+		/*
+		 * We are done with the mft record, so we release it. Otherwise
+		 * we would deadlock in ntfs_attr_iget().
+		 */
+		put_attr_search_ctx(ctx);
+		unmap_mft_record(ni);
+		m = NULL;
+		ctx = NULL;
 		/* Get the index bitmap attribute inode. */
 		bvi = ntfs_attr_iget(vi, AT_BITMAP, I30, 4);
 		if (unlikely(IS_ERR(bvi))) {
@@ -823,7 +834,6 @@ skip_attr_list_load:
 					bvi->i_size << 3, vi->i_size);
 			goto unm_err_out;
 		}
-
 skip_large_dir_stuff:
 		/* Everyone gets read and scan permissions. */
 		vi->i_mode |= S_IRUGO | S_IXUGO;
@@ -963,6 +973,11 @@ skip_large_dir_stuff:
 				le32_to_cpu(ctx->attr->_ARA(value_length));
 		}
 no_data_attr_special_case:
+		/* We are done with the mft record, so we release it. */
+		put_attr_search_ctx(ctx);
+		unmap_mft_record(ni);
+		m = NULL;
+		ctx = NULL;
 		/* Everyone gets all permissions. */
 		vi->i_mode |= S_IRWXUGO;
 		/* If read-only, noone gets write permissions. */
@@ -991,9 +1006,6 @@ no_data_attr_special_case:
 	else
 		vi->i_blocks = ni->_ICF(compressed_size) >> 9;
 
-	put_attr_search_ctx(ctx);
-	unmap_mft_record(READ, ni);
-
 	ntfs_debug("Done.");
 	return;
 unm_err_out:
@@ -1001,7 +1013,8 @@ unm_err_out:
 		err = -EIO;
 	if (ctx)
 		put_attr_search_ctx(ctx);
-	unmap_mft_record(READ, ni);
+	if (m)
+		unmap_mft_record(ni);
 err_out:
 	ntfs_error(vi->i_sb, "Failed with error code %i. Marking inode 0x%lx "
 			"as bad.", -err, vi->i_ino);
@@ -1055,7 +1068,7 @@ static int ntfs_read_locked_attr_inode(s
 	/* Set inode type to zero but preserve permissions. */
 	vi->i_mode	= base_vi->i_mode & ~S_IFMT;
 
-	m = map_mft_record(READ, base_ni);
+	m = map_mft_record(base_ni);
 	if (IS_ERR(m)) {
 		err = PTR_ERR(m);
 		goto err_out;
@@ -1229,7 +1242,7 @@ static int ntfs_read_locked_attr_inode(s
 	ni->nr_extents = -1;
 
 	put_attr_search_ctx(ctx);
-	unmap_mft_record(READ, base_ni);
+	unmap_mft_record(base_ni);
 
 	ntfs_debug("Done.");
 	return 0;
@@ -1239,7 +1252,7 @@ unm_err_out:
 		err = -EIO;
 	if (ctx)
 		put_attr_search_ctx(ctx);
-	unmap_mft_record(READ, base_ni);
+	unmap_mft_record(base_ni);
 err_out:
 	ntfs_error(vi->i_sb, "Failed with error code %i while reading "
 			"attribute inode (mft_no 0x%lx, type 0x%x, name_len "
@@ -1364,7 +1377,7 @@ void ntfs_read_inode_mount(struct inode 
 	/* Need this to sanity check attribute list references to $MFT. */
 	ni->seq_no = le16_to_cpu(m->sequence_number);
 
-	/* Provides readpage() and sync_page() for map_mft_record(READ). */
+	/* Provides readpage() and sync_page() for map_mft_record(). */
 	vi->i_mapping->a_ops = &ntfs_mft_aops;
 
 	ctx = get_attr_search_ctx(ni, m);
@@ -1761,8 +1774,8 @@ void __ntfs_clear_inode(ntfs_inode *ni)
 		}
 	}
 	/* Synchronize with ntfs_commit_inode(). */
-	down_write(&ni->mrec_lock);
-	up_write(&ni->mrec_lock);
+	down(&ni->mrec_lock);
+	up(&ni->mrec_lock);
 	if (NInoDirty(ni)) {
 		ntfs_error(ni->vol->sb, "Failed to commit dirty inode "
 				"asynchronously.");
@@ -1836,7 +1849,7 @@ void ntfs_clear_big_inode(struct inode *
 			ni->_INE(base_ntfs_ino) = NULL;
 		}
 	}
-	BUG_ON(atomic_read(&ni->mft_count) || !atomic_dec_and_test(&ni->count));
+	BUG_ON(ni->page || !atomic_dec_and_test(&ni->count));
 	return;
 }
 
diff -urNp linux-2.4.19-tg3-ntfs-2.0.22b/fs/ntfs/inode.h linux-2.4.19-tg3-ntfs-2.0.23a/fs/ntfs/inode.h
--- linux-2.4.19-tg3-ntfs-2.0.22b/fs/ntfs/inode.h	Sun Aug  4 21:12:32 2002
+++ linux-2.4.19-tg3-ntfs-2.0.23a/fs/ntfs/inode.h	Sun Aug  4 21:14:21 2002
@@ -77,9 +77,8 @@ struct _ntfs_inode {
 	 * The following fields are only valid for real inodes and extent
 	 * inodes.
 	 */
-	struct rw_semaphore mrec_lock;	/* Lock for serializing access to the
+	struct semaphore mrec_lock; /* Lock for serializing access to the
 				   mft record belonging to this inode. */
-	atomic_t mft_count;	/* Mapping reference count for book keeping. */
 	struct page *page;	/* The page containing the mft record of the
 				   inode. This should only be touched by the
 				   (un)map_mft_record*() functions. */
diff -urNp linux-2.4.19-tg3-ntfs-2.0.22b/fs/ntfs/kcompat.h linux-2.4.19-tg3-ntfs-2.0.23a/fs/ntfs/kcompat.h
--- linux-2.4.19-tg3-ntfs-2.0.22b/fs/ntfs/kcompat.h	Sun Aug  4 21:12:32 2002
+++ linux-2.4.19-tg3-ntfs-2.0.23a/fs/ntfs/kcompat.h	Sun Aug  4 21:14:25 2002
@@ -25,10 +25,6 @@
 #define _LINUX_NTFS_KCOMPAT_H
 
 #include <linux/version.h>
-
-/* Just in case someone would like to use it with 2.5.x ;-) */
-#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
-
 #include <linux/compiler.h>
 
 #ifndef MAX_BUF_PER_PAGE
@@ -45,11 +41,6 @@
 #  define MAX_LFS_FILESIZE        0x7fffffffffffffff
 #endif
 
-#ifndef CONFIG_PREEMPT
-#  define preempt_disable()	do {} while (0);
-#  define preempt_enable()	do {} while (0);
-#endif
-
 #include <linux/fs.h>
 
 /*
@@ -83,24 +74,4 @@ BUFFER_FNS(Uptodate, uptodate)
 BUFFER_FNS(Async, async)
 TAS_BUFFER_FNS(Lock, locked)
 
-#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,4,19))
-/* Copied from 2.5.x: fs/block_dev.c. This function was introduced with
-   2.4.19-pre8 kernel version. If you use some post pre7 version but earlier
-   then 2.4.19 release you will want to remove these -- pkot */
-static inline int sb_set_blocksize(struct super_block *sb, int size)
-{
-	int bits;
-	if (set_blocksize(sb->s_dev, size) < 0)
-		return 0;
-	sb->s_blocksize = size;
-	for (bits = 9, size >>= 9; size >>= 1; bits++)
-		;
-	sb->s_blocksize_bits = bits;
-	return sb->s_blocksize;
-}
-
-#endif /* Linux 2.4.18 and older */
-
-#endif /* Linux 2.4.x */
-
 #endif /* _LINUX_NTFS_KCOMPAT_H */
diff -urNp linux-2.4.19-tg3-ntfs-2.0.22b/fs/ntfs/malloc.h linux-2.4.19-tg3-ntfs-2.0.23a/fs/ntfs/malloc.h
--- linux-2.4.19-tg3-ntfs-2.0.22b/fs/ntfs/malloc.h	Sun Aug  4 21:12:52 2002
+++ linux-2.4.19-tg3-ntfs-2.0.23a/fs/ntfs/malloc.h	Sun Aug  4 21:14:54 2002
@@ -26,20 +26,6 @@
 #include <linux/slab.h>
 
 /**
- * vmalloc_nofs - allocate any pages but don't allow calls into fs layer
- * @size:	number of bytes to allocate
- *
- * Allocate any pages but don't allow calls into fs layer. Return allocated
- * memory or NULL if insufficient memory.
- */
-static inline void *vmalloc_nofs(unsigned long size)
-{
-	if (likely(size >> PAGE_SHIFT < num_physpages))
-		return __vmalloc(size, GFP_NOFS | __GFP_HIGHMEM, PAGE_KERNEL);
-	return NULL;
-}
-
-/**
  * ntfs_malloc_nofs - allocate memory in multiples of pages
  * @size	number of bytes to allocate
  *
@@ -66,7 +52,8 @@ static inline void *ntfs_malloc_nofs(uns
 
 static inline void ntfs_free(void *addr)
 {
-	if (likely((unsigned long)addr < VMALLOC_START)) {
+	if (likely(((unsigned long)addr < VMALLOC_START) ||
+			((unsigned long)addr >= VMALLOC_END ))) {
 		return kfree(addr);
 		/* return free_page((unsigned long)addr); */
 	}
diff -urNp linux-2.4.19-tg3-ntfs-2.0.22b/fs/ntfs/mft.c linux-2.4.19-tg3-ntfs-2.0.23a/fs/ntfs/mft.c
--- linux-2.4.19-tg3-ntfs-2.0.22b/fs/ntfs/mft.c	Sun Aug  4 21:12:42 2002
+++ linux-2.4.19-tg3-ntfs-2.0.23a/fs/ntfs/mft.c	Sun Aug  4 21:14:21 2002
@@ -2,7 +2,7 @@
  * mft.c - NTFS kernel mft record operations. Part of the Linux-NTFS project.
  *
  * Copyright (c) 2001,2002 Anton Altaparmakov.
- * Copyright (C) 2002 Richard Russon.
+ * Copyright (c) 2002 Richard Russon.
  *
  * This program/include file is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as published
@@ -86,13 +86,15 @@ int format_mft_record(ntfs_inode *ni, MF
 	if (mft_rec)
 		m = mft_rec;
 	else {
-		m = map_mft_record(WRITE, ni);
+		m = map_mft_record(ni);
 		if (IS_ERR(m))
 			return PTR_ERR(m);
 	}
 	__format_mft_record(m, ni->vol->mft_record_size, ni->mft_no);
-	if (!mft_rec)
-		unmap_mft_record(WRITE, ni);
+	if (!mft_rec) {
+		// FIXME: Need to set the mft record dirty!
+		unmap_mft_record(ni);
+	}
 	return 0;
 }
 
@@ -108,12 +110,12 @@ extern int ntfs_readpage(struct file *, 
  * ntfs_map_page() in map_mft_record_page().
  */
 struct address_space_operations ntfs_mft_aops = {
-	writepage:	NULL,			/* Write dirty page to disk. */
-	readpage:	ntfs_readpage,		/* Fill page with data. */
-	sync_page:	block_sync_page,	/* Currently, just unplugs the
+	.writepage	= NULL,			/* Write dirty page to disk. */
+	.readpage	= ntfs_readpage,	/* Fill page with data. */
+	.sync_page	= block_sync_page,	/* Currently, just unplugs the
 						   disk request queue. */
-	prepare_write:	NULL,			/* . */
-	commit_write:	NULL,			/* . */
+	.prepare_write	= NULL,			/* . */
+	.commit_write	= NULL,			/* . */
 };
 
 /**
@@ -133,7 +135,7 @@ static inline MFT_RECORD *map_mft_record
 	struct page *page;
 	unsigned long index, ofs, end_index;
 
-	BUG_ON(atomic_read(&ni->mft_count) || ni->page);
+	BUG_ON(ni->page);
 	/*
 	 * The index into the page cache and the offset within the page cache
 	 * page of the wanted mft record. FIXME: We need to check for
@@ -147,70 +149,36 @@ static inline MFT_RECORD *map_mft_record
 	end_index = mft_vi->i_size >> PAGE_CACHE_SHIFT;
 
 	/* If the wanted index is out of bounds the mft record doesn't exist. */
-	if (index >= end_index) {
+	if (unlikely(index >= end_index)) {
 		if (index > end_index || (mft_vi->i_size & ~PAGE_CACHE_MASK) <
 				ofs + vol->mft_record_size) {
 			page = ERR_PTR(-ENOENT);
-			goto up_err_out;
+			goto err_out;
 		}
 	}
 	/* Read, map, and pin the page. */
 	page = ntfs_map_page(mft_vi->i_mapping, index);
-	if (!IS_ERR(page)) {
-		/* Pin the mft record mapping in the ntfs_inode. */
-		atomic_inc(&ni->mft_count);
-
-		/* Setup the references in the ntfs_inode. */
+	if (likely(!IS_ERR(page))) {
 		ni->page = page;
 		ni->page_ofs = ofs;
-
 		return page_address(page) + ofs;
 	}
-up_err_out:
-	/* Just in case... */
+err_out:
 	ni->page = NULL;
 	ni->page_ofs = 0;
-
 	ntfs_error(vol->sb, "Failed with error code %lu.", -PTR_ERR(page));
 	return (void*)page;
 }
 
 /**
- * unmap_mft_record_page - unmap the page in which a specific mft record resides
- * @ni:		ntfs inode whose mft record page to unmap
- *
- * This unmaps the page in which the mft record of the ntfs inode @ni is
- * situated and returns. This is a NOOP if highmem is not configured.
- *
- * The unmap happens via ntfs_unmap_page() which in turn decrements the use
- * count on the page thus releasing it from the pinned state.
- *
- * We do not actually unmap the page from memory of course, as that will be
- * done by the page cache code itself when memory pressure increases or
- * whatever.
- */
-static inline void unmap_mft_record_page(ntfs_inode *ni)
-{
-	BUG_ON(atomic_read(&ni->mft_count) || !ni->page);
-	// TODO: If dirty, blah...
-	ntfs_unmap_page(ni->page);
-	ni->page = NULL;
-	ni->page_ofs = 0;
-	return;
-}
-
-/**
  * map_mft_record - map, pin and lock an mft record
- * @rw:		map for read (rw = READ) or write (rw = WRITE)
  * @ni:		ntfs inode whose MFT record to map
  *
- * First, take the mrec_lock semaphore for reading or writing, depending on
- * the value or @rw. We might now be sleeping, while waiting for the semaphore
- * if it was already locked by someone else.
- *
- * Then increment the map reference count and return the mft. If this is the
- * first invocation, the page of the record is first mapped using
- * map_mft_record_page().
+ * First, take the mrec_lock semaphore. We might now be sleeping, while waiting
+ * for the semaphore if it was already locked by someone else.
+ *
+ * The page of the record is mapped using map_mft_record_page() before being
+ * returned to the caller.
  *
  * This in turn uses ntfs_map_page() to get the page containing the wanted mft
  * record (it in turn calls read_cache_page() which reads it in from disk if
@@ -235,11 +203,11 @@ static inline void unmap_mft_record_page
  * locking problem then is them locking the page while we are accessing it.
  *
  * So that code will end up having to own the mrec_lock of all mft
- * records/inodes present in the page before I/O can proceed. Grr. In that
- * case we wouldn't need need to bother with PG_locked and PG_uptodate as
- * nobody will be accessing anything without owning the mrec_lock semaphore.
- * But we do need to use them because of the read_cache_page() invokation and
- * the code becomes so much simpler this way that it is well worth it.
+ * records/inodes present in the page before I/O can proceed. In that case we
+ * wouldn't need need to bother with PG_locked and PG_uptodate as nobody will
+ * be accessing anything without owning the mrec_lock semaphore. But we do need
+ * to use them because of the read_cache_page() invokation and the code becomes
+ * so much simpler this way that it is well worth it.
  *
  * The mft record is now ours and we return a pointer to it. You need to check
  * the returned pointer with IS_ERR() and if that is true, PTR_ERR() will return
@@ -252,89 +220,75 @@ static inline void unmap_mft_record_page
  * A: No, the inode ones mean we want to change the mft record, not we want to
  * write it out.
  */
-MFT_RECORD *map_mft_record(const int rw, ntfs_inode *ni)
+MFT_RECORD *map_mft_record(ntfs_inode *ni)
 {
 	MFT_RECORD *m;
 
-	ntfs_debug("Entering for mft_no 0x%lx, mapping for %s.", ni->mft_no,
-			rw == READ ? "READ" : "WRITE");
+	ntfs_debug("Entering for mft_no 0x%lx", ni->mft_no);
 
 	/* Make sure the ntfs inode doesn't go away. */
 	atomic_inc(&ni->count);
 
 	/* Serialize access to this mft record. */
-	if (rw == READ)
-		down_read(&ni->mrec_lock);
-	else
-		down_write(&ni->mrec_lock);
-
-	/* If already mapped, bump reference count and return the mft record. */
-	if (atomic_read(&ni->mft_count)) {
-		BUG_ON(!ni->page);
-		atomic_inc(&ni->mft_count);
-		return page_address(ni->page) + ni->page_ofs;
-	}
+	down(&ni->mrec_lock);
 
-	/* Wasn't mapped. Map it now and return it if all was ok. */
 	m = map_mft_record_page(ni);
-	if (!IS_ERR(m))
+	if (likely(!IS_ERR(m)))
 		return m;
 
-	/* Mapping failed. Release the mft record lock. */
-	if (rw == READ)
-		up_read(&ni->mrec_lock);
-	else
-		up_write(&ni->mrec_lock);
-
-	ntfs_error(ni->vol->sb, "Failed with error code %lu.", -PTR_ERR(m));
-
-	/* Release the ntfs inode and return the error code. */
+	up(&ni->mrec_lock);
 	atomic_dec(&ni->count);
+	ntfs_error(ni->vol->sb, "Failed with error code %lu.", -PTR_ERR(m));
 	return m;
 }
 
 /**
- * unmap_mft_record - release a mapped mft record
- * @rw:		unmap from read (@rw = READ) or write (@rw = WRITE)
- * @ni:		ntfs inode whose MFT record to unmap
- *
- * First, decrement the mapping count and when it reaches zero unmap the mft
- * record.
+ * unmap_mft_record_page - unmap the page in which a specific mft record resides
+ * @ni:		ntfs inode whose mft record page to unmap
  *
- * Second, release the mrec_lock semaphore.
+ * This unmaps the page in which the mft record of the ntfs inode @ni is
+ * situated and returns. This is a NOOP if highmem is not configured.
  *
- * The mft record is now released for others to get hold of.
+ * The unmap happens via ntfs_unmap_page() which in turn decrements the use
+ * count on the page thus releasing it from the pinned state.
  *
- * Finally, release the ntfs inode by decreasing the ntfs inode reference count.
+ * We do not actually unmap the page from memory of course, as that will be
+ * done by the page cache code itself when memory pressure increases or
+ * whatever.
+ */
+static inline void unmap_mft_record_page(ntfs_inode *ni)
+{
+	BUG_ON(!ni->page);
+
+	// TODO: If dirty, blah...
+	ntfs_unmap_page(ni->page);
+	ni->page = NULL;
+	ni->page_ofs = 0;
+	return;
+}
+
+/**
+ * unmap_mft_record - release a mapped mft record
+ * @ni:		ntfs inode whose MFT record to unmap
  *
- * NOTE: If caller had the mft record mapped for write and has modified it, it
- * is imperative to set the mft record dirty BEFORE calling unmap_mft_record().
+ * We release the page mapping and the mrec_lock mutex which unmaps the mft
+ * record and releases it for others to get hold of. We also release the ntfs
+ * inode by decrementing the ntfs inode reference count.
  *
- * NOTE: This has to be done both for 'normal' mft records, and for extent mft
- * records.
+ * NOTE: If caller has modified the mft record, it is imperative to set the mft
+ * record dirty BEFORE calling unmap_mft_record().
  */
-void unmap_mft_record(const int rw, ntfs_inode *ni)
+void unmap_mft_record(ntfs_inode *ni)
 {
 	struct page *page = ni->page;
 
-	BUG_ON(!atomic_read(&ni->mft_count) || !page);
+	BUG_ON(!page);
 
-	ntfs_debug("Entering for mft_no 0x%lx, unmapping from %s.", ni->mft_no,
-			rw == READ ? "READ" : "WRITE");
+	ntfs_debug("Entering for mft_no 0x%lx", ni->mft_no);
 
-	/* Only release the actual page mapping if this is the last one. */
-	if (atomic_dec_and_test(&ni->mft_count))
-		unmap_mft_record_page(ni);
-
-	/* Release the semaphore. */
-	if (rw == READ)
-		up_read(&ni->mrec_lock);
-	else
-		up_write(&ni->mrec_lock);
-
-	/* Release the ntfs inode. */
+	unmap_mft_record_page(ni);
+	up(&ni->mrec_lock);
 	atomic_dec(&ni->count);
-
 	/*
 	 * If pure ntfs_inode, i.e. no vfs inode attached, we leave it to
 	 * ntfs_clear_extent_inode() in the extent inode case, and to the
@@ -356,11 +310,6 @@ void unmap_mft_record(const int rw, ntfs
  *
  * On successful return, @ntfs_ino contains a pointer to the ntfs_inode
  * structure of the mapped extent inode.
- *
- * Note, we always map for READ. We consider this lock as irrelevant because
- * the base inode will be write locked in all cases when we want to write to
- * an extent inode which already gurantees that there is no-one else accessing
- * the extent inode.
  */
 MFT_RECORD *map_extent_mft_record(ntfs_inode *base_ni, MFT_REF mref,
 		ntfs_inode **ntfs_ino)
@@ -394,21 +343,21 @@ MFT_RECORD *map_extent_mft_record(ntfs_i
 			break;
 		}
 	}
-	if (ni) {
+	if (likely(ni != NULL)) {
 		up(&base_ni->extent_lock);
 		atomic_dec(&base_ni->count);
 		/* We found the record; just have to map and return it. */
-		m = map_mft_record(READ, ni);
-		/* Map mft record increments this on success. */
+		m = map_mft_record(ni);
+		/* map_mft_record() has incremented this on success. */
 		atomic_dec(&ni->count);
-		if (!IS_ERR(m)) {
+		if (likely(!IS_ERR(m))) {
 			/* Verify the sequence number. */
-			if (le16_to_cpu(m->sequence_number) == seq_no) {
+			if (likely(le16_to_cpu(m->sequence_number) == seq_no)) {
 				ntfs_debug("Done 1.");
 				*ntfs_ino = ni;
 				return m;
 			}
-			unmap_mft_record(READ, ni);
+			unmap_mft_record(ni);
 			ntfs_error(base_ni->vol->sb, "Found stale extent mft "
 					"reference! Corrupt file system. "
 					"Run chkdsk.");
@@ -421,7 +370,7 @@ map_err_out:
 	}
 	/* Record wasn't there. Get a new ntfs inode and initialize it. */
 	ni = ntfs_new_extent_inode(base_ni->vol->sb, mft_no);
-	if (!ni) {
+	if (unlikely(!ni)) {
 		up(&base_ni->extent_lock);
 		atomic_dec(&base_ni->count);
 		return ERR_PTR(-ENOMEM);
@@ -431,15 +380,15 @@ map_err_out:
 	ni->nr_extents = -1;
 	ni->_INE(base_ntfs_ino) = base_ni;
 	/* Now map the record. */
-	m = map_mft_record(READ, ni);
-	if (IS_ERR(m)) {
+	m = map_mft_record(ni);
+	if (unlikely(IS_ERR(m))) {
 		up(&base_ni->extent_lock);
 		atomic_dec(&base_ni->count);
 		ntfs_clear_extent_inode(ni);
 		goto map_err_out;
 	}
 	/* Verify the sequence number. */
-	if (le16_to_cpu(m->sequence_number) != seq_no) {
+	if (unlikely(le16_to_cpu(m->sequence_number) != seq_no)) {
 		ntfs_error(base_ni->vol->sb, "Found stale extent mft "
 				"reference! Corrupt file system. Run chkdsk.");
 		destroy_ni = TRUE;
@@ -452,7 +401,7 @@ map_err_out:
 		int new_size = (base_ni->nr_extents + 4) * sizeof(ntfs_inode *);
 
 		tmp = (ntfs_inode **)kmalloc(new_size, GFP_NOFS);
-		if (!tmp) {
+		if (unlikely(!tmp)) {
 			ntfs_error(base_ni->vol->sb, "Failed to allocate "
 					"internal buffer.");
 			destroy_ni = TRUE;
@@ -473,7 +422,7 @@ map_err_out:
 	*ntfs_ino = ni;
 	return m;
 unm_err_out:
-	unmap_mft_record(READ, ni);
+	unmap_mft_record(ni);
 	up(&base_ni->extent_lock);
 	atomic_dec(&base_ni->count);
 	/*
diff -urNp linux-2.4.19-tg3-ntfs-2.0.22b/fs/ntfs/mft.h linux-2.4.19-tg3-ntfs-2.0.23a/fs/ntfs/mft.h
--- linux-2.4.19-tg3-ntfs-2.0.22b/fs/ntfs/mft.h	Sun Aug  4 21:13:13 2002
+++ linux-2.4.19-tg3-ntfs-2.0.23a/fs/ntfs/mft.h	Sun Aug  4 21:14:53 2002
@@ -31,15 +31,15 @@ extern int format_mft_record(ntfs_inode 
 //extern int format_mft_record2(struct super_block *vfs_sb,
 //		const unsigned long inum, MFT_RECORD *m);
 
-extern MFT_RECORD *map_mft_record(const int rw, ntfs_inode *ni);
-extern void unmap_mft_record(const int rw, ntfs_inode *ni);
+extern MFT_RECORD *map_mft_record(ntfs_inode *ni);
+extern void unmap_mft_record(ntfs_inode *ni);
 
 extern MFT_RECORD *map_extent_mft_record(ntfs_inode *base_ni, MFT_REF mref,
 		ntfs_inode **ntfs_ino);
 
 static inline void unmap_extent_mft_record(ntfs_inode *ni)
 {
-	unmap_mft_record(READ, ni);
+	unmap_mft_record(ni);
 	return;
 }
 
diff -urNp linux-2.4.19-tg3-ntfs-2.0.22b/fs/ntfs/namei.c linux-2.4.19-tg3-ntfs-2.0.23a/fs/ntfs/namei.c
--- linux-2.4.19-tg3-ntfs-2.0.22b/fs/ntfs/namei.c	Sun Aug  4 21:12:41 2002
+++ linux-2.4.19-tg3-ntfs-2.0.23a/fs/ntfs/namei.c	Sun Aug  4 21:14:23 2002
@@ -164,6 +164,7 @@ static struct dentry *ntfs_lookup(struct
 handle_name:
    {
 	struct dentry *real_dent;
+	MFT_RECORD *m;
 	attr_search_context *ctx;
 	ntfs_inode *ni = NTFS_I(dent_inode);
 	int err;
@@ -177,22 +178,23 @@ handle_name:
 				name->len * 3 + 1);
 		kfree(name);
 	} else /* if (name->type == FILE_NAME_DOS) */ {		/* Case 3. */
-		MFT_RECORD *m;
 		FILE_NAME_ATTR *fn;
 
 		kfree(name);
 
 		/* Find the WIN32 name corresponding to the matched DOS name. */
 		ni = NTFS_I(dent_inode);
-		m = map_mft_record(READ, ni);
+		m = map_mft_record(ni);
 		if (IS_ERR(m)) {
 			err = PTR_ERR(m);
-			goto name_err_out;
+			m = NULL;
+			ctx = NULL;
+			goto err_out;
 		}
 		ctx = get_attr_search_ctx(ni, m);
 		if (!ctx) {
 			err = -ENOMEM;
-			goto unm_err_out;
+			goto err_out;
 		}
 		do {
 			ATTR_RECORD *a;
@@ -204,21 +206,21 @@ handle_name:
 						"namespace counterpart to DOS "
 						"file name. Run chkdsk.");
 				err = -EIO;
-				goto put_unm_err_out;
+				goto err_out;
 			}
 			/* Consistency checks. */
 			a = ctx->attr;
 			if (a->non_resident || a->flags)
-				goto eio_put_unm_err_out;
+				goto eio_err_out;
 			val_len = le32_to_cpu(a->_ARA(value_length));
 			if (le16_to_cpu(a->_ARA(value_offset)) + val_len >
 					le32_to_cpu(a->length))
-				goto eio_put_unm_err_out;
+				goto eio_err_out;
 			fn = (FILE_NAME_ATTR*)((u8*)ctx->attr + le16_to_cpu(
 					ctx->attr->_ARA(value_offset)));
 			if ((u32)(fn->file_name_length * sizeof(uchar_t) +
 					sizeof(FILE_NAME_ATTR)) > val_len)
-				goto eio_put_unm_err_out;
+				goto eio_err_out;
 		} while (fn->file_name_type != FILE_NAME_WIN32);
 
 		/* Convert the found WIN32 name to current NLS code page. */
@@ -228,13 +230,15 @@ handle_name:
 				fn->file_name_length * 3 + 1);
 
 		put_attr_search_ctx(ctx);
-		unmap_mft_record(READ, ni);
+		unmap_mft_record(ni);
 	}
+	m = NULL;
+	ctx = NULL;
 
 	/* Check if a conversion error occured. */
 	if ((signed)nls_name.len < 0) {
 		err = (signed)nls_name.len;
-		goto name_err_out;
+		goto err_out;
 	}
 	nls_name.hash = full_name_hash(nls_name.name, nls_name.len);
 
@@ -250,7 +254,7 @@ handle_name:
 		kfree(nls_name.name);
 		if (!real_dent) {
 			err = -ENOMEM;
-			goto name_err_out;
+			goto err_out;
 		}
 		d_add(real_dent, dent_inode);
 		return real_dent;
@@ -271,14 +275,14 @@ handle_name:
 	d_instantiate(real_dent, dent_inode);
 	return real_dent;
 
-eio_put_unm_err_out:
+eio_err_out:
 	ntfs_error(vol->sb, "Illegal file name attribute. Run chkdsk.");
 	err = -EIO;
-put_unm_err_out:
-	put_attr_search_ctx(ctx);
-unm_err_out:
-	unmap_mft_record(READ, ni);
-name_err_out:
+err_out:
+	if (ctx)
+		put_attr_search_ctx(ctx);
+	if (m)
+		unmap_mft_record(ni);
 	iput(dent_inode);
 	return ERR_PTR(err);
    }
@@ -288,6 +292,6 @@ name_err_out:
  * Inode operations for directories.
  */
 struct inode_operations ntfs_dir_inode_ops = {
-	lookup:		ntfs_lookup,	/* VFS: Lookup directory. */
+	.lookup	= ntfs_lookup,	/* VFS: Lookup directory. */
 };
 
diff -urNp linux-2.4.19-tg3-ntfs-2.0.22b/fs/ntfs/super.c linux-2.4.19-tg3-ntfs-2.0.23a/fs/ntfs/super.c
--- linux-2.4.19-tg3-ntfs-2.0.22b/fs/ntfs/super.c	Sun Aug  4 21:13:13 2002
+++ linux-2.4.19-tg3-ntfs-2.0.23a/fs/ntfs/super.c	Sun Aug  4 21:14:54 2002
@@ -852,7 +852,7 @@ volume_failed:
 		ntfs_error(sb, "Failed to load $Volume.");
 		goto iput_lcnbmp_err_out;
 	}
-	m = map_mft_record(READ, NTFS_I(vol->vol_ino));
+	m = map_mft_record(NTFS_I(vol->vol_ino));
 	if (IS_ERR(m)) {
 iput_volume_failed:
 		iput(vol->vol_ino);
@@ -867,7 +867,7 @@ iput_volume_failed:
 err_put_vol:
 		put_attr_search_ctx(ctx);
 get_ctx_vol_failed:
-		unmap_mft_record(READ, NTFS_I(vol->vol_ino));
+		unmap_mft_record(NTFS_I(vol->vol_ino));
 		goto iput_volume_failed;
 	}
 	vi = (VOLUME_INFORMATION*)((char*)ctx->attr +
@@ -882,7 +882,7 @@ get_ctx_vol_failed:
 	vol->major_ver = vi->major_ver;
 	vol->minor_ver = vi->minor_ver;
 	put_attr_search_ctx(ctx);
-	unmap_mft_record(READ, NTFS_I(vol->vol_ino));
+	unmap_mft_record(NTFS_I(vol->vol_ino));
 	printk(KERN_INFO "NTFS volume version %i.%i.\n", vol->major_ver,
 			vol->minor_ver);
 	/*
@@ -1260,9 +1260,9 @@ static int ntfs_statfs(struct super_bloc
  * proper functions.
  */
 struct super_operations ntfs_mount_sops = {
-	read_inode:	ntfs_read_inode_mount,	/* VFS: Load inode from disk,
+	.read_inode	= ntfs_read_inode_mount,/* VFS: Load inode from disk,
 						   called from iget(). */
-	clear_inode:	ntfs_clear_big_inode,	/* VFS: Called when an inode is
+	.clear_inode	= ntfs_clear_big_inode,	/* VFS: Called when an inode is
 						   removed from memory. */
 };
 
@@ -1272,19 +1272,21 @@ typedef void (*read_inode2_t)(struct ino
  * The complete super operations.
  */
 struct super_operations ntfs_sops = {
-	read_inode2:	(read_inode2_t)ntfs_read_locked_inode, /* VFS: Load
+	.read_inode2	= (read_inode2_t)ntfs_read_locked_inode, /* VFS: Load
 						   inode from disk, called from
 						   ntfs_iget(). */
-	dirty_inode:	ntfs_dirty_inode,	/* VFS: Called from
+	.dirty_inode	= ntfs_dirty_inode,	/* VFS: Called from
 						   __mark_inode_dirty(). */
-	put_inode:	ntfs_put_inode,	/* VFS: Called just before the inode
-					   reference count is decreased. */
-	put_super:	ntfs_put_super,	/* Syscall: umount. */
-	statfs:		ntfs_statfs,	/* Syscall: statfs */
-	remount_fs:	ntfs_remount,	/* Syscall: mount -o remount. */
-	clear_inode:	ntfs_clear_big_inode,	/* VFS: Called when an inode is
+	.put_inode	= ntfs_put_inode,	/* VFS: Called just before the
+						   inode reference count is
+						   decreased. */
+	.put_super	= ntfs_put_super,	/* Syscall: umount. */
+	.statfs		= ntfs_statfs,		/* Syscall: statfs */
+	.remount_fs	= ntfs_remount,		/* Syscall: mount -o remount. */
+	.clear_inode	= ntfs_clear_big_inode,	/* VFS: Called when an inode is
 						   removed from memory. */
-	show_options:	ntfs_show_options, /* Show mount options in proc. */
+	.show_options	= ntfs_show_options, 	/* Show mount options in
+						   proc. */
 };
 
 /**
diff -urNp linux-2.4.19-tg3-ntfs-2.0.22b/include/linux/dcache.h linux-2.4.19-tg3-ntfs-2.0.23a/include/linux/dcache.h
--- linux-2.4.19-tg3-ntfs-2.0.22b/include/linux/dcache.h	Sun Aug  4 21:13:11 2002
+++ linux-2.4.19-tg3-ntfs-2.0.23a/include/linux/dcache.h	Sun Aug  4 21:14:52 2002
@@ -5,6 +5,7 @@
 
 #include <asm/atomic.h>
 #include <linux/mount.h>
+#include <linux/kernel.h>
 
 /*
  * linux/include/linux/dcache.h

[Linux-NTFS-Dev] [ANNOUNCE] NTFS 2.0.22a for Linux 2.4.19

[Pawel K. <pk...@li...>]

Hi,

New version of the NTFS-TNG backport is out. This version syncs with both:
the latest NTFS driver -- 2.0.22 and the latest Linux kernel -- 2.4.19.

You can get the patch from the sourceforge servers. See the detailes at
http://linux-ntfs.sf.net/downloads.html

regards,
pkot
-- 
Pawel Kot <pk...@li...>
http://www.gnokii.org/ :: http://www.slackware.pl/
http://kt.linuxnews.pl/ -- Kernel Traffic po polsku

Re: [Linux-NTFS-Dev] delayed allocation for ntfs?

[Jeff G. <jg...@ma...>]

Anton Altaparmakov wrote:
> Hi,
> 
> btw. Jeff, your IbuFS supports delayed allocation, doesn't it? Can I 
> have a copy of the source to look at? XFS seems horrendously complex and 
> reimplements the almost the entire fs/buffer.c and mm/filemap.c to make 
> it work and that seems just a touch over the top. I am not aware of any 
> other FS on Linux doing delayed allocation at present...

Nope, it's just a basic extent-based fs at this point.

Andrew Morton posted delayed-alloc patches for ext2 and/or ext3 a while 
ago, so that's something to look at.  I think there were problems with 
the patch itself and also VM problems which meant that it wasn't very 
useful in his tests.

> 
> At 01:46 20/07/02, Jeff Garzik wrote:
> 
>> * You want to reserve space via some sort of internal accounting, to 
>> properly handle ENOSPC
> 
> 
> ok. That is going to be interesting to get right. Perhaps we just need 
> to over account so that we may start returning -ENOSPC when in fact 
> there is space left. Would that be acceptable? Any ideas welcome...

I'm missing a bit of information (or probably, more correctly, 
forgotten):  why can't we accurately account free space?

At worst, you could schedule_task a process that scans the free block 
bitmap, and block any processes that want to allocate new blocks until 
(a) free blocks > 0 or (b) the keventd-launched task ends.


>> * You probably want to either have a pool of pages, as a temporary 
>> backing store, or, grab an extra reference to the page passed to 
>> prepare/commit_write.  For the second, I think you'll want to unlock 
>> the page ASAP, and lock it again later when you start doing I/O on it.
> 
> 
> If we get an extra reference, is the vm ever going to call our writepage 
> (e.g. under memory pressure)? If yes and it doesn't consider the extra 
> reference as "page busy" than that would work nicely.

Better ask a VM expert.  I am just guessing:  it should call writepage 
as long as the page is on the dirty list, regardless of how many people 
have references to the page.  Remember, the page is unlocked when the VM 
would want to do the writeback.  Keeping a reference just means we won't 
lost the page to general page allocation/freeing.


>> * I think compression is better done outside the write path, to keep 
>> it simple and fast.  Maybe something in ntfsprogs could talk to an 
>> ioctl(2) which compresses an open(2)'d file descriptor.
> 
> 
> The problem is what happens with already compressed files?

You don't have to convert 100% of the file data, just the blocks being 
updated.  NTFS TNG should already support files which contain mixed 
compressed and uncompressed runs (I thought??)

If you want to compress in place -- go for it.  My only objection is 
that it's a not-necessary feature in the filesystem's fast path.  If you 
want to put compression support in there and deal with the complexity, 
more power to you :)  It really comes down to the maintainer's call -- 
do I want the bloat and complexity in the kernel or userspace?  The 
upside is the obvious convenience of putting yet another feature in the 
kernel :)



>> The bigger advantage to delayed allocation is the allocation of 
>> contiguous runs.
> 
> 
> The way my cluster allocator works gives you that, too, except that it 
> doesn't work well if more than one file is being written to at once. 
> Then the two get interleaved with one cluster each in the worst case 
> (depends on write(2) chunk size and on cluster size). But I have thought 
> of reserving space on allocations so that this doesn't happen but I 
> haven't tried that yet so no idea how well it would work... And I don't 
> know how to determine how much space to reserve in advance. A static 
> value seems daft, something that would scale depending on write activity 
> would be nice. Obviously delayed allocation would be best...

As long as you allocate-on-flush, you have a single point where you need 
to actually allocate the new blocks, and you can properly interleave there.

But that brings up mmap issues, which also responds to some of your 
comments [which would be further down, if I hadn't edited :)]

It will be worth testing with ->writepage implemented, where are the 
best places to start writing out delayed-alloc pages?

Your entry points are: ->commit_write, ->flush, ->writepage with 
PageLaunder bit set [2.4 specific!], and ->writepage called from kupdated.

And IMHO, your proper points for doing actual I/O are:
1) ->writepage with PageLaunder bit, because the system is saying "get 
rid of this page as fast as possible, I need to free it".  [you'll need 
to find the 2.5 equivalent of ->writepage call case for when the page 
needs evicting]  Basically write the page, ignoring delayed alloc, as 
fast as possible.
2) ->flush, typically the last close of the fd, but in general the point 
where you want to allocate new blocks for delayed I/O pages, and start 
their writeout by dirtying them
3) some internal timeout occurs, and the page hasn't been written to 
disk in N seconds.  if we are delaying kupdated's flushes, we have to do 
them

I think (and VM experts may disagree, it's a question to ask them) that 
you should have ->writepage delay the allocation if it's called from 
kupdated.

So anyway, mmap and ENOSPC.  I think the ext2 behavior here is sane, and 
can be followed even in a delayed-alloc system.  If you adding new 
blocks to a file via mmap(2), clearly you aren't going to see ENOSPC.  I 
think you will get a segfault, actually.  ext2 marks the page with 
PageError if it can't allocate blocks.  That's all you can really do, 
when called from ->writepage.  With prepare/commit_write, the expected 
behavior is to return a value that will be passed straight to userspace, 
in this case ENOSPC.

Overall, your ->writepage implementation will likely be quite different 
from ->prepare/commit_write.  Even though they kinda sorta do the same 
thing :)


>> * FWIW the last close of a file triggers a flush, which might be a 
>> good point for actually allocating blocks
> 
> 
> Odd. I opened a file, wrote to it, exited the editor, did "cat file" and 
> only a few seconds later did the kernel blow up (due to the lacking 
> writepage). Admittedly this may be an artefact of the lacking 
> writepage... We will find out when it is implemented. (-:

Is flush implemented?  If not, it would probably fall back to writepage...


> If you delay the allocation how do you know that that is a hole you are 
> writing into as opposed to data? Or do we always have to check for this 
> kind of thing at prepare_write time? And if we do check, and say we 
> decrement the amount of available space to account for the new data, 
> what happens if someone writes to the same page again? Our check would 
> again return that the page is inside a hole and we would account for it 
> _again_ so we would be overaccounting and run out of space quickly... 

As long as you have a list of pages for whom allocation is delayed, you 
should be fine.  No additional bits necessary.  If it isn't on the list, 
it isn't accounted for.

But since we have the nasty job of writing tons of zeros to disk when 
sparse-file support is absent, I would say that you need a totally 
separate accounting of zero pages delayed, and factor that into the 
overall free-blocks number.

I feel like I'm rambling, so I'll shut up now.  I hope I made some sense :)

	Jeff

Re: [Linux-NTFS-Dev] delayed allocation for ntfs?

[Anton A. <ai...@ca...>]

Hi,

btw. Jeff, your IbuFS supports delayed allocation, doesn't it? Can I have a 
copy of the source to look at? XFS seems horrendously complex and 
reimplements the almost the entire fs/buffer.c and mm/filemap.c to make it 
work and that seems just a touch over the top. I am not aware of any other 
FS on Linux doing delayed allocation at present...

At 01:46 20/07/02, Jeff Garzik wrote:
>* You want to reserve space via some sort of internal accounting, to 
>properly handle ENOSPC

ok. That is going to be interesting to get right. Perhaps we just need to 
over account so that we may start returning -ENOSPC when in fact there is 
space left. Would that be acceptable? Any ideas welcome...

>* You probably want to either have a pool of pages, as a temporary backing 
>store, or, grab an extra reference to the page passed to 
>prepare/commit_write.  For the second, I think you'll want to unlock the 
>page ASAP, and lock it again later when you start doing I/O on it.

If we get an extra reference, is the vm ever going to call our writepage 
(e.g. under memory pressure)? If yes and it doesn't consider the extra 
reference as "page busy" than that would work nicely.

>* I think compression is better done outside the write path, to keep it 
>simple and fast.  Maybe something in ntfsprogs could talk to an ioctl(2) 
>which compresses an open(2)'d file descriptor.

The problem is what happens with already compressed files? Example: I have 
a 1.4GiB file on my ntfs partition and I keep it compressed because it 
compresses really well and saves me a lot of space. Now under Linux I write 
a single byte in the middle of that file. What do we do? Either we have to 
compress the data and save it inside the file or we have to decompress the 
whole file and save it decompressed. Problem being, chances are there is 
not enough space for the decompressed version on the volume. And another 
problem being, decompressing 1.4GiB of data is going to take a fairly long 
time just streaming that much data at maximum platter speed of 38MiB/sec 
would take 37*2 = 74 seconds absolute minimum (that ignores seek times). We 
would need a kernel thread to do this asynchronously, at least the user is 
not going to be impressed if he has to wait 74 seconds before his 1 byte 
write completes...

>The bigger advantage to delayed allocation is the allocation of contiguous 
>runs.

The way my cluster allocator works gives you that, too, except that it 
doesn't work well if more than one file is being written to at once. Then 
the two get interleaved with one cluster each in the worst case (depends on 
write(2) chunk size and on cluster size). But I have thought of reserving 
space on allocations so that this doesn't happen but I haven't tried that 
yet so no idea how well it would work... And I don't know how to determine 
how much space to reserve in advance. A static value seems daft, something 
that would scale depending on write activity would be nice. Obviously 
delayed allocation would be best...

>* FWIW the last close of a file triggers a flush, which might be a good 
>point for actually allocating blocks

Odd. I opened a file, wrote to it, exited the editor, did "cat file" and 
only a few seconds later did the kernel blow up (due to the lacking 
writepage). Admittedly this may be an artefact of the lacking writepage... 
We will find out when it is implemented. (-:

>* A lot of Unix tools do care about free space accounting, and in general, 
>I think it makes a lot of people feel safer if its accurate

Ok. But I don't understand how it can be done in combination with delayed 
allocation. Example: you are writing into a hole inside a file. If you 
delay the allocation how do you know that that is a hole you are writing 
into as opposed to data? Or do we always have to check for this kind of 
thing at prepare_write time? And if we do check, and say we decrement the 
amount of available space to account for the new data, what happens if 
someone writes to the same page again? Our check would again return that 
the page is inside a hole and we would account for it _again_ so we would 
be overaccounting and run out of space quickly... Hm, I guess each page 
would need a PageAccounted() or a PageDelayedAlloc() bit or something like 
that to cope with these cases. But even if we do this we are then working 
at page granularity (or more precisely page cache page granularity) which 
is dumb if we have 512-byte clusters and the write doesn't fill the whole 
page... The more I think about it the more I understand why XFS delayed 
allocation implementation is so complex and why they chose to only 
implement an fs blocksize equal to the page cache page size. (Doesn't seem 
optimal as if you upgrade a Pentium to an Alpha and move your disk allong 
XFS wouldn't be able to read the data IIRC... but I may have misunderstood 
their code...)

Cheers,

         Anton


-- 
   "I've not lost my mind. It's backed up on tape somewhere." - Unknown
-- 
Anton Altaparmakov <aia21 at cantab.net> (replace at with @)
Linux NTFS Maintainer / IRC: #ntfs on irc.openprojects.net
WWW: http://linux-ntfs.sf.net/ & http://www-stu.christs.cam.ac.uk/~aia21/

Re: [Linux-NTFS-Dev] delayed allocation for ntfs?

[Jeff G. <jg...@ma...>]

Random thoughts on delayed allocation:

* You want to reserve space via some sort of internal accounting, to 
properly handle ENOSPC

* You probably want to either have a pool of pages, as a temporary 
backing store, or, grab an extra reference to the page passed to 
prepare/commit_write.  For the second, I think you'll want to unlock the 
page ASAP, and lock it again later when you start doing I/O on it.

* I think compression is better done outside the write path, to keep it 
simple and fast.  Maybe something in ntfsprogs could talk to an ioctl(2) 
which compresses an open(2)'d file descriptor.  The bigger advantage to 
delayed allocation is the allocation of contiguous runs.

* FWIW the last close of a file triggers a flush, which might be a good 
point for actually allocating blocks

* A lot of Unix tools do care about free space accounting, and in 
general, I think it makes a lot of people feel safer if its accurate

	Jeff

Re: [Linux-NTFS-Dev] delayed allocation for ntfs?

[Joseph M. <jma...@st...>]

you could always assume a write to an uncompressed file would cause it to
have 0% compression...

-joe

----- Original Message -----
From: "Anton Altaparmakov" <ai...@ca...>
To: "Jeff Garzik" <jg...@ma...>;
<lin...@li...>
Sent: Friday, July 19, 2002 11:48 AM
Subject: [Linux-NTFS-Dev] delayed allocation for ntfs?


> Hi,
>
> What do you think about using delayed allocation for NTFS. Here is my
idea,
> let me know what you think...
>
> The idea below is based on the simplest thing I could think off, i.e.
there
> is no form of ENOSPC handling in prepare/commit_write.
>
> Ok so here goes:
>
> ntfs_prepare_write()
> ====================
> if (page is uptodate)
>          return success.
> // For non-uptodate pages:
> if (there is an allocation for the destination buffers) {
>          map any partially overlapping buffers;
>          read them synchronously from the backing store;
> } else {
>          // There is no allocation, i.e. hole or data extension
>          zero any partially overlapping buffers;
> }
> return success;
>
> ntfs_commit_write()
> ===================
> mark buffers uptodate, but leave them unmapped;
> update i_size if necessary;
> set_page_dirty();
> return success;
>
> ntfs_writepage() -- analogous to the current ntfs_readpage()
> ================
> - For non-resident, uncompressed attributes, map all *uptodate* buffers,
> allocating if necessary, and finally write them (i.e. only write uptodate
> buffers. if the page is uptodate, write all buffers). (If the attribute is
> mst protected, need to get fully exclusive access to the page,
> pre_write_mst protect the data, then have our async io completion handler
> post_write_mst deprotect the data again before unlocking the page.)
>
> - For non-resident, compressed attributes, compress data chunk, allocate
> space if necessary, finally write out to backing store.
>
> - For resident attributes, may need to convert to non-resident if size has
> grown too big, then go to the non-resident, uncompressed case above. If
> size is still small enough, just copy data to the mft record and mark that
> dirty for later write out (we could force a synchronous write if desired).
>
> Conclusions
> ===========
> The above proposal has the problem of permitting overallocation. So the
> user can overallocate without any form of stopping them. We could just
have
> a stupid check like "if (NVolENOSPC(vol)) return -ENOSPC;" if we want so
> that once we notice we are actually out of space all further writes will
be
> stopped. And we would do a simple NVolSetENOSPC(vol) when we notice we are
> out of space... The cluster deallocator would do a NVolClearENOSPC(vol).
>
> We could of course do more complicated accounting to make sure we will
> never overallocate but that would make everything a lot more
complicated...
>
> Basically my proposal makes ntfs_writepage() the "workhorse" and keeps
> prepare/commit_write() as simple as possible. At the same time this speeds
> up writes a lot as we are not slowed down by allocations at write(2) time
> and allocate on vm writeback/sync instead.
>
> Does this make sense or have I missed something important? Any
> better/alternative ideas are welcome!
>
> What do you think about the necessity for free space accounting? Can we do
> just none? Should we do a simple ENOSPC per volume flag? Or do we really
> have to do full accounting to ensure we never overallocate?
>
> The advantage of the delayed allocation is it allows easier handling of
> compressed files - there we cannot know how much space we will need as the
> page cache data size is not equal to the data written out to disk. We need
> to compress the data before we know. And we don't want to compress every
> time prepare/commit_write are called, otherwise byte by byte writes would
> _really_ suck performance wise.
>
> But even for delayed allocation as above, if we decide to do full
> accounting of free space to prevent overallocation, we have a problem with
> compressed files. For extension of files or filling in of holes, we could
> just assume the data would not compress at all and charge that much in the
> accounting. But this becomes more complicated on overwrite as the new data
> is likely to compress differently well to the existing data so we may need
> to allocate more space just when overwriting and we have no way of telling
> the difference until we have compressed the data. This is why I suggest
not
> to do accounting at all. Perhaps the ENOSPC flag would be useful as a
> sanity check though so an application can't trash the machine by just
> writing to a full partition and us not being able to write out the dirty
> data...
>
> /me finishes in hope of stimulating some discussion or at least getting
> people's opinions...
>
> Best regards,
>
>          Anton
>
>
> --
>    "I've not lost my mind. It's backed up on tape somewhere." - Unknown
> --
> Anton Altaparmakov <aia21 at cantab.net> (replace at with @)
> Linux NTFS Maintainer / IRC: #ntfs on irc.openprojects.net
> WWW: http://linux-ntfs.sf.net/ & http://www-stu.christs.cam.ac.uk/~aia21/
>
>
>
> -------------------------------------------------------
> This sf.net email is sponsored by:ThinkGeek
> Welcome to geek heaven.
> http://thinkgeek.com/sf
> _______________________________________________
> Linux-NTFS-Dev mailing list
> Lin...@li...
> https://lists.sourceforge.net/lists/listinfo/linux-ntfs-dev
>

[Linux-NTFS-Dev] delayed allocation for ntfs?

[Anton A. <ai...@ca...>]

Hi,

What do you think about using delayed allocation for NTFS. Here is my idea, 
let me know what you think...

The idea below is based on the simplest thing I could think off, i.e. there 
is no form of ENOSPC handling in prepare/commit_write.

Ok so here goes:

ntfs_prepare_write()
====================
if (page is uptodate)
         return success.
// For non-uptodate pages:
if (there is an allocation for the destination buffers) {
         map any partially overlapping buffers;
         read them synchronously from the backing store;
} else {
         // There is no allocation, i.e. hole or data extension
         zero any partially overlapping buffers;
}
return success;

ntfs_commit_write()
===================
mark buffers uptodate, but leave them unmapped;
update i_size if necessary;
set_page_dirty();
return success;

ntfs_writepage() -- analogous to the current ntfs_readpage()
================
- For non-resident, uncompressed attributes, map all *uptodate* buffers, 
allocating if necessary, and finally write them (i.e. only write uptodate 
buffers. if the page is uptodate, write all buffers). (If the attribute is 
mst protected, need to get fully exclusive access to the page, 
pre_write_mst protect the data, then have our async io completion handler 
post_write_mst deprotect the data again before unlocking the page.)

- For non-resident, compressed attributes, compress data chunk, allocate 
space if necessary, finally write out to backing store.

- For resident attributes, may need to convert to non-resident if size has 
grown too big, then go to the non-resident, uncompressed case above. If 
size is still small enough, just copy data to the mft record and mark that 
dirty for later write out (we could force a synchronous write if desired).

Conclusions
===========
The above proposal has the problem of permitting overallocation. So the 
user can overallocate without any form of stopping them. We could just have 
a stupid check like "if (NVolENOSPC(vol)) return -ENOSPC;" if we want so 
that once we notice we are actually out of space all further writes will be 
stopped. And we would do a simple NVolSetENOSPC(vol) when we notice we are 
out of space... The cluster deallocator would do a NVolClearENOSPC(vol).

We could of course do more complicated accounting to make sure we will 
never overallocate but that would make everything a lot more complicated...

Basically my proposal makes ntfs_writepage() the "workhorse" and keeps 
prepare/commit_write() as simple as possible. At the same time this speeds 
up writes a lot as we are not slowed down by allocations at write(2) time 
and allocate on vm writeback/sync instead.

Does this make sense or have I missed something important? Any 
better/alternative ideas are welcome!

What do you think about the necessity for free space accounting? Can we do 
just none? Should we do a simple ENOSPC per volume flag? Or do we really 
have to do full accounting to ensure we never overallocate?

The advantage of the delayed allocation is it allows easier handling of 
compressed files - there we cannot know how much space we will need as the 
page cache data size is not equal to the data written out to disk. We need 
to compress the data before we know. And we don't want to compress every 
time prepare/commit_write are called, otherwise byte by byte writes would 
_really_ suck performance wise.

But even for delayed allocation as above, if we decide to do full 
accounting of free space to prevent overallocation, we have a problem with 
compressed files. For extension of files or filling in of holes, we could 
just assume the data would not compress at all and charge that much in the 
accounting. But this becomes more complicated on overwrite as the new data 
is likely to compress differently well to the existing data so we may need 
to allocate more space just when overwriting and we have no way of telling 
the difference until we have compressed the data. This is why I suggest not 
to do accounting at all. Perhaps the ENOSPC flag would be useful as a 
sanity check though so an application can't trash the machine by just 
writing to a full partition and us not being able to write out the dirty 
data...

/me finishes in hope of stimulating some discussion or at least getting 
people's opinions...

Best regards,

         Anton


-- 
   "I've not lost my mind. It's backed up on tape somewhere." - Unknown
-- 
Anton Altaparmakov <aia21 at cantab.net> (replace at with @)
Linux NTFS Maintainer / IRC: #ntfs on irc.openprojects.net
WWW: http://linux-ntfs.sf.net/ & http://www-stu.christs.cam.ac.uk/~aia21/

[Linux-NTFS-Dev] docs and dots

[Richard R. <nt...@fl...>]

Hi all,

It's of interest to very few of you, but I converted the manual pages
(of the linux ntfs tools) to html and put them online.

I've also created "dotty" files for the function call hierarchy for
the NTFS library, the NTFS driver and the LDM driver.  They are created
directly (and almost automatically) from the source.  There's no need to
run the code to determine call paths.

If you're interested, have a look at:

  http://linux-ntfs.sf.net/tools

Cheers,
    FlatCap (Rich)
    nt...@fl...

WWW: http://linux-ntfs.sf.net
IRC: #ntfs on irc.openprojects.net

[Linux-NTFS-Dev] Re: mkntfs on sparse files

[Anton A. <ai...@ca...>]

At 08:20 16/07/02, Szakacsits Szabolcs wrote:
>On Mon, 15 Jul 2002, Anton Altaparmakov wrote:
> > At 17:25 15/07/02, Szakacsits Szabolcs wrote:
> > > > > > >- create file(s) [unfortunately sparse files don't work w/ mkntfs]
> > > > > > why?
> > > > >mkntfs -f -F 100M
> > > > >mkntfs v1.6.99
> > > > >ERROR: 100M is not a block device.
> > > > >mkntfs forced anyway.
> > > > >ERROR: Error: device is too small (103kiB). Minimum NTFS volume size
> > > > >is 1MiB.
> > > > >Aborting...
> >
> > Ok, this _sould_ now work (it does for me). If you could try it, too, it
> > would be great.
>
>Yes, now it's ok, thanks. Here is a quick summary how different fs's
>handle sparse files and 0 bytes size file if volume size is specified.
>
>            sparse file     0 byte file but given fs size
>XFS            +                      -
>JFS            -                      -
>ext[23]        +(F,i)                 +(F,i)
>reiserfs       +(f)                   -
>ntfs           +(F)                   +(F)
>
>F: only if -F (force) given
>f: only if -f (force) given
>i: it asks to proceed or not

Great! Thanks for the info. So we are closest to ext[23] which is good IMO.

Anton


-- 
   "I've not lost my mind. It's backed up on tape somewhere." - Unknown
-- 
Anton Altaparmakov <aia21 at cantab.net> (replace at with @)
Linux NTFS Maintainer / IRC: #ntfs on irc.openprojects.net
WWW: http://linux-ntfs.sf.net/ & http://www-stu.christs.cam.ac.uk/~aia21/

[Linux-NTFS-Dev] Re: mkntfs on sparse files

[Szakacsits S. <sz...@si...>]

On Mon, 15 Jul 2002, Anton Altaparmakov wrote:
> At 17:25 15/07/02, Szakacsits Szabolcs wrote:
> > > > > >- create file(s) [unfortunately sparse files don't work w/ mkntfs]
> > > > > why?
> > > >mkntfs -f -F 100M
> > > >mkntfs v1.6.99
> > > >ERROR: 100M is not a block device.
> > > >mkntfs forced anyway.
> > > >ERROR: Error: device is too small (103kiB). Minimum NTFS volume size
> > > >is 1MiB.
> > > >Aborting...
>
> Ok, this _sould_ now work (it does for me). If you could try it, too, it
> would be great.

Yes, now it's ok, thanks. Here is a quick summary how different fs's
handle sparse files and 0 bytes size file if volume size is specified.

           sparse file     0 byte file but given fs size
XFS            +                      -
JFS            -                      -
ext[23]        +(F,i)                 +(F,i)
reiserfs       +(f)                   -
ntfs           +(F)                   +(F)

F: only if -F (force) given
f: only if -f (force) given
i: it asks to proceed or not

	Szaka

[Linux-NTFS-Dev] Re: $LogFile reset

[Szakacsits S. <sz...@si...>]

On Thu, 11 Jul 2002, Anton Altaparmakov wrote:
> At 14:18 11/07/02, Szakacsits Szabolcs wrote:
> >However ntfsfix also accepts any version 2.X. Does that really needed?
> Yeah, Please adapt your function to accept all 2.x versions, too. (And

Commited.

> >I also plan to move log journal reset and
>
> Please, only one argument: ntfs_volume *vol, function does rest. Also,
> please don't use the code from ntfsfix and instead use ntfs_open_inode() +
> ntfs_open_attr() [you now know the size] + loop using ntfs_attr_pwrite()
> with a 4kiB or so buffer which is memset to -1 over the length of the
> attribute + close the attr and the inode. I have been meaning to do this
> for ages but never got round to it and ntfs_attr_pwrite() was not advanced
> enough back then, but it is now... Thanks! (-:

Commited. My md5sum's matched with old and the new ntfsfix but please
test it.

> Further I think the journal emptying should actually happen at ntfs_mount()
> time, perhaps we could have a mount option to prevent this from happening?
> Although I don't see why would want to prevent it, so probably no need to
> bother. Again, we would only do this if not mountind MS_RDONLY.
>
> How does that sound?

Reasonable :) If it works fine using the new API, we should do it.

	Szaka

Re: [Linux-NTFS-Dev] supported ntfs versions

[Anton A. <ai...@ca...>]

At 16:18 11/07/02, Szakacsits Szabolcs wrote:
>On Thu, 11 Jul 2002, Anton Altaparmakov wrote:
> > > > BOOL ntfs_is_version_supported(ntfs_volume *vol)
> > >
> > >Name is ok (first I thought the same) but please no BOOL. It just
> > >conflicts with everybody's own BOOL definition, int is better.
> >
> > We already have BOOL defined so as soon as you include an ntfs header you
> > would have the conflict.
>
>Yes but it will be easier to clean up later ;) Anyway vol must be
>checked for NULL so BOOL isn't enough anymore.

Yes you are of course perfectly right. Silly me. -1 + errno is required 
after all.

Anton


-- 
   "I've not lost my mind. It's backed up on tape somewhere." - Unknown
-- 
Anton Altaparmakov <aia21 at cantab.net> (replace at with @)
Linux NTFS Maintainer / IRC: #ntfs on irc.openprojects.net
WWW: http://linux-ntfs.sf.net/ & http://www-stu.christs.cam.ac.uk/~aia21/