linux-ntfs-cvs — List for CVS checkins and comments.

[Linux-NTFS-cvs] CVS: dynamic-disk/linux/fs/partitions ldm.c,1.70,1.71 ldm.h,1.43,1.44

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

Changes by: flatcap

Update of /cvsroot/linux-ntfs/dynamic-disk/linux/fs/partitions
In directory usw-pr-cvs1:/tmp/cvs-serv5773/linux/fs/partitions

Modified Files:
	ldm.c ldm.h 
Log Message:
new fragment handling code.
more elegant than mine, simpler than Jakob's and smaller than both.


Index: ldm.c
===================================================================
RCS file: /cvsroot/linux-ntfs/dynamic-disk/linux/fs/partitions/ldm.c,v
retrieving revision 1.70
retrieving revision 1.71
diff -U2 -r1.70 -r1.71
--- ldm.c	15 Apr 2002 00:14:20 -0000	1.70
+++ ldm.c	15 Apr 2002 21:57:33 -0000	1.71
@@ -728,5 +728,5 @@
 	int minor;
 
-	DEBUG_ON (!hd || !ldb || !disk);
+	DEBUG_ON (!hd || !ldb);
 
 	disk = ldm_get_disk_objid (ldb);
@@ -1162,5 +1162,5 @@
 	part->parent_id     = ldm_get_vnum (buffer + 0x34 + r_size);
 	part->disk_id       = ldm_get_vnum (buffer + 0x34 + r_parent);
-	if (vb->flags & VBLK_FLAG_SUCCESSIVE)
+	if (vb->flags & VBLK_FLAG_PART_INDEX)
 		part->partnum = buffer[0x35 + r_diskid];
 	else
@@ -1257,7 +1257,4 @@
 	DEBUG_ON (!buf || !vb);
 
-	buf -= VBLK_SIZE_HEAD;		/* Skip the header FIXME WHAT? */
-	len += VBLK_SIZE_HEAD;
-
 	if (ldm_out_of_range (buf, len, 0x18)) {
 		// FIXME logging
@@ -1301,11 +1298,22 @@
  * FIXME prereq:vb is already sanity-checked.
  *
- * Return: none
+ * Return: none FIXME
  */
-static void ldm_ldmdb_add(struct vblk *vb, struct ldmdb *ldb)
+static BOOL ldm_ldmdb_add (u8 *data, int len, struct ldmdb *ldb)
 {
+	struct vblk *vb;
 	list_t *item;
 
-	DEBUG_ON (!vb || !ldb);
+	DEBUG_ON (!data || !ldb);
+
+	vb = kmalloc (sizeof(*vb), GFP_KERNEL);
+	if (!vb) {
+		ldm_crit ("out of mem");	// FIXME
+		return FALSE;
+	}
+
+	if (!ldm_parse_vblk (data, len, vb)) {
+		return FALSE;			/* Already logged */
+	}
 
 	/* Put vblk into the correct list. */
@@ -1314,15 +1322,15 @@
 	case VBLK_DGR4:
 		list_add(&vb->list, &ldb->v_dgrp);
-		return;
+		break;
 	case VBLK_DSK3:
 	case VBLK_DSK4:
 		list_add(&vb->list, &ldb->v_disk);
-		return;
+		break;
 	case VBLK_VOL5:
 		list_add(&vb->list, &ldb->v_volu);
-		return;
+		break;
 	case VBLK_CMP3:
 		list_add(&vb->list, &ldb->v_comp);
-		return;
+		break;
 	case VBLK_PRT3:
 		/* Sort by the partition's start sector. */
@@ -1332,35 +1340,70 @@
 			    (v->vblk.part.start > vb->vblk.part.start)) {
 				list_add_tail(&vb->list, &v->list);
-				return;
+				return TRUE;
 			}
 		}
 		list_add_tail(&vb->list, &ldb->v_part);
-		return;
+		break;
 	}
+	return TRUE;
 }
 
 /**
- * ldm_frag_find - Obvious fraglist helper functions.
- * @list: List of fragments.
- * FIXME: better descriptions.
+ * ldm_frag_add
  */
-static struct frags *ldm_frag_find(list_t *list, u32 group)
+static BOOL ldm_frag_add (const u8 *data, int size, list_t *frags)
 {
+	struct frag *f;
 	list_t *item;
+	int rec, num, group;
 
-	DEBUG_ON (!list);
+	DEBUG_ON (!data || !frags);
 
-	list_for_each(item, list) {
-		struct frags *f = list_entry(item, struct frags, list);
+	group = BE32 (data + 0x08);
+	rec   = BE16 (data + 0x0C);
+	num   = BE16 (data + 0x0E);
+	if ((num < 1) || (num > 4)) {
+		ldm_error ("corrupt vblk %d parts.", num);
+		return FALSE;
+	}
+
+	list_for_each(item, frags) {
+		f = list_entry(item, struct frag, list);
 		if (f->group == group)
-			return f;
+			goto found;
+	}
+
+	f = kmalloc (sizeof (*f) + size*num, GFP_KERNEL);
+	if (!f) {
+		ldm_crit ("Out of memory.");
+		return FALSE;
 	}
-	return 0;
+
+	f->group = group;
+	f->num   = num;
+	f->rec   = rec;
+	f->map   = 0xFF << num;
+
+	list_add_tail(&f->list, frags);
+found:
+	if (f->map & (1 << rec)) {
+		ldm_error ("Duplicate VBLK, part %d.", rec);
+	}
+
+	f->map |= 1 << rec;
+
+	if (num > 0) {
+		data += VBLK_SIZE_HEAD;
+		size -= VBLK_SIZE_HEAD;
+	}
+	memcpy (f->data+rec*(size-VBLK_SIZE_HEAD)+VBLK_SIZE_HEAD, data, size);
+
+	return TRUE;
 }
 
 /**
- * ldm_frag_listfree -
+ * ldm_frag_free -
  */
-static void ldm_frag_listfree(list_t *list)
+static void ldm_frag_free (list_t *list)
 {
 	list_t *item, *tmp;
@@ -1369,76 +1412,5 @@
 
 	list_for_each_safe(item, tmp, list)
-		kfree (list_entry(item, struct frags, list));
-
-	INIT_LIST_HEAD(list);
-}
-
-/**
- * ldm_frag_add - Adds a VBLK fragment to fragment list.
- * @list: Fragment list.
- * @vbh:  VBLK header.
- * @data: pointer to raw data.
- * @size: size of datablock.
- *
- * Process fragment data and copy to fragment list.
- * FIXME: desc.
- *
- * Returns:	TRUE	fragment added.
- *		FALSE	vblk record is corrupt.
- *		-1	error.
- */
-static int ldm_frag_add(list_t *list, const struct vblk_head *vbh,
-			const u8 *data, int size)
-{
-	BOOL bad = FALSE;
-	struct frags *f;
-
-	DEBUG_ON (!list || !vbh || !data);
-
-	/* Sanity check vblk header. */
-	if (vbh->nrec > FRAG_MAX || vbh->rec >= vbh->nrec) {
-		ldm_error ("Invalid VBLK header.");
-		bad = TRUE; // FIXME shouldn't we return?
-	}
-
-	/* Try to find previous entry. */
-	if ((f = ldm_frag_find(list, vbh->group))) {
-		/* More sanity checking. */
-		if (FRAG_GETBAD(f)) {
-			bad = TRUE;
-			// FIXME has this been logged already?
-		} else if (vbh->nrec != f->nrec || FRAG_GETMAP(f, vbh->rec)) {
-			ldm_error ("Inconsistent VBLK fragments!");
-			bad = TRUE;
-		}
-	} else { /* Not found, create a new entry in list. */
-		const int nrec = (bad) ? 0 : vbh->nrec;
-
-		/* Allocate memory */
-		f = kmalloc(sizeof (*f) + nrec * size, GFP_KERNEL);
-		if (!f) {
-			ldm_crit ("Out of memory.");
-			return -1;
-		}
-
-		/* Initialize entry. */
-		f->group = vbh->group;
-		f->nrec = nrec;
-		f->map = 0x00;
-
-		/* Add to end of list. */
-		list_add_tail(&f->list, list);
-	}
-
-	/* Mark as bad if necessary. */
-	if (bad)
-		FRAG_SETBAD(f);
-	/* Copy data */
-	else {
-		memcpy(f->data + vbh->rec*size, data, size);
-		FRAG_SETMAP(f, vbh->rec);
-	}
-
-	return !bad;
+		kfree (list_entry(item, struct frag, list));
 }
 
@@ -1446,5 +1418,4 @@
  * ldm_frag_commit - Parse complete multipart VBLK records and add to ldmdb.
  * @list: Fragment list.
- * @size: fragmentsize.
  * @ldb:  ldmdb.
  *
@@ -1454,144 +1425,79 @@
  *		FALSE
  */
-static BOOL ldm_frag_commit(list_t *list, int size, struct ldmdb *ldb)
+static BOOL ldm_frag_commit (list_t *frags, struct ldmdb *ldb)
 {
-	list_t *item, *tmp;
-	struct vblk *vb = NULL;
-	BOOL result;
+	struct frag *f;
+	list_t *item;
+	BOOL result = FALSE;
 
-	DEBUG_ON (!list || !ldb);
+	DEBUG_ON (!frags || !ldb);
 
-	list_for_each_safe(item, tmp, list) {
-		struct frags *f = list_entry(item, struct frags, list);
-		int i;
-
-		if (FRAG_GETBAD(f))
-			goto entry_done;
-
-		/* Make sure we've got all parts. */
-		for (i = 0; i < f->nrec; i++)
-			if (!FRAG_GETMAP(f, i)) {
-				ldm_error ("VBLK group %lu is incomplete.",
-					(unsigned long)f->group);
-				goto entry_done;
-			}
+	list_for_each(item, frags) {
+		f = list_entry(item, struct frag, list);
 
-		/* Allocate memory for VBLK if necessary. */
-		if (!vb)
-			vb = kmalloc (sizeof(*vb), GFP_KERNEL);
-		if (!vb) {
-			ldm_crit ("Out of memory.");
-			result = FALSE;
+		if (f->map != 0xFF) {
+			ldm_error ("VBLK group %d is incomplete.", f->group);
 			goto out;
 		}
 
-		/* Parse vblk entry and add to list. */
-		if (ldm_parse_vblk (f->data, size * f->nrec, vb)) {
-			ldm_ldmdb_add(vb, ldb);
-			vb = NULL;
-		}
-		/* else - Already logged */
-	entry_done:
-		list_del(&f->list);
-		kfree (f);
+		if (!ldm_ldmdb_add (f->data, f->num*ldb->vm.vblk_size, ldb))
+			goto out;
 	}
+
 	result = TRUE;
 out:
-	kfree (vb);
-
 	return result;
 }
 
 /**
- * ldm_get_vblks - Read and cache the VMDB in the ldmdb
- * @bdev:  The device to read from
- * @base:  The offset into the device
- * @ldb:   ldmdb struct
- *
- * This reads all VBLK entries and then stores relevant information
- * in the appropriate list inside the ldmdb
- *
- * Returns: TRUE   Database read without any errors
- *          FALSE  Error
- */
-static BOOL ldm_get_vblks(struct block_device *bdev, unsigned long base,
-		struct ldmdb *ldb)
-{
-	// FIXME: This function is ugly, it should be rewritten.
-	const int perbuf = 512 / ldb->vm.vblk_size;
-	const int skip   = ldb->vm.vblk_offset / 512;
-	const int finish = (ldb->vm.vblk_size * ldb->vm.last_vblk_seq) / 512;
-	const int body_size = ldb->vm.vblk_size - VBLK_SIZE_HEAD;
-	LIST_HEAD(fraglist);
-	struct vblk *vb = NULL;
+ * ldm_get_vblks - new
+ */
+static BOOL ldm_get_vblks(struct block_device *bdev, unsigned long base, struct ldmdb *ldb)
+{
+	int size, perbuf, skip, finish, s, v, recs;
 	u8 *data = NULL;
 	Sector sect;
-	int s;
 	BOOL result = FALSE;
+	LIST_HEAD(frags);
+
+	DEBUG_ON (!bdev || !ldb);
 
-	DEBUG_ON (!bdev || !ldb); // FIXME useless after deref'ing ldb (above)
+	size   = ldb->vm.vblk_size;
+	perbuf = 512 / size;
+	skip   = ldb->vm.vblk_offset / 512;
+	finish = (size * ldb->vm.last_vblk_seq) / 512;
 
-	/* Loop through sectors */
-	for (s = skip; s < finish; s++) {
-		int i;
-		if (data)
-			put_dev_sector(sect);
+	for (s = skip; s < finish; s++) {		/* For each sector */
 		data = read_dev_sector (bdev, base + OFF_VMDB + s, &sect);
 		if (!data) {
-			ldm_crit ("Disk read failed in get buffers."); //FIXME
+			ldm_crit ("Disk read failed.");
 			goto out;
 		}
 
-		/* Loop through all entries in sector */
-		for (i = 0; i < perbuf; i++) {
-			const u8 *block = data + i*ldb->vm.vblk_size;
-			const u8 *body_data = block + VBLK_SIZE_HEAD;
-			struct vblk_head vbh;
-
-			if (MAGIC_VBLK != BE32 (block)) {
-				ldm_error ("not a VBLK"); //FIXME
+		for (v = 0; v < perbuf; v++, data+=size) {  /* For each vblk */
+			if (MAGIC_VBLK != BE32 (data)) {
+				ldm_error ("Expected to find a VBLK.");
 				goto out;
 			}
 
-			/* Common to all VBLKs */
-			vbh.group = BE32 (block + 0x08);
-			vbh.rec   = BE16 (block + 0x0C);
-			vbh.nrec  = BE16 (block + 0x0E);
-			if (vbh.nrec == 0)	/* Record is not in use */
-				continue;
-
-			/* Record is multipart */
-			if (vbh.nrec > 1) {
-				if (ldm_frag_add(&fraglist, &vbh, body_data, body_size) < 0)
-					goto out; /* already logged */
-				continue;
+			recs = BE16 (data + 0x0E);	/* Number of records */
+			if (recs == 1) {
+				if (!ldm_ldmdb_add (data, size, ldb))
+					goto out;	/* Already logged */
+			} else if (recs > 1) {
+				if (!ldm_frag_add (data, size, &frags))
+					goto out;	/* Already logged */
 			}
-
-			/* Allocate memory for vblk */
-			if (!vb)
-				vb = kmalloc (sizeof(*vb), GFP_KERNEL);
-			if (!vb) {
-				ldm_crit ("Out of memory.");
-				goto out;
-			}
-
-			/* Parse record and add to list. */
-			if (ldm_parse_vblk (body_data, body_size, vb)) {
-				ldm_ldmdb_add(vb, ldb);
-				vb = NULL;
-			}
-			/* else - Already logged */
+			/* else Record is not in use, ignore it. */
 		}
+		put_dev_sector(sect);
+		data = NULL;
 	}
 
-	/* Combine fragments. */
-	result = ldm_frag_commit(&fraglist, body_size, ldb);
+	result = ldm_frag_commit (&frags, ldb);
 out:
-	kfree(vb);
 	if (data)
 		put_dev_sector(sect);
-
-	/* Free fraglist */
-	ldm_frag_listfree(&fraglist);
+	ldm_frag_free (&frags);
 
 	return result;
@@ -1701,2 +1607,3 @@
 	return err;
 }
+

Index: ldm.h
===================================================================
RCS file: /cvsroot/linux-ntfs/dynamic-disk/linux/fs/partitions/ldm.h,v
retrieving revision 1.43
retrieving revision 1.44
diff -U2 -r1.43 -r1.44
--- ldm.h	15 Apr 2002 00:14:20 -0000	1.43
+++ ldm.h	15 Apr 2002 21:57:33 -0000	1.44
@@ -56,8 +56,4 @@
 #define VBLK_DGR4		0x45		/* Disk Group, version 4 */
 
-/* vblk flags. */
-#define VBLK_FLAG_COMPOUND	0x10		/* 00010000 Compound comp. */
-#define VBLK_FLAG_SUCCESSIVE	0x08		/* 00001000 n-th in set, n>1 */
-
 /* vblk flags indicating extra information will be present */
 #define	VBLK_FLAG_COMP_STRIPE	0x10
@@ -117,16 +113,10 @@
 
 /* VBLK Fragment handling */
-#define FRAG_MAPBITS		8
-#define FRAG_MAX		(FRAG_MAPBITS-1)
-#define FRAG_GETMAP(f,n)	(f->map &  (1 << n))
-#define FRAG_SETMAP(f,n)	(f->map |= (1 << n))
-#define FRAG_GETBAD(f)		(f->map &  (1 << (FRAG_MAPBITS-1)))
-#define FRAG_SETBAD(f)		(f->map |= (1 << (FRAG_MAPBITS-1)))
-
-struct frags {
+struct frag {
 	list_t	list;
 	u32	group;
-	u8	nrec;
-	u8	map;
+	u8	num;				/* Total number of records */
+	u8	rec;				/* This is record number n */
+	u8	map;				/* Which portions are in use */
 	u8	data[0];
 };

[Linux-NTFS-cvs] CVS: linux-ntfs/ntfstools mkntfs.c,1.63,1.64

[Anton A. <an...@us...>]

Changes by: antona

Update of /cvsroot/linux-ntfs/linux-ntfs/ntfstools
In directory usw-pr-cvs1:/tmp/cvs-serv1574/ntfstools

Modified Files:
	mkntfs.c 
Log Message:
Little fix of a fix. (-:


Index: mkntfs.c
===================================================================
RCS file: /cvsroot/linux-ntfs/linux-ntfs/ntfstools/mkntfs.c,v
retrieving revision 1.63
retrieving revision 1.64
diff -U2 -r1.63 -r1.64
--- mkntfs.c	15 Apr 2002 20:04:29 -0000	1.63
+++ mkntfs.c	15 Apr 2002 21:41:16 -0000	1.64
@@ -1528,5 +1528,5 @@
 {
 	attr_search_context *ctx;
-	ATTR_RECORD *a = NULL;
+	ATTR_RECORD *a;
 	int asize, err, i;
 	uchar_t *uname;
@@ -1601,4 +1601,6 @@
 	if (name_len)
 		memcpy((char*)a + 24, uname, name_len << 1);
+	if (val_len)
+		memcpy((char*)a + le16_to_cpu(a->value_offset), val, val_len);
 err_out:
 	if (ctx)
@@ -1606,6 +1608,4 @@
 	if (uname)
 		free(uname);
-	if (val_len && a)
-		memcpy((char*)a + le16_to_cpu(a->value_offset), val, val_len);
 	return err;
 }

[Linux-NTFS-cvs] CVS: linux-ntfs Makefile.am,1.6,1.7 Makefile.in,1.11,1.12

[Anton A. <an...@us...>]

Changes by: antona

Update of /cvsroot/linux-ntfs/linux-ntfs
In directory usw-pr-cvs1:/tmp/cvs-serv31580

Modified Files:
	Makefile.am Makefile.in 
Log Message:
Fix all compiler warnings that came up with -Wall. Enabled -Wall for ./configure --enable-debug everywhere. Fix a few bugs in mkntfs that came up in the warnings (just error code paths, nothing major).


Index: Makefile.am
===================================================================
RCS file: /cvsroot/linux-ntfs/linux-ntfs/Makefile.am,v
retrieving revision 1.6
retrieving revision 1.7
diff -U2 -r1.6 -r1.7
--- Makefile.am	14 Apr 2002 14:15:47 -0000	1.6
+++ Makefile.am	15 Apr 2002 20:04:22 -0000	1.7
@@ -2,5 +2,5 @@
 # Need this to enable 64-bit (device) file access functions and parameters.
 if DEBUG
-AM_CFLAGS = -D_FILE_OFFSET_BITS=64 -g -DDEBUG
+AM_CFLAGS = -D_FILE_OFFSET_BITS=64 -g -DDEBUG -Wall
 else
 AM_CFLAGS = -D_FILE_OFFSET_BITS=64

Index: Makefile.in
===================================================================
RCS file: /cvsroot/linux-ntfs/linux-ntfs/Makefile.in,v
retrieving revision 1.11
retrieving revision 1.12
diff -U2 -r1.11 -r1.12
--- Makefile.in	14 Apr 2002 14:15:47 -0000	1.11
+++ Makefile.in	15 Apr 2002 20:04:22 -0000	1.12
@@ -89,5 +89,5 @@
 all_includes = @all_includes@
 all_libraries = @all_libraries@
-@DEBUG_TRUE@AM_CFLAGS = @DEBUG_TRUE@-D_FILE_OFFSET_BITS=64 -g -DDEBUG
+@DEBUG_TRUE@AM_CFLAGS = @DEBUG_TRUE@-D_FILE_OFFSET_BITS=64 -g -DDEBUG -Wall
 @DEBUG_FALSE@AM_CFLAGS = @DEBUG_FALSE@-D_FILE_OFFSET_BITS=64
 

[Linux-NTFS-cvs] CVS: linux-ntfs/libntfs Makefile.am,1.10,1.11 Makefile.in,1.14,1.15 disk_io.c,1.19,1.20 mft.c,1.18,1.19 unistr.c,1.8,1.9 volume.c,1.24,1.25

[Anton A. <an...@us...>]

Changes by: antona

Update of /cvsroot/linux-ntfs/linux-ntfs/libntfs
In directory usw-pr-cvs1:/tmp/cvs-serv31580/libntfs

Modified Files:
	Makefile.am Makefile.in disk_io.c mft.c unistr.c volume.c 
Log Message:
Fix all compiler warnings that came up with -Wall. Enabled -Wall for ./configure --enable-debug everywhere. Fix a few bugs in mkntfs that came up in the warnings (just error code paths, nothing major).


Index: Makefile.am
===================================================================
RCS file: /cvsroot/linux-ntfs/linux-ntfs/libntfs/Makefile.am,v
retrieving revision 1.10
retrieving revision 1.11
diff -U2 -r1.10 -r1.11
--- Makefile.am	14 Apr 2002 14:08:29 -0000	1.10
+++ Makefile.am	15 Apr 2002 20:04:26 -0000	1.11
@@ -7,9 +7,9 @@
 # - If the interface is the same as the previous version, change to C:R+1:A
 
-LTVERSION = 3:0:0
+LTVERSION = 4:0:0
 
 # Need this to enable 64-bit (device) file access functions and parameters.
 if DEBUG
-AM_CFLAGS = -D_FILE_OFFSET_BITS=64 -g -DDEBUG
+AM_CFLAGS = -D_FILE_OFFSET_BITS=64 -g -DDEBUG -Wall
 else
 AM_CFLAGS = -D_FILE_OFFSET_BITS=64

Index: Makefile.in
===================================================================
RCS file: /cvsroot/linux-ntfs/linux-ntfs/libntfs/Makefile.in,v
retrieving revision 1.14
retrieving revision 1.15
diff -U2 -r1.14 -r1.15
--- Makefile.in	14 Apr 2002 14:08:29 -0000	1.14
+++ Makefile.in	15 Apr 2002 20:04:26 -0000	1.15
@@ -96,6 +96,6 @@
 all_libraries = @all_libraries@
 
-LTVERSION = 3:0:0
-@DEBUG_TRUE@AM_CFLAGS = @DEBUG_TRUE@-D_FILE_OFFSET_BITS=64 -g -DDEBUG
+LTVERSION = 4:0:0
+@DEBUG_TRUE@AM_CFLAGS = @DEBUG_TRUE@-D_FILE_OFFSET_BITS=64 -g -DDEBUG -Wall
 @DEBUG_FALSE@AM_CFLAGS = @DEBUG_FALSE@-D_FILE_OFFSET_BITS=64
 

Index: disk_io.c
===================================================================
RCS file: /cvsroot/linux-ntfs/linux-ntfs/libntfs/disk_io.c,v
retrieving revision 1.19
retrieving revision 1.20
diff -U2 -r1.19 -r1.20
--- disk_io.c	15 Apr 2002 18:39:37 -0000	1.19
+++ disk_io.c	15 Apr 2002 20:04:27 -0000	1.20
@@ -30,4 +30,5 @@
 #include "types.h"
 #include "disk_io.h"
+#include "mst.h"
 #include "debug.h"
 
@@ -162,5 +163,5 @@
 	__s64 br, i;
 
-	if (!b || count < 0 || pos < 0 || bksize & bksize - 1 ||
+	if (!b || count < 0 || pos < 0 || bksize & (bksize - 1) ||
 			bksize % NTFS_SECTOR_SIZE) {
 		errno = EINVAL;
@@ -214,5 +215,5 @@
 	char retry;
 	
-	if (!b || count < 0 || pos < 0 || bksize & bksize - 1 ||
+	if (!b || count < 0 || pos < 0 || bksize & (bksize - 1) ||
 			bksize % NTFS_SECTOR_SIZE) {
 		errno = EINVAL;

Index: mft.c
===================================================================
RCS file: /cvsroot/linux-ntfs/linux-ntfs/libntfs/mft.c,v
retrieving revision 1.18
retrieving revision 1.19
diff -U2 -r1.18 -r1.19
--- mft.c	15 Apr 2002 19:02:40 -0000	1.18
+++ mft.c	15 Apr 2002 20:04:27 -0000	1.19
@@ -22,4 +22,5 @@
  */
 
+#include <stdlib.h>
 #include <errno.h>
 
@@ -28,4 +29,5 @@
 #include "debug.h"
 #include "bitmap.h"
+#include "attrib.h"
 
 /**
@@ -73,5 +75,5 @@
 	}
 	/* Offset within the cluster of the first mft record to read. */
-	ofs = m << vol->mft_record_size_bits & vol->cluster_size - 1;
+	ofs = (m << vol->mft_record_size_bits) & (vol->cluster_size - 1);
 	br = ntfs_mst_pread(vol->fd, (lcn << vol->cluster_size_bits) + ofs,
 			count, vol->mft_record_size, b);
@@ -129,5 +131,5 @@
 	}
 	/* Offset within the cluster of the first mft record to write. */
-	ofs = m << vol->mft_record_size_bits & vol->cluster_size - 1;
+	ofs = (m << vol->mft_record_size_bits) & (vol->cluster_size - 1);
 	bw = ntfs_mst_pwrite(vol->fd, (lcn << vol->cluster_size_bits) + ofs,
 			count, vol->mft_record_size, b);

Index: unistr.c
===================================================================
RCS file: /cvsroot/linux-ntfs/linux-ntfs/libntfs/unistr.c,v
retrieving revision 1.8
retrieving revision 1.9
diff -U2 -r1.8 -r1.9
--- unistr.c	14 Apr 2002 14:08:30 -0000	1.8
+++ unistr.c	15 Apr 2002 20:04:27 -0000	1.9
@@ -23,4 +23,5 @@
 
 #include <stdio.h>
+#include <stdlib.h>
 
 #include "types.h"
@@ -108,5 +109,5 @@
 
 #ifdef DEBUG
-	if (!name1 || !name2 || ic && !upcase && upcase_len) {
+	if (!name1 || !name2 || (ic && !upcase && upcase_len)) {
 		Dputs("ntfs_collate_names received NULL pointer!");
 		exit(1);

Index: volume.c
===================================================================
RCS file: /cvsroot/linux-ntfs/linux-ntfs/libntfs/volume.c,v
retrieving revision 1.24
retrieving revision 1.25
diff -U2 -r1.24 -r1.25
--- volume.c	15 Apr 2002 19:02:41 -0000	1.24
+++ volume.c	15 Apr 2002 20:04:28 -0000	1.25
@@ -106,5 +106,5 @@
 	__s64 l;
 	ssize_t br;
-	__u8 sectors_per_cluster, bits;
+	__u8 sectors_per_cluster;
 	__s8 c;
 	MFT_REF mref;
@@ -163,5 +163,5 @@
 	Dprintf("NumberOfSectors = %Li\n", sle64_to_cpu(bs->number_of_sectors));
 	Dprintf("SectorsPerCluster = 0x%x\n", sectors_per_cluster);
-	if (sectors_per_cluster & sectors_per_cluster - 1) {
+	if (sectors_per_cluster & (sectors_per_cluster - 1)) {
 		Dprintf("Error: %s is not a valid NTFS partition! "
 				"sectors_per_cluster is not a power of 2.\n",
@@ -171,5 +171,5 @@
 	}
 	vol->number_of_clusters = sle64_to_cpu(bs->number_of_sectors) >>
-			ffs(sectors_per_cluster) - 1;
+			(ffs(sectors_per_cluster) - 1);
 
 	vol->mft_lcn = sle64_to_cpu(bs->mft_lcn);
@@ -187,5 +187,5 @@
 	vol->cluster_size = sectors_per_cluster *
 					le16_to_cpu(bs->bpb.bytes_per_sector);
-	if (vol->cluster_size & vol->cluster_size - 1) {
+	if (vol->cluster_size & (vol->cluster_size - 1)) {
 		Dprintf("Error: %s is not a valid NTFS partition! "
 				"cluster_size is not a power of 2.\n", name);
@@ -213,5 +213,5 @@
 	else
 		vol->mft_record_size = vol->cluster_size * c;
-	if (vol->mft_record_size & vol->mft_record_size - 1) {
+	if (vol->mft_record_size & (vol->mft_record_size - 1)) {
 		Dprintf("Error: %s is not a valid NTFS partition! "
 				"mft_record_size is not a power of 2.\n", name);
@@ -396,5 +396,5 @@
 	Dprintf("Loading $UpCase... ");
 	mref = (MFT_REF)FILE_$UpCase;
-	if (err = __read_file_record(vol, &mref, &mb, NULL)) {
+	if ((err = __read_file_record(vol, &mref, &mb, NULL))) {
 		Dputs(FAILED);
 		errno = -err;
@@ -460,5 +460,5 @@
 	Dprintf("Loading $Volume... ");
 	mref = (MFT_REF)FILE_$Volume;
-	if (err = __read_file_record(vol, &mref, &mb, NULL)) {
+	if ((err = __read_file_record(vol, &mref, &mb, NULL))) {
 		Dputs(FAILED);
 		errno = -err;

[Linux-NTFS-cvs] CVS: linux-ntfs ChangeLog,1.34,1.35

[Anton A. <an...@us...>]

Changes by: antona

Update of /cvsroot/linux-ntfs/linux-ntfs
In directory usw-pr-cvs1:/tmp/cvs-serv1399

Modified Files:
	ChangeLog 
Log Message:
Update


Index: ChangeLog
===================================================================
RCS file: /cvsroot/linux-ntfs/linux-ntfs/ChangeLog,v
retrieving revision 1.34
retrieving revision 1.35
diff -U2 -r1.34 -r1.35
--- ChangeLog	15 Apr 2002 17:51:26 -0000	1.34
+++ ChangeLog	15 Apr 2002 20:07:58 -0000	1.35
@@ -12,4 +12,8 @@
 	  find_attr() which has the same effect.
 	- Rewrite disk_io.[ch] and mft.[ch] defining new access API.
+	- Add -Wall to compiler options when ./configure is run with
+	  --enable-debug.
+	- Fix minor error code path bugs in mkntfs.c that showed up with -Wall.
+	- Fix all compiler warnings that showed up with -Wall.
 
 12/03/2002 - 1.6.0 - More mkntfs options and cleanups.

[Linux-NTFS-cvs] CVS: linux-ntfs/include debug.h,1.2,1.3 mft.h,1.28,1.29

[Anton A. <an...@us...>]

Changes by: antona

Update of /cvsroot/linux-ntfs/linux-ntfs/include
In directory usw-pr-cvs1:/tmp/cvs-serv31580/include

Modified Files:
	debug.h mft.h 
Log Message:
Fix all compiler warnings that came up with -Wall. Enabled -Wall for ./configure --enable-debug everywhere. Fix a few bugs in mkntfs that came up in the warnings (just error code paths, nothing major).


Index: debug.h
===================================================================
RCS file: /cvsroot/linux-ntfs/linux-ntfs/include/debug.h,v
retrieving revision 1.2
retrieving revision 1.3
diff -U2 -r1.2 -r1.3
--- debug.h	14 Apr 2002 13:56:45 -0000	1.2
+++ debug.h	15 Apr 2002 20:04:25 -0000	1.3
@@ -35,4 +35,5 @@
 #	include <stdarg.h>
 #endif
+#include <errno.h>
 
 /* Debug output to stderr. To get it run ./configure --enable-debug. */

Index: mft.h
===================================================================
RCS file: /cvsroot/linux-ntfs/linux-ntfs/include/mft.h,v
retrieving revision 1.28
retrieving revision 1.29
diff -U2 -r1.28 -r1.29
--- mft.h	15 Apr 2002 17:51:26 -0000	1.28
+++ mft.h	15 Apr 2002 20:04:25 -0000	1.29
@@ -100,4 +100,9 @@
 }
 
+// FIXME: Temporary old stuff below here.
+
+extern int __read_file_record(const ntfs_volume *vol, const MFT_REF *mref,
+			MFT_RECORD **mrec, ATTR_RECORD **attr);
+
 #endif /* defined MFT_H */
 

[Linux-NTFS-cvs] CVS: linux-ntfs/ntfstools Makefile.am,1.15,1.16 Makefile.in,1.19,1.20 mkntfs.c,1.62,1.63 sd.c,1.2,1.3 upcase.c,1.2,1.3

[Anton A. <an...@us...>]

Changes by: antona

Update of /cvsroot/linux-ntfs/linux-ntfs/ntfstools
In directory usw-pr-cvs1:/tmp/cvs-serv31580/ntfstools

Modified Files:
	Makefile.am Makefile.in mkntfs.c sd.c upcase.c 
Log Message:
Fix all compiler warnings that came up with -Wall. Enabled -Wall for ./configure --enable-debug everywhere. Fix a few bugs in mkntfs that came up in the warnings (just error code paths, nothing major).


Index: Makefile.am
===================================================================
RCS file: /cvsroot/linux-ntfs/linux-ntfs/ntfstools/Makefile.am,v
retrieving revision 1.15
retrieving revision 1.16
diff -U2 -r1.15 -r1.16
--- Makefile.am	12 Apr 2002 15:23:48 -0000	1.15
+++ Makefile.am	15 Apr 2002 20:04:29 -0000	1.16
@@ -1,5 +1,5 @@
 # Need this to enable 64-bit (device) file access functions and parameters.
 if DEBUG
-AM_CFLAGS = -D_FILE_OFFSET_BITS=64 -g -DDEBUG
+AM_CFLAGS = -D_FILE_OFFSET_BITS=64 -g -DDEBUG -Wall
 else
 AM_CFLAGS = -D_FILE_OFFSET_BITS=64

Index: Makefile.in
===================================================================
RCS file: /cvsroot/linux-ntfs/linux-ntfs/ntfstools/Makefile.in,v
retrieving revision 1.19
retrieving revision 1.20
diff -U2 -r1.19 -r1.20
--- Makefile.in	12 Apr 2002 15:23:48 -0000	1.19
+++ Makefile.in	15 Apr 2002 20:04:29 -0000	1.20
@@ -89,5 +89,5 @@
 all_includes = @all_includes@
 all_libraries = @all_libraries@
-@DEBUG_TRUE@AM_CFLAGS = @DEBUG_TRUE@-D_FILE_OFFSET_BITS=64 -g -DDEBUG
+@DEBUG_TRUE@AM_CFLAGS = @DEBUG_TRUE@-D_FILE_OFFSET_BITS=64 -g -DDEBUG -Wall
 @DEBUG_FALSE@AM_CFLAGS = @DEBUG_FALSE@-D_FILE_OFFSET_BITS=64
 

Index: mkntfs.c
===================================================================
RCS file: /cvsroot/linux-ntfs/linux-ntfs/ntfstools/mkntfs.c,v
retrieving revision 1.62
retrieving revision 1.63
diff -U2 -r1.62 -r1.63
--- mkntfs.c	15 Apr 2002 19:02:41 -0000	1.62
+++ mkntfs.c	15 Apr 2002 20:04:29 -0000	1.63
@@ -111,4 +111,5 @@
 #include "attrib.h"
 #include "bitmap.h"
+#include "mst.h"
 
 extern const unsigned char attrdef_ntfs12_array[2400];
@@ -399,5 +400,5 @@
 int ucsnlen(const uchar_t *s, int maxlen)
 {
-	int i, len;
+	int i;
 	
 	for (i = 0; i < maxlen; i++)
@@ -493,5 +494,5 @@
 		return;
 	case $VOLUME_NAME:
-		printf("Volume name length = %i\n", i);
+		printf("Volume name length = %i\n", val_len);
 		if (val_len) {
 			buf = calloc(1, val_len);
@@ -807,5 +808,5 @@
 	m->magic = magic_FILE;
 	/* Aligned to 2-byte boundary. */
-	m->usa_ofs = cpu_to_le16(sizeof(MFT_RECORD) + 1 & ~1);
+	m->usa_ofs = cpu_to_le16((sizeof(MFT_RECORD) + 1) & ~1);
 	if (opt.mft_record_size >= NTFS_SECTOR_SIZE)
 		m->usa_count = cpu_to_le16(opt.mft_record_size /
@@ -820,11 +821,11 @@
 	}
 	/* Set the update sequence number to 1. */
-	*(__u16*)((char*)m + (sizeof(MFT_RECORD) + 1 & ~1)) = cpu_to_le16(1);
+	*(__u16*)((char*)m + ((sizeof(MFT_RECORD) + 1) & ~1)) = cpu_to_le16(1);
 	m->lsn = cpu_to_le64(0LL);
 	m->sequence_number = cpu_to_le16(1);
 	m->link_count = cpu_to_le16(0);
 	/* Aligned to 8-byte boundary. */
-	m->attrs_offset = cpu_to_le16(le16_to_cpu(m->usa_ofs) +
-			(le16_to_cpu(m->usa_count) << 1) + 7 & ~7);
+	m->attrs_offset = cpu_to_le16((le16_to_cpu(m->usa_ofs) +
+			(le16_to_cpu(m->usa_count) << 1) + 7) & ~7);
 	m->flags = cpu_to_le16(0);
 	/*
@@ -832,5 +833,6 @@
 	 * aligned to 8-byte boundary.
 	 */
-	m->bytes_in_use = cpu_to_le32(le16_to_cpu(m->attrs_offset) + 8+7 & ~7);
+	m->bytes_in_use = cpu_to_le32((le16_to_cpu(m->attrs_offset) + 8 + 7) &
+			~7);
 	m->bytes_allocated = cpu_to_le32(opt.mft_record_size);
 	m->base_mft_record = cpu_to_le64((MFT_REF)0);
@@ -875,5 +877,5 @@
 {
 	int i;
-	LCN prev_lcn, delta_lcn;
+	LCN prev_lcn;
 	/* Terminator byte. */
 	int rls = 1;
@@ -950,5 +952,5 @@
 int build_mapping_pairs(char *dest, const int dest_len, const run_list *rl)
 {
-	int i, j;
+	int i;
 	__s8 len_len, lcn_len;
 	char *dest_max;
@@ -1017,5 +1019,5 @@
 	 * appropriate codes exist for simplicity of parsing the return value.
 	 */
-	if (size != (size + 7 & ~7)) {
+	if (size != ((size + 7) & ~7)) {
 		Eprintf("make_room_for_attribute() received non 8-byte aligned"
 				"size.\n");
@@ -1050,6 +1052,6 @@
 
 	/* New attribute length and mft record bytes used. */
-	new_alen = le32_to_cpu(a->length) - le32_to_cpu(a->value_length) +
-			new_vsize + 7 & ~7;
+	new_alen = (le32_to_cpu(a->length) - le32_to_cpu(a->value_length) +
+			new_vsize + 7) & ~7;
 	new_muse = le32_to_cpu(m->bytes_in_use) - le32_to_cpu(a->length) +
 			new_alen;
@@ -1188,5 +1190,5 @@
 	__u16 hdr_size;
 	int asize, mpa_size, err, i;
-	__s64 bw, inited_size;
+	__s64 bw = 0, inited_size;
 	VCN highest_vcn;
 	uchar_t *uname;
@@ -1249,5 +1251,5 @@
 	}
 	/* Mapping pairs array and next attribute must be 8-byte aligned. */
-	asize = ((int)hdr_size + (name_len + 7 & ~7) + mpa_size) + 7 & ~7;
+	asize = (((int)hdr_size + ((name_len + 7) & ~7) + mpa_size) + 7) & ~7;
 	/* Get the highest vcn. */
 	for (i = 0, highest_vcn = 0LL; rl[i].length; i++)
@@ -1293,9 +1295,9 @@
 	a->flags = flags;
 	a->instance = m->next_attr_instance;
-	m->next_attr_instance = cpu_to_le16(le16_to_cpu(m->next_attr_instance)
-								+ 1 & 0xffff);
+	m->next_attr_instance = cpu_to_le16((le16_to_cpu(m->next_attr_instance)
+			+ 1) & 0xffff);
 	a->lowest_vcn = cpu_to_le64(0);
 	a->highest_vcn = cpu_to_le64(highest_vcn - 1LL);
-	a->mapping_pairs_offset = cpu_to_le16(hdr_size + (name_len + 7 & ~7));
+	a->mapping_pairs_offset = cpu_to_le16(hdr_size + ((name_len + 7) & ~7));
 	memset(a->reserved1, 0, sizeof(a->reserved1));
 	// FIXME: Allocated size depends on compression.
@@ -1325,5 +1327,5 @@
 				"\n");
 		err = build_mapping_pairs((char*)a + hdr_size + 
-				(name_len + 7 & ~7), mpa_size, rl);
+				((name_len + 7) & ~7), mpa_size, rl);
 	}
 	a->initialized_size = cpu_to_le64(inited_size);
@@ -1355,6 +1357,6 @@
 	__u16 hdr_size;
 	int asize, mpa_size, err, i;
-	run_list *rl;
-	__s64 bw;
+	run_list *rl = NULL;
+	__s64 bw = 0;
 	uchar_t *uname;
 /*
@@ -1427,5 +1429,5 @@
 	}
 	/* Mapping pairs array and next attribute must be 8-byte aligned. */
-	asize = ((int)hdr_size + (name_len + 7 & ~7) + mpa_size) + 7 & ~7;
+	asize = (((int)hdr_size + ((name_len + 7) & ~7) + mpa_size) + 7) & ~7;
 	err = make_room_for_attribute(m, (char*)a, asize);
 	if (err == -ENOSPC) {
@@ -1462,14 +1464,14 @@
 	a->flags = flags;
 	a->instance = m->next_attr_instance;
-	m->next_attr_instance = cpu_to_le16(le16_to_cpu(m->next_attr_instance)
-								+ 1 & 0xffff);
+	m->next_attr_instance = cpu_to_le16((le16_to_cpu(m->next_attr_instance)
+			+ 1) & 0xffff);
 	a->lowest_vcn = cpu_to_le64(0);
 	for (i = 0; rl[i].length; i++)
 		;
 	a->highest_vcn = cpu_to_le64(rl[i].vcn - 1);
-	a->mapping_pairs_offset = cpu_to_le16(hdr_size + (name_len + 7 & ~7));
+	a->mapping_pairs_offset = cpu_to_le16(hdr_size + ((name_len + 7) & ~7));
 	memset(a->reserved1, 0, sizeof(a->reserved1));
 	// FIXME: Allocated size depends on compression.
-	a->allocated_size = cpu_to_le64(val_len + (opt.cluster_size - 1) &
+	a->allocated_size = cpu_to_le64((val_len + (opt.cluster_size - 1)) &
 			~(opt.cluster_size - 1));
 	a->data_size = cpu_to_le64(val_len);
@@ -1497,5 +1499,5 @@
 				"\n");
 		err = build_mapping_pairs((char*)a + hdr_size + 
-				(name_len + 7 & ~7), mpa_size, rl);
+				((name_len + 7) & ~7), mpa_size, rl);
 	}
 	if (err < 0 || bw != val_len) {
@@ -1526,5 +1528,5 @@
 {
 	attr_search_context *ctx;
-	ATTR_RECORD *a;
+	ATTR_RECORD *a = NULL;
 	int asize, err, i;
 	uchar_t *uname;
@@ -1556,5 +1558,5 @@
 	a = ctx->attr;
 	/* sizeof(resident attribute record header) == 24 */
-	asize = (24 + (name_len + 7 & ~7) + val_len) + 7 & ~7;
+	asize = ((24 + ((name_len + 7) & ~7) + val_len) + 7) & ~7;
 	err = make_room_for_attribute(m, (char*)a, asize);
 	if (err == -ENOSPC) {
@@ -1591,8 +1593,8 @@
 	a->flags = cpu_to_le16(flags);
 	a->instance = m->next_attr_instance;
-	m->next_attr_instance = cpu_to_le16(le16_to_cpu(m->next_attr_instance)
-								+ 1 & 0xffff);
+	m->next_attr_instance = cpu_to_le16((le16_to_cpu(m->next_attr_instance)
+			+ 1) & 0xffff);
 	a->value_length = cpu_to_le32(val_len);
-	a->value_offset = cpu_to_le16(24 + (name_len + 7 & ~7));
+	a->value_offset = cpu_to_le16(24 + ((name_len + 7) & ~7));
 	a->resident_flags = res_flags;
 	a->reservedR = 0;
@@ -1604,5 +1606,5 @@
 	if (uname)
 		free(uname);
-	if (val_len)
+	if (val_len && a)
 		memcpy((char*)a + le16_to_cpu(a->value_offset), val, val_len);
 	return err;
@@ -1877,5 +1879,5 @@
 	INDEX_ROOT *r;
 	INDEX_ENTRY_HEADER *e;
-	int i, err, val_len;
+	int err, val_len;
 
 	val_len = sizeof(INDEX_ROOT) + sizeof(INDEX_ENTRY_HEADER);
@@ -1903,5 +1905,5 @@
 				opt.cluster_size;
 	} else /* if (opt.cluster_size > index_block_size) */ {
-		if (index_block_size & index_block_size - 1) {
+		if (index_block_size & (index_block_size - 1)) {
 			Eprintf("add_attr_index_root: index block size is not "
 					"a power of 2.\n");
@@ -2023,10 +2025,10 @@
 	ATTR_RECORD *a;
 	INDEX_ROOT *r;
-	INDEX_ENTRY *re, *ae;
+	INDEX_ENTRY *re;
 	INDEX_ALLOCATION *ia_val = NULL;
 	uchar_t *uname;
 	char bmp[8];
 	char *re_start, *re_end;
-	int i, err, r_size, index_block_size;
+	int i, err, index_block_size;
 	
 	if (name_len) {
@@ -2099,6 +2101,6 @@
 	ia_val->index.flags = LEAF_NODE;
 	/* Align to 8-byte boundary. */
-	ia_val->index.entries_offset = cpu_to_le32(sizeof(INDEX_HEADER) +
-			le16_to_cpu(ia_val->usa_count) * 2 + 7 & ~7);
+	ia_val->index.entries_offset = cpu_to_le32((sizeof(INDEX_HEADER) +
+			le16_to_cpu(ia_val->usa_count) * 2 + 7) & ~7);
 	ia_val->index.allocated_size = cpu_to_le32(index_block_size -
 			(sizeof(INDEX_ALLOCATION) - sizeof(INDEX_HEADER)));
@@ -2182,5 +2184,5 @@
 	 * appropriate codes exist for simplicity of parsing the return value.
 	 */
-	if (size != (size + 7 & ~7)) {
+	if (size != ((size + 7) & ~7)) {
 		Eprintf("make_room_for_index_entry_in_index_block() received "
 				"non 8-byte aligned size.\n");
@@ -2225,5 +2227,5 @@
 		FILE_NAME_ATTR *file_name, __u32 file_name_size)
 {
-	int err, ie_key_len, i;
+	int err, i;
 	INDEX_ENTRY *ie;
 	char *index_end;
@@ -2325,5 +2327,5 @@
 		ie = (INDEX_ENTRY*)((char*)ie + le16_to_cpu(ie->length));
 	};
-	i = sizeof(INDEX_ENTRY_HEADER) + file_name_size + 7 & ~7;
+	i = (sizeof(INDEX_ENTRY_HEADER) + file_name_size + 7) & ~7;
 	err = make_room_for_index_entry_in_index_block(index, ie, i);
 	if (err) {
@@ -2724,6 +2726,4 @@
 int main(int argc, char **argv)
 {
-	const char *OK = "OK";
-	const char *FAILED = "FAILED";
 	int i, j, err;
 	ssize_t bw;
@@ -2922,8 +2922,8 @@
 			opt.nr_clusters);
 	/* Determine lcn bitmap byte size and allocate it. */
-	lcn_bitmap_byte_size = opt.nr_clusters + 7 >> 3;
+	lcn_bitmap_byte_size = (opt.nr_clusters + 7) >> 3;
 	/* Needs to be multiple of 8 bytes. */
-	lcn_bitmap_byte_size = lcn_bitmap_byte_size + 7 & ~7;
-	i = lcn_bitmap_byte_size + opt.cluster_size - 1 &
+	lcn_bitmap_byte_size = (lcn_bitmap_byte_size + 7) & ~7;
+	i = (lcn_bitmap_byte_size + opt.cluster_size - 1) &
 			~(opt.cluster_size - 1);
 	Dprintf("lcn_bitmap_byte_size = %i, allocated = %i\n",
@@ -2949,7 +2949,7 @@
 	mft_bitmap_size = opt.mft_size / opt.mft_record_size;
 	/* Convert to bytes, at least one. */
-	mft_bitmap_byte_size = mft_bitmap_size + 7 >> 3;
+	mft_bitmap_byte_size = (mft_bitmap_size + 7) >> 3;
 	/* Mft bitmap is allocated in multiples of 8 bytes. */
-	mft_bitmap_byte_size = mft_bitmap_byte_size + 7 & ~7;
+	mft_bitmap_byte_size = (mft_bitmap_byte_size + 7) & ~7;
 	Dprintf("mft_bitmap_size = %i, mft_bitmap_byte_size = %i\n",
 			mft_bitmap_size, mft_bitmap_byte_size);
@@ -3396,5 +3396,5 @@
 		err = create_hardlink(index_block, root_ref, m,
 				MAKE_MFT_REF(FILE_$AttrDef, FILE_$AttrDef),
-				buf2_size + opt.cluster_size - 1 &
+				(buf2_size + opt.cluster_size - 1) &
 				~(opt.cluster_size - 1), buf2_size,
 				FILE_ATTR_HIDDEN | FILE_ATTR_SYSTEM, 0, 0,
@@ -3415,5 +3415,5 @@
 		err = create_hardlink(index_block, root_ref, m,
 				MAKE_MFT_REF(FILE_$Bitmap, FILE_$Bitmap),
-				lcn_bitmap_byte_size + opt.cluster_size - 1 &
+				(lcn_bitmap_byte_size + opt.cluster_size - 1) &
 				~(opt.cluster_size - 1), lcn_bitmap_byte_size,
 				FILE_ATTR_HIDDEN | FILE_ATTR_SYSTEM, 0, 0,
@@ -3494,5 +3494,5 @@
 		err = create_hardlink(index_block, root_ref, m,
 				MAKE_MFT_REF(FILE_$Boot, FILE_$Boot),
-				8192 + opt.cluster_size - 1 &
+				(8192 + opt.cluster_size - 1) &
 				~(opt.cluster_size - 1), 8192,
 				FILE_ATTR_HIDDEN | FILE_ATTR_SYSTEM, 0, 0,
@@ -3579,5 +3579,5 @@
 		err = create_hardlink(index_block, root_ref, m,
 				MAKE_MFT_REF(FILE_$UpCase, FILE_$UpCase),
-				(opt.upcase_len << 1) + opt.cluster_size - 1 &
+				((opt.upcase_len << 1) + opt.cluster_size - 1) &
 				~(opt.cluster_size - 1), opt.upcase_len << 1,
 				FILE_ATTR_HIDDEN | FILE_ATTR_SYSTEM, 0, 0,

Index: sd.c
===================================================================
RCS file: /cvsroot/linux-ntfs/linux-ntfs/ntfstools/sd.c,v
retrieving revision 1.2
retrieving revision 1.3
diff -U2 -r1.2 -r1.3
--- sd.c	10 Jun 2001 15:54:20 -0000	1.2
+++ sd.c	15 Apr 2002 20:04:30 -0000	1.3
@@ -31,5 +31,4 @@
 	SECURITY_DESCRIPTOR_RELATIVE *sd;
 	ACL *acl;
-	ACE_HEADER *ace_hdr;
 	ACCESS_ALLOWED_ACE *aa_ace;
 	SID *sid;

Index: upcase.c
===================================================================
RCS file: /cvsroot/linux-ntfs/linux-ntfs/ntfstools/upcase.c,v
retrieving revision 1.2
retrieving revision 1.3
diff -U2 -r1.2 -r1.3
--- upcase.c	10 Jun 2001 02:25:38 -0000	1.2
+++ upcase.c	15 Apr 2002 20:04:31 -0000	1.3
@@ -23,4 +23,6 @@
  */
 
+#include <string.h>
+
 #include "types.h"
 

[Linux-NTFS-cvs] CVS: linux-ntfs/libntfs mft.c,1.17,1.18 volume.c,1.23,1.24

[Anton A. <an...@us...>]

Changes by: antona

Update of /cvsroot/linux-ntfs/linux-ntfs/libntfs
In directory usw-pr-cvs1:/tmp/cvs-serv12277/libntfs

Modified Files:
	mft.c volume.c 
Log Message:
Really fix the library and mkntfs while at it.


Index: mft.c
===================================================================
RCS file: /cvsroot/linux-ntfs/linux-ntfs/libntfs/mft.c,v
retrieving revision 1.17
retrieving revision 1.18
diff -U2 -r1.17 -r1.18
--- mft.c	15 Apr 2002 18:54:07 -0000	1.17
+++ mft.c	15 Apr 2002 19:02:40 -0000	1.18
@@ -183,5 +183,5 @@
 	if (!(m = (MFT_RECORD*)malloc(vol->mft_record_size)))
 		return -ENOMEM;
-	if ((er = get_mft_record(vol, m, mref)) != 1)
+	if ((er = read_mft_record(vol, *mref, m)) != 1)
 		goto failed;
 	if (!is_file_record(m->magic))

Index: volume.c
===================================================================
RCS file: /cvsroot/linux-ntfs/linux-ntfs/libntfs/volume.c,v
retrieving revision 1.23
retrieving revision 1.24
diff -U2 -r1.23 -r1.24
--- volume.c	15 Apr 2002 18:54:07 -0000	1.23
+++ volume.c	15 Apr 2002 19:02:41 -0000	1.24
@@ -230,5 +230,5 @@
 	}
 	/* Can't use any of the higher level functions yet! */
-	br = mst_pread(vol->fd, vol->mft_lcn << vol->cluster_size_bits, 1,
+	br = ntfs_mst_pread(vol->fd, vol->mft_lcn << vol->cluster_size_bits, 1,
 			vol->mft_record_size, mb);
 	if (br != 1) {

[Linux-NTFS-cvs] CVS: linux-ntfs/ntfstools mkntfs.c,1.61,1.62

[Anton A. <an...@us...>]

Changes by: antona

Update of /cvsroot/linux-ntfs/linux-ntfs/ntfstools
In directory usw-pr-cvs1:/tmp/cvs-serv12277/ntfstools

Modified Files:
	mkntfs.c 
Log Message:
Really fix the library and mkntfs while at it.


Index: mkntfs.c
===================================================================
RCS file: /cvsroot/linux-ntfs/linux-ntfs/ntfstools/mkntfs.c,v
retrieving revision 1.61
retrieving revision 1.62
diff -U2 -r1.61 -r1.62
--- mkntfs.c	14 Apr 2002 15:26:24 -0000	1.61
+++ mkntfs.c	15 Apr 2002 19:02:41 -0000	1.62
@@ -3689,6 +3689,6 @@
 	for (i = 0; i < opt.mft_size / opt.mft_record_size; i++) {
 		if (!opt.no_action)
-			lw = mst_pwrite(f, buf + i * opt.mft_record_size,
-						opt.mft_record_size, pos);
+			lw = ntfs_mst_pwrite(f, pos, 1, opt.mft_record_size,
+					buf + i * opt.mft_record_size);
 		if (lw != opt.mft_record_size)
 			err_exit("%s\n", lw == -1 ? strerror(errno) :
@@ -3715,6 +3715,6 @@
 		*usnp = cpu_to_le16(usn);
 		if (!opt.no_action)
-			lw = mst_pwrite(f, buf + i * opt.mft_record_size,
-					opt.mft_record_size, pos);
+			lw = ntfs_mst_pwrite(f, pos, 1, opt.mft_record_size,
+					buf + i * opt.mft_record_size);
 		if (lw != opt.mft_record_size)
 			err_exit("%s\n", lw == -1 ? strerror(errno) :

[Linux-NTFS-cvs] CVS: linux-ntfs/ntfstools ntfsfix.c,1.23,1.24

[Anton A. <an...@us...>]

Changes by: antona

Update of /cvsroot/linux-ntfs/linux-ntfs/ntfstools
In directory usw-pr-cvs1:/tmp/cvs-serv16914/ntfstools

Modified Files:
	ntfsfix.c 
Log Message:
Fix ntfsfix as well. This completes all changes and everything should be just as functional as before.


Index: ntfsfix.c
===================================================================
RCS file: /cvsroot/linux-ntfs/linux-ntfs/ntfstools/ntfsfix.c,v
retrieving revision 1.23
retrieving revision 1.24
diff -U2 -r1.23 -r1.24
--- ntfsfix.c	14 Apr 2002 14:15:47 -0000	1.23
+++ ntfsfix.c	15 Apr 2002 19:17:24 -0000	1.24
@@ -129,6 +129,6 @@
 	/* Read $MFT and $MFTmirr. */
 	printf("Going to read $Mft... ");
-	*(__u64*)&mref = FILE_$MFT;
-	br = get_mft_records(vol, (MFT_RECORD*)b1, &mref, 4);
+	mref = (MFT_REF)FILE_$MFT;
+	br = read_mft_records(vol, mref, 4, (MFT_RECORD*)b1);
 	if (br != 4) {
 		puts(FAILED);
@@ -136,9 +136,9 @@
 	}
 	puts(OK);
-	/* Use mst_pread as we don't want to rely on information in $Mft for
-	 * locating $MftMirr as that would defeat the point of $MftMirr. */
+	/* Use ntfs_mst_pread as we don't want to rely on information in $Mft
+	 * for locating $MftMirr as that would defeat the point of $MftMirr. */
 	printf("Going to read $MftMirr... ");
-	br = mst_pread(vol->fd, b2, mrs, 4, vol->mftmirr_lcn <<
-		       				vol->cluster_size_bits);
+	br = ntfs_mst_pread(vol->fd, vol->mftmirr_lcn << vol->cluster_size_bits,
+			4, mrs, b2);
 	if (br != 4) {
 		puts(FAILED);
@@ -245,11 +245,12 @@
 			memcpy(b2 + mrs * i, b1 + mrs * i, mrs);
 			/* Do the writes now. */
-			*(__u64*)&mref = i;
-			br = put_mft_record(vol, b1 + mrs * i, &mref);
+			mref = (MFT_REF)i;
+			br = write_mft_record(vol, mref,
+					(MFT_RECORD*)(b1 + mrs * i));
 			if (br != 1)
 				goto mirr_sync_failed;
-			br = mst_pwrite(vol->fd, b2 + mrs * i, mrs, 
-			     (vol->mftmirr_lcn * vol->cluster_size) + 
-			     					(i * mrs));
+			br = ntfs_mst_pwrite(vol->fd, (vol->mftmirr_lcn <<
+					vol->cluster_size_bits) + i * mrs, 1,
+					mrs, b2 + mrs * i);
 			/* If we succeeded then do the next record. */
 			if (br == mrs)
@@ -310,6 +311,6 @@
 	/* Write $Volume to $Mft. */
 	printf("Writing $Volume to $Mft... ");
-	*(__u64*)&mref = FILE_$Volume;
-	br = put_mft_record(vol, b1 + (3 * mrs), &mref);
+	mref = (MFT_REF)FILE_$Volume;
+	br = write_mft_record(vol, mref, (MFT_RECORD*)(b1 + 3 * mrs));
 	if (br != 1) {
 		puts(FAILED);
@@ -325,7 +326,7 @@
 	/* Write $Volume to $MftMirr. */
 	printf("Writing $Volume to $MftMirr... ");
-	br = mst_pwrite(vol->fd, b2 + (3 * mrs), mrs, 
-			(vol->mftmirr_lcn << vol->cluster_size_bits) +
-		       						(3 * mrs));
+	br = ntfs_mst_pwrite(vol->fd, (vol->mftmirr_lcn <<
+			vol->cluster_size_bits) + 3 * mrs, 1, mrs,
+			b2 + 3 * mrs);
 	if (br != mrs) {
 		puts(FAILED);

[Linux-NTFS-cvs] CVS: linux-ntfs/libntfs attrib.c,1.20,1.21 mft.c,1.16,1.17 volume.c,1.22,1.23

[Anton A. <an...@us...>]

Changes by: antona

Update of /cvsroot/linux-ntfs/linux-ntfs/libntfs
In directory usw-pr-cvs1:/tmp/cvs-serv9215/libntfs

Modified Files:
	attrib.c mft.c volume.c 
Log Message:
Update library for the new API.


Index: attrib.c
===================================================================
RCS file: /cvsroot/linux-ntfs/linux-ntfs/libntfs/attrib.c,v
retrieving revision 1.20
retrieving revision 1.21
diff -U2 -r1.20 -r1.21
--- attrib.c	15 Apr 2002 17:51:26 -0000	1.20
+++ attrib.c	15 Apr 2002 18:54:06 -0000	1.21
@@ -340,9 +340,8 @@
 				 * files as well?
 				 */
-				r = ntfs_pread(vol->fd, intbuf,
+				r = ntfs_pread(vol->fd, rl[i].lcn <<
+						vol->cluster_size_bits,
 						vol->cluster_size *
-						rl[i].length,
-						rl[i].lcn <<
-						vol->cluster_size_bits);
+						rl[i].length, intbuf);
 				if (r != rl[i].length) {
 #define ESTR "Error reading attribute value"
@@ -376,8 +375,8 @@
 				 * be 16 (= compression unit size).
 				 */
-				r = ntfs_pread(vol->fd, b + total,
+				r = ntfs_pread(vol->fd, rl[i].lcn <<
+						vol->cluster_size_bits,
 						vol->cluster_size *
-						rl[i].length, rl[i].lcn <<
-						vol->cluster_size_bits);
+						rl[i].length, b + total);
 				if (r != rl[i].length) {
 #define ESTR "Error reading attribute value"
@@ -454,9 +453,10 @@
 		/* Now write all clusters to disk from b. */
 		for (i = 0, total = 0; rl[i].length && (l > 0); i++) {
-			w = ntfs_pwrite(vol->fd, b + total,
-				min(l, rl[i].length << vol->cluster_size_bits),
-				rl[i].lcn << vol->cluster_size_bits);
+			w = ntfs_pwrite(vol->fd, rl[i].lcn <<
+					vol->cluster_size_bits, min(l,
+					rl[i].length << vol->cluster_size_bits),
+					b + total);
 			if (w != min(l, rl[i].length <<
-						vol->cluster_size_bits)) {
+					vol->cluster_size_bits)) {
 #define ESTR "Error writing attribute value"
 				if (w == -1) {

Index: mft.c
===================================================================
RCS file: /cvsroot/linux-ntfs/linux-ntfs/libntfs/mft.c,v
retrieving revision 1.16
retrieving revision 1.17
diff -U2 -r1.16 -r1.17
--- mft.c	15 Apr 2002 18:39:37 -0000	1.16
+++ mft.c	15 Apr 2002 18:54:07 -0000	1.17
@@ -181,5 +181,5 @@
 		return -EINVAL;
 	}
-	if (!(m = malloc(vol->mft_record_size)))
+	if (!(m = (MFT_RECORD*)malloc(vol->mft_record_size)))
 		return -ENOMEM;
 	if ((er = get_mft_record(vol, m, mref)) != 1)

Index: volume.c
===================================================================
RCS file: /cvsroot/linux-ntfs/linux-ntfs/libntfs/volume.c,v
retrieving revision 1.22
retrieving revision 1.23
diff -U2 -r1.22 -r1.23
--- volume.c	15 Apr 2002 00:42:08 -0000	1.22
+++ volume.c	15 Apr 2002 18:54:07 -0000	1.23
@@ -137,5 +137,5 @@
 	}
 	/* Now read the bootsector. */
-	br = ntfs_pread(vol->fd, bs, sizeof(NTFS_BOOT_SECTOR), 0);
+	br = ntfs_pread(vol->fd, 0, sizeof(NTFS_BOOT_SECTOR), bs);
 	if (br != 1) {
 		Dputs(FAILED);
@@ -230,6 +230,6 @@
 	}
 	/* Can't use any of the higher level functions yet! */
-	br = mst_pread(vol->fd, (char*)mb, vol->mft_record_size, 1, 
-					vol->mft_lcn << vol->cluster_size_bits);
+	br = mst_pread(vol->fd, vol->mft_lcn << vol->cluster_size_bits, 1,
+			vol->mft_record_size, mb);
 	if (br != 1) {
 		Dputs(FAILED);

[Linux-NTFS-cvs] CVS: linux-ntfs/include disk_io.h,1.12,1.13

[Anton A. <an...@us...>]

Changes by: antona

Update of /cvsroot/linux-ntfs/linux-ntfs/include
In directory usw-pr-cvs1:/tmp/cvs-serv4378/include

Modified Files:
	disk_io.h 
Log Message:
Cleanup some mistakes.


Index: disk_io.h
===================================================================
RCS file: /cvsroot/linux-ntfs/linux-ntfs/include/disk_io.h,v
retrieving revision 1.12
retrieving revision 1.13
diff -U2 -r1.12 -r1.13
--- disk_io.h	15 Apr 2002 17:51:26 -0000	1.12
+++ disk_io.h	15 Apr 2002 18:39:36 -0000	1.13
@@ -38,7 +38,7 @@
 
 extern __s64 ntfs_read_clusters(const ntfs_volume *vol, const __s64 lcn,
-		__s64 count, const void *b)
+		__s64 count, const void *b);
 extern __s64 ntfs_write_clusters(const ntfs_volume *vol, const __s64 lcn,
-		__s64 count, const void *b)
+		__s64 count, const void *b);
 
 #endif /* defined DISK_IO_H */

[Linux-NTFS-cvs] CVS: linux-ntfs/libntfs disk_io.c,1.18,1.19 mft.c,1.15,1.16

[Anton A. <an...@us...>]

Changes by: antona

Update of /cvsroot/linux-ntfs/linux-ntfs/libntfs
In directory usw-pr-cvs1:/tmp/cvs-serv4378/libntfs

Modified Files:
	disk_io.c mft.c 
Log Message:
Cleanup some mistakes.


Index: disk_io.c
===================================================================
RCS file: /cvsroot/linux-ntfs/linux-ntfs/libntfs/disk_io.c,v
retrieving revision 1.18
retrieving revision 1.19
diff -U2 -r1.18 -r1.19
--- disk_io.c	15 Apr 2002 17:51:26 -0000	1.18
+++ disk_io.c	15 Apr 2002 18:39:37 -0000	1.19
@@ -211,5 +211,5 @@
 		const __u32 bksize, const void *b)
 {
-	__s64 written, towrite, total;
+	__s64 written, towrite, total, i;
 	char retry;
 	

Index: mft.c
===================================================================
RCS file: /cvsroot/linux-ntfs/linux-ntfs/libntfs/mft.c,v
retrieving revision 1.15
retrieving revision 1.16
diff -U2 -r1.15 -r1.16
--- mft.c	15 Apr 2002 17:51:26 -0000	1.15
+++ mft.c	15 Apr 2002 18:39:37 -0000	1.16
@@ -22,4 +22,6 @@
  */
 
+#include <errno.h>
+
 #include "mft.h"
 #include "disk_io.h"

[Linux-NTFS-cvs] CVS: linux-ntfs/include attrib.h,1.27,1.28 disk_io.h,1.11,1.12 mft.h,1.27,1.28

[Anton A. <an...@us...>]

Changes by: antona

Update of /cvsroot/linux-ntfs/linux-ntfs/include
In directory usw-pr-cvs1:/tmp/cvs-serv12122/include

Modified Files:
	attrib.h disk_io.h mft.h 
Log Message:
read/write_mft_record(s) are here


Index: attrib.h
===================================================================
RCS file: /cvsroot/linux-ntfs/linux-ntfs/include/attrib.h,v
retrieving revision 1.27
retrieving revision 1.28
diff -U2 -r1.27 -r1.28
--- attrib.h	14 Apr 2002 13:56:45 -0000	1.27
+++ attrib.h	15 Apr 2002 17:51:26 -0000	1.28
@@ -37,4 +37,6 @@
 } LCN_SPECIAL_VALUES;
 
+LCN vcn_to_lcn(const run_list_element *rl, const VCN vcn);
+
 /**
  * attr_search_context - used in attribute search functions
@@ -83,26 +85,4 @@
  */
 run_list *decompress_run_list(const ATTR_RECORD *attr);
-
-/**
- * vcn_to_lcn - determine the lcn corresponding to a particular vcn
- * @rl:		decompressed mapping pairs array (i.e. run list)
- * @vcn:	virtucal cluster number for which to determine the lcn
- *
- * Determine the logical cluster number given the virtual cluster number @vcn
- * and the run list @rl describing the mapping between the LCNs and VCNs. 
- * 
- * Return values:
- * 
- * 	> 0: The lcn corresponding to the vcn.
- * 	
- * 	0: Check errno:
- * 		0	The lcn corresponding to the vcn is really zero.
- *		ENOENT	We are looking for a vcn which doesn't exist.
- * 		EINVAL	Either @rl or @vcn are invalid.
- * 		
- *	-1: The lcn is sparse, i.e. it's contents are zero and there is no disk
- *	    space allocated for it.
- */
-LCN vcn_to_lcn(const run_list *rl, const VCN vcn);
 
 /**

Index: disk_io.h
===================================================================
RCS file: /cvsroot/linux-ntfs/linux-ntfs/include/disk_io.h,v
retrieving revision 1.11
retrieving revision 1.12
diff -U2 -r1.11 -r1.12
--- disk_io.h	15 Apr 2002 00:45:28 -0000	1.11
+++ disk_io.h	15 Apr 2002 17:51:26 -0000	1.12
@@ -27,15 +27,17 @@
 #include "types.h"
 
-extern __s64 ntfs_pread(const int fd, const __s64 pos, __s64 count, void *b);
-extern __s64 ntfs_pwrite(int fd, const __s64 pos, __s64 count, const void *b);
+extern __s64 ntfs_pread(const int fd, const __s64 pos, __s64 count,
+		const void *b);
+extern __s64 ntfs_pwrite(const int fd, const __s64 pos, __s64 count,
+		const void *b);
 
 extern __s64 ntfs_mst_pread(const int fd, const __s64 pos, __s64 count,
-		const __u32 bksize, void *b);
-extern __s64 ntfs_mst_pwrite(int fd, const __s64 pos, const __s64 count,
+		const __u32 bksize, const void *b);
+extern __s64 ntfs_mst_pwrite(const int fd, const __s64 pos, const __s64 count,
 		const __u32 bksize, const void *b);
 
 extern __s64 ntfs_read_clusters(const ntfs_volume *vol, const __s64 lcn,
-		__s64 count, void *b)
-extern __s64 ntfs_write_clusters(ntfs_volume *vol, const __s64 lcn,
+		__s64 count, const void *b)
+extern __s64 ntfs_write_clusters(const ntfs_volume *vol, const __s64 lcn,
 		__s64 count, const void *b)
 

Index: mft.h
===================================================================
RCS file: /cvsroot/linux-ntfs/linux-ntfs/include/mft.h,v
retrieving revision 1.27
retrieving revision 1.28
diff -U2 -r1.27 -r1.28
--- mft.h	15 Apr 2002 00:45:28 -0000	1.27
+++ mft.h	15 Apr 2002 17:51:26 -0000	1.28
@@ -28,4 +28,52 @@
 #include "endians.h"
 
+extern __s64 read_mft_records(const ntfs_volume *vol, const MFT_REF mref,
+		const __s64 count, const MFT_RECORD *b);
+
+/**
+ * read_mft_record - read a record from the mft
+ * @vol:	volume to read from
+ * @mref:	mft record number to read
+ * @b:		output data buffer
+ *
+ * Read the mft record specified by @mref from volume @vol into buffer @b.
+ * Return 1 on success or -1 on error, with errno set to the error code.
+ *
+ * The read mft record is mst deprotected and is hence ready to use. The caller
+ * should check the record with is_baad_recordp() in case mst deprotection
+ * failed.
+ *
+ * NOTE: @b has to be at least of size vol->mft_record_size.
+ */
+static __inline__ int read_mft_record(const ntfs_volume *vol,
+		const MFT_REF mref, const MFT_RECORD *b)
+{
+	return (int)read_mft_records(vol, mref, 1, b);
+}
+
+extern __s64 write_mft_records(const ntfs_volume *vol, const MFT_REF mref,
+		const __s64 count, const MFT_RECORD *b);
+
+/**
+ * write_mft_record - write an mft record to disk
+ * @vol:	volume to write to
+ * @mref:	mft record number to write
+ * @b:		data buffer containing the mft record to write
+ *
+ * Write the mft record specified by @mref from buffer @b to volume @vol.
+ * Return 1 on success or -1 on error, with errno set to the error code.
+ *
+ * Before the mft record is written, it is mst protected. After the write, it
+ * is deprotected again, thus resulting in an increase in the update sequence
+ * number inside the buffer @b.
+ *
+ * NOTE: @b has to be at least of size vol->mft_record_size.
+ */
+static __inline__ int write_mft_record(const ntfs_volume *vol,
+		const MFT_REF mref, const MFT_RECORD *b)
+{
+	return (int)write_mft_records(vol, mref, 1, b);
+}
+
 /**
  * get_mft_record_data_size - return number of bytes used in mft record @b
@@ -51,16 +99,4 @@
 	return le32_to_cpu(b->bytes_in_use);
 }
-
-extern int get_mft_records(const ntfs_volume *vol, const MFT_RECORD *mrec,
-		const MFT_REF *mref, const int count);
-
-extern int get_mft_record(const ntfs_volume *vol, const MFT_RECORD *mrec,
-		const MFT_REF *mref);
-
-extern int __read_file_record(const ntfs_volume *vol, const MFT_REF *mref,
-		MFT_RECORD **mrec, ATTR_RECORD **attr);
-
-extern int put_mft_record(ntfs_volume *vol, const __u8 *buf,
-		const MFT_REF *mref);
 
 #endif /* defined MFT_H */

[Linux-NTFS-cvs] CVS: linux-ntfs ChangeLog,1.33,1.34

[Anton A. <an...@us...>]

Changes by: antona

Update of /cvsroot/linux-ntfs/linux-ntfs
In directory usw-pr-cvs1:/tmp/cvs-serv12122

Modified Files:
	ChangeLog 
Log Message:
read/write_mft_record(s) are here


Index: ChangeLog
===================================================================
RCS file: /cvsroot/linux-ntfs/linux-ntfs/ChangeLog,v
retrieving revision 1.33
retrieving revision 1.34
diff -U2 -r1.33 -r1.34
--- ChangeLog	14 Apr 2002 15:26:23 -0000	1.33
+++ ChangeLog	15 Apr 2002 17:51:26 -0000	1.34
@@ -11,4 +11,5 @@
 	- Remove find_first_attr(). Just use get_attr_search_ctx() +
 	  find_attr() which has the same effect.
+	- Rewrite disk_io.[ch] and mft.[ch] defining new access API.
 
 12/03/2002 - 1.6.0 - More mkntfs options and cleanups.

[Linux-NTFS-cvs] CVS: linux-ntfs/libntfs attrib.c,1.19,1.20 disk_io.c,1.17,1.18 mft.c,1.14,1.15

[Anton A. <an...@us...>]

Changes by: antona

Update of /cvsroot/linux-ntfs/linux-ntfs/libntfs
In directory usw-pr-cvs1:/tmp/cvs-serv12122/libntfs

Modified Files:
	attrib.c disk_io.c mft.c 
Log Message:
read/write_mft_record(s) are here


Index: attrib.c
===================================================================
RCS file: /cvsroot/linux-ntfs/linux-ntfs/libntfs/attrib.c,v
retrieving revision 1.19
retrieving revision 1.20
diff -U2 -r1.19 -r1.20
--- attrib.c	15 Apr 2002 00:42:07 -0000	1.19
+++ attrib.c	15 Apr 2002 17:51:26 -0000	1.20
@@ -681,26 +681,58 @@
 }
 
-LCN vcn_to_lcn(const run_list *rl, const VCN vcn)
+/* Already cleaned up code below, but still look for FIXME:... */
+
+/**
+ * vcn_to_lcn - convert a vcn into a lcn given a run list
+ * @rl:		run list to use for conversion
+ * @vcn:	vcn to convert
+ *
+ * Convert the virtual cluster number @vcn of an attribute into a logical
+ * cluster number (lcn) of a device using the run list @rl to map vcns to their
+ * corresponding lcns.
+ *
+ * Since lcns must be >= 0, we use negative return values with special meaning:
+ *
+ * Return value			Meaning / Description
+ * ==================================================
+ *  -1 = LCN_HOLE		Hole / not allocated on disk.
+ *  -2 = LCN_RL_NOT_MAPPED	This is part of the run list which has not been
+ *				inserted into the run list yet.
+ *  -3 = LCN_ENOENT		There is no such vcn in the attribute.
+ *  -4 = LCN_EINVAL		Input parameter error.
+ */
+LCN vcn_to_lcn(const run_list_element *rl, const VCN vcn)
 {
-	int i = 0;
-	
-	if (!rl || vcn < 0) {
-		errno = EINVAL;
-		return 0;
-	}
-	if (!rl[0].length || vcn < rl[0].vcn) {
-		errno = ENOENT;
-		return 0;
-	}
-	do {
+	int i;
+
+	if (vcn < (VCN)0)
+		return (LCN)LCN_EINVAL;
+	/*
+	 * If rl is NULL, assume that we have found an unmapped run list. The
+	 * caller can then attempt to map it and fail appropriately if
+	 * necessary.
+	 */
+	if (!rl)
+		return (LCN)LCN_RL_NOT_MAPPED;
+
+	/* Catch out of lower bounds vcn. */
+	if (vcn < rl[0].vcn)
+		return (LCN)LCN_ENOENT;
+
+	for (i = 0; rl[i].length; i++) {
 		if (vcn < rl[i+1].vcn) {
-			if (rl[i].lcn == (LCN)-1)
-				return (LCN)-1;
-			errno = 0;
-			return rl[i].lcn + (vcn - rl[i].vcn);
+			if (rl[i].lcn >= (LCN)0)
+				return rl[i].lcn + (vcn - rl[i].vcn);
+			return rl[i].lcn;
 		}
-	} while (rl[++i].length);
-	errno = ENOENT;
-	return 0;
+	}
+	/*
+	 * The terminator element is setup to the correct value, i.e. one of
+	 * LCN_HOLE, LCN_RL_NOT_MAPPED, or LCN_ENOENT.
+	 */
+	if (rl[i].lcn < (LCN)0)
+		return rl[i].lcn;
+	/* Just in case... We could replace this with BUG() some day. */
+	return (LCN)LCN_ENOENT;
 }
 
@@ -749,5 +781,5 @@
 	} /* Attribute list. */
 	if (ctx->ntfs_ino != ctx->base_ntfs_ino)
-		fprintf(stderr, __FUNCTION__ "(): EEEEEK!\n");
+		fprintf(stderr, __FUNCTION__ "(): FIXME: EEEEEK!\n");
 	//	unmap_mft_record(READ, ctx->ntfs_ino);
 	init_attr_search_ctx(ctx, ctx->base_ntfs_ino, ctx->base_mrec);
@@ -782,5 +814,5 @@
 {
 	if (ctx->base_ntfs_ino && ctx->ntfs_ino != ctx->base_ntfs_ino)
-		fprintf(stderr, __FUNCTION__ "(): EEEEEK!\n");
+		fprintf(stderr, __FUNCTION__ "(): FIXME: EEEEEK!\n");
 		//unmap_mft_record(READ, ctx->ntfs_ino);
 	free(ctx);

Index: disk_io.c
===================================================================
RCS file: /cvsroot/linux-ntfs/linux-ntfs/libntfs/disk_io.c,v
retrieving revision 1.17
retrieving revision 1.18
diff -U2 -r1.17 -r1.18
--- disk_io.c	15 Apr 2002 00:42:07 -0000	1.17
+++ disk_io.c	15 Apr 2002 17:51:26 -0000	1.18
@@ -48,5 +48,5 @@
  * case the data pointer @b was NULL.
  */
-__s64 ntfs_pread(const int fd, const __s64 pos, __s64 count, void *b)
+__s64 ntfs_pread(const int fd, const __s64 pos, __s64 count, const void *b)
 {
 	__s64 br, total;
@@ -95,5 +95,5 @@
  * either lseek, malloc, write or fdatasync. Or errno is EINVAL if @b is null.
  */
-__s64 ntfs_pwrite(int fd, const __s64 pos, __s64 count, const void *b)
+__s64 ntfs_pwrite(const int fd, const __s64 pos, __s64 count, const void *b)
 {
 	__s64 written, total;
@@ -158,5 +158,5 @@
  */
 __s64 ntfs_mst_pread(const int fd, const __s64 pos, __s64 count,
-		const __u32 bksize, void *b)
+		const __u32 bksize, const void *b)
 {
 	__s64 br, i;
@@ -208,5 +208,5 @@
  * achieved.
  */
-__s64 ntfs_mst_pwrite(int fd, const __s64 pos, const __s64 count,
+__s64 ntfs_mst_pwrite(const int fd, const __s64 pos, const __s64 count,
 		const __u32 bksize, const void *b)
 {
@@ -274,5 +274,5 @@
  */
 __s64 ntfs_read_clusters(const ntfs_volume *vol, const __s64 lcn, __s64 count,
-		void *b)
+		const void *b)
 {
 	__s64 br;
@@ -315,5 +315,5 @@
  * error, with errno set to the error code.
  */
-__s64 ntfs_write_clusters(ntfs_volume *vol, const __s64 lcn, __s64 count,
+__s64 ntfs_write_clusters(const ntfs_volume *vol, const __s64 lcn, __s64 count,
 		const void *b)
 {

Index: mft.c
===================================================================
RCS file: /cvsroot/linux-ntfs/linux-ntfs/libntfs/mft.c,v
retrieving revision 1.14
retrieving revision 1.15
diff -U2 -r1.14 -r1.15
--- mft.c	15 Apr 2002 00:42:07 -0000	1.14
+++ mft.c	15 Apr 2002 17:51:26 -0000	1.15
@@ -24,22 +24,26 @@
 #include "mft.h"
 #include "disk_io.h"
+#include "debug.h"
 #include "bitmap.h"
 
 /**
- * get_mft_records - read records from the mft from disk
+ * ntfs_read_mft_records - read records from the mft from disk
  * @vol:	volume to read from
- * @mrec:	output data buffer
- * @mref:	starting mft record number
+ * @mref:	starting mft record number to read
  * @count:	number of mft records to read
+ * @b:		output data buffer
  *
  * Read @count mft records starting at @mref from volume @vol into buffer
- * @mrec. Return @count on success or -ERRNO on error, where ERRNO is the error
- * code. This function will do the error reporting so caller really only needs
- * to check for sucess / failure.
+ * @b. Return @count on success or -1 on error, with errno set to the error
+ * code.
  *
- * NOTE: @mrec has to be at least of size @count * vol->mft_record_size.
+ * The read mft records are mst deprotected and are hence ready to use. The
+ * caller should check each record with is_baad_recordp() in case mst
+ * deprotection failed.
+ *
+ * NOTE: @b has to be at least of size @count * vol->mft_record_size.
  */
-int get_mft_records(const ntfs_volume *vol, const MFT_RECORD *mrec,
-		    const MFT_REF *mref, const int count)
+__s64 read_mft_records(const ntfs_volume *vol, const MFT_REF mref,
+		const __s64 count, const MFT_RECORD *b)
 {
 	__s64 br, ofs;
@@ -47,35 +51,35 @@
 	VCN m;
 	
-	if (!vol || !mrec)
+	if (!vol || !b)
 		return -EINVAL;
 	if (!vol->fd)
 		return -EBADF;
-	m = MREF(*mref);
+	m = MREF(mref);
 	if (vol->number_of_mft_records < m + count)
 		return -ESPIPE;
-	if (!ntfs_get_bit(vol->mft_bitmap, m))
-		return -ENOENT;
+	/* Starting cluster of the first mft record to read. */
 	lcn = vcn_to_lcn(vol->mft_runlist, m << vol->mft_record_size_bits >>
-						vol->cluster_size_bits);
-	if (lcn == -1) {
-		perror("Error sparse $Mft records are not supported");
-		return -ENOTSUP;
+			vol->cluster_size_bits);
+	/*
+	 * We always keep the COMPLETE run list for $MFT/$DATA in
+	 * vol->mft_runlist.
+	 */
+	if (lcn < 0) {
+		Dprintf(__FUNCTION__ "(): BUG! vcn_to_lcn() on $MFT/$DATA "
+				"returned %Li.\n", lcn);
+		return lcn;
 	}
+	/* Offset within the cluster of the first mft record to read. */
 	ofs = m << vol->mft_record_size_bits & vol->cluster_size - 1;
-	br = mst_pread(vol->fd, (__u8*)mrec, vol->mft_record_size, count, 
-					(lcn << vol->cluster_size_bits) + ofs);
+	br = ntfs_mst_pread(vol->fd, (lcn << vol->cluster_size_bits) + ofs,
+			count, vol->mft_record_size, b);
 	if (br != count) {
-		int eo = errno;
-#define ESTR "Error reading $Mft record"
-                if (br == -1) {
-                        perror(ESTR);
-			return -eo;
-		} else if (!br)
-                        fprintf(stderr, "Error: partition is smaller than "
-                                        "it should be!?! Weird!\n");
+		if (br != -1)
+			errno = EIO;
+		if (!br)
+			Dputs("Error: partition is smaller than it should be!");
 		else
-                        fprintf(stderr, ESTR ": unknown error\n");
-#undef ESTR
-		return -EIO;
+			Dperror("Error reading $Mft record(s)");
+		return -1;
 	}
 	return br;
@@ -83,23 +87,62 @@
 
 /**
- * get_mft_record - read a record from the mft
- * @vol:	volume to read from
- * @mrec:	output data buffer
- * @mref:	starting mft record number
- * @count:	number of mft records to read
- *
- * Read mft record specified by @mref from volume @vol into buffer @mrec.
- * Return 1 on success or -ERRNO on error, where ERRNO is the error
- * code. This function will do the error reporting so caller really only needs
- * to check for sucess / failure.
- *
- * NOTE: @mrec has to be at least of size vol->mft_record_size.
+ * write_mft_records - write mft records to disk 
+ * @vol:	volume to write to
+ * @mref:	starting mft record number to write
+ * @count:	number of mft records to write
+ * @b:		data buffer containing the mft records to write
+ *
+ * Write mft records starting with @mref from buffer @b to volume @vol. Return
+ * @count on success or -1 on error, with errno set to the error code.
+ *
+ * Before the mft records are written, they are mst protected. After the write,
+ * they are deprotected again, thus resulting in an increase in the update
+ * sequence number inside the buffer @b.
  */
-__inline__ int get_mft_record(const ntfs_volume *vol, const MFT_RECORD *mrec,
-			      const MFT_REF *mref)
+__s64 write_mft_records(const ntfs_volume *vol, const MFT_REF mref,
+		const __s64 count, const MFT_RECORD *b)
 {
-	return get_mft_records(vol, mrec, mref, 1);
+	__s64 bw, ofs;
+	LCN lcn;
+	VCN m;
+
+	if (!vol || !b)
+		return -EINVAL;
+	if (!vol->fd)
+		return -EBADF;
+	m = MREF(mref);
+	if (vol->number_of_mft_records < m + count)
+		return -ESPIPE;
+	/* Starting cluster of the first mft record to write. */
+	lcn = vcn_to_lcn(vol->mft_runlist, m << vol->mft_record_size_bits >>
+			vol->cluster_size_bits);
+	/*
+	 * We always keep the COMPLETE run list for $MFT/$DATA in
+	 * vol->mft_runlist.
+	 */
+	if (lcn < 0) {
+		Dprintf(__FUNCTION__ "(): BUG! vcn_to_lcn() on $MFT/$DATA "
+				"returned %Li.\n", lcn);
+		return lcn;
+	}
+	/* Offset within the cluster of the first mft record to write. */
+	ofs = m << vol->mft_record_size_bits & vol->cluster_size - 1;
+	bw = ntfs_mst_pwrite(vol->fd, (lcn << vol->cluster_size_bits) + ofs,
+			count, vol->mft_record_size, b);
+	if (bw != count) {
+		if (bw != -1)
+			errno = EIO;
+		if (!bw)
+			Dputs("Error: ran out of input data writing $Mft "
+					"record(s)!\n");
+		else
+			Dperror("Error writing $Mft record(s)");
+		return -1;
+	}
+	return bw;
 }
 
+/* FIXME: Old stuff below here. */
+
 /**
  * __read_file_record - read a FILE record from the mft from disk
@@ -191,59 +234,4 @@
 {
 	return -ENOTSUP;
-}
-
-/**
- * put_mft_record - write a record to the mft
- * @vol:	volume to write to
- * @buf:	data buffer containing the mft record to write
- * @mref:	mft record number to write to
- *
- * Write mft record @mref from buffer @buf to volume @vol. Return 1 on
- * success or -ERRNO on error, where ERRNO is the error code. This function
- * will do the error reporting so caller really only needs to check for sucess
- * / failure.
- */
-int put_mft_record(ntfs_volume *vol, const __u8 *buf, const MFT_REF *mref)
-{
-	__s64 bw, m;
-	__s64 lcn, ofs;
-	
-	if (!vol || !buf)
-		return -EINVAL;
-	if (!vol->fd)
-		return -EBADF;
-	m = MREF(*mref);
-	if (vol->number_of_mft_records <= m)
-		return -ESPIPE;
-	if (!ntfs_get_bit(vol->mft_bitmap, m))
-		return -ENOENT;
-	lcn = vcn_to_lcn(vol->mft_runlist, m << vol->mft_record_size_bits >>
-						vol->cluster_size_bits);
-	if (lcn == -1) {
-		perror("Error sparse $Mft records are not supported");
-		return -ENOTSUP;
-	}
-	ofs = m << vol->mft_record_size_bits & vol->cluster_size - 1;
-	if (lcn == -1) {
-		int eo = errno;
-		perror("Error determining on disk location of $Mft record");
-		return -eo;
-	}
-	bw = mst_pwrite(vol->fd, buf, vol->mft_record_size, 
-					(lcn << vol->cluster_size_bits) + ofs);
-	if (bw != vol->mft_record_size) {
-		int eo = errno;
-#define ESTR "Error writing $Mft record"
-                if (bw == -1) {
-                        perror(ESTR);
-			return -eo;
-		} else if (!bw)
-                        fprintf(stderr, ESTR ": Ran out of input data!\n");
-		else
-                        fprintf(stderr, ESTR ": unknown error\n");
-#undef ESTR
-		return -EIO;
-	}
-	return 1;
 }
 

[Linux-NTFS-cvs] CVS: linux-ntfs/include disk_io.h,1.10,1.11 mft.h,1.26,1.27

[Anton A. <an...@us...>]

Changes by: antona

Update of /cvsroot/linux-ntfs/linux-ntfs/include
In directory usw-pr-cvs1:/tmp/cvs-serv29782

Modified Files:
	disk_io.h mft.h 
Log Message:
Update headers to reflect changes in libntfs.


Index: disk_io.h
===================================================================
RCS file: /cvsroot/linux-ntfs/linux-ntfs/include/disk_io.h,v
retrieving revision 1.10
retrieving revision 1.11
diff -U2 -r1.10 -r1.11
--- disk_io.h	14 Apr 2002 13:56:45 -0000	1.10
+++ disk_io.h	15 Apr 2002 00:45:28 -0000	1.11
@@ -27,147 +27,16 @@
 #include "types.h"
 
-/**
- * ntfs_pwrite - positioned write to disk
- * @fd:		file descriptor to write to
- * @b:		data buffer to write to disk
- * @count:	number of bytes to write
- * @pos:	position in file descriptor to write to
- * 
- * This function will write @count bytes of data @b to file descriptor @fd at
- * position @pos.
- *
- * On success return bytes written (0 means nothing written).
- * On error return -1 with errno set appropriately to the return code of 
- * either lseek, malloc, write or fdatasync. Or errno is EINVAL if b is null.
- */
-__s64 ntfs_pwrite(int fd, const void *b, __s64 count, const __s64 pos);
+extern __s64 ntfs_pread(const int fd, const __s64 pos, __s64 count, void *b);
+extern __s64 ntfs_pwrite(int fd, const __s64 pos, __s64 count, const void *b);
 
-/**
- * mst_pwrite - multi sector transfer (mst) positioned write
- * @fd:		file descriptor to write to
- * @b:		data buffer to write to disk
- * @count:	number of bytes to write
- * @pos:	position in file descriptor to write to
- * 
- * Multi sector transfer (mst) positioned write. This function will write
- * @count bytes of data @b to file descriptor @fd at position @pos.
- * 
- * On success return bytes written (0 means nothing written).
- * On error return -1 with errno set appropriately to the return code of 
- * either lseek, malloc, write or fdatasync. Or errno is EINVAL if b is null.
- */
-__s64 mst_pwrite(int fd, const void *b, __s64 count, const __s64 pos);
-
-/**
- * ntfs_pread - positioned read from disk
- * @fd:		file descriptor to read from
- * @b:		output data buffer
- * @bksize:	size of each block
- * @count:	number of blocks to read
- * @pos:	position in file descriptor to read from
- * 
- * This function will read @count @blocks of size @bksize bytes each from file
- * descriptor @fd at position @pos into the buffer @b.
- * 
- * On success, return the number of successfully read blocks. If this number is
- * lower than @count this means that we have reached end of file. 0 means end
- * of file or nothing to read (@count or @bksize is 0). On error, return -1
- * with errno set appropriately to the return code of either lseek or read, or
- * to EINVAL in case the data pointer @b was NULL or the block size (@bksize)
- * was not a multiple of NTFS_SECTOR_SIZE or @bksize was not a power of two.
- * 
- * NOTE: If a read error is encountered we return -1 even if we have already
- * 	 read some blocks successfully (this is subject to change!!!).
- */
-__s64 ntfs_pread(const int fd, void *b, const __u32 bksize, __s64 count,
-	         const __s64 pos);
-
-/**
- * mst_pread - multi sector transfer (mst) positioned read
- * @fd:		file descriptor to read from
- * @b:		output data buffer
- * @bksize:	size of each block
- * @count:	number of blocks to read
- * @pos:	position in file descriptor to read from
- * 
- * Multi sector transfer (mst) positioned read. This function will read @count
- * @blocks of size @bksize bytes each from file descriptor @fd at position @pos
- * into the buffer @b.
- * 
- * On success, return the number of successfully read blocks. If this number is
- * lower than @count this means that we have reached end of file. 0 means end
- * of file or nothing to read (@count or @bksize is 0). On error, return -1
- * with errno set appropriately to the return code of either lseek or read, or
- * to EINVAL in case the data pointer @b was NULL or the block size (@bksize)
- * was not a multiple of NTFS_SECTOR_SIZE or @bksize was not a power of two.
- * 
- * NOTE: If an incomplete multi sector transfer has been detected the magic
- * 	 will have been changed to magic_BAAD but no error will be returned.
- * 	 I.e. it is possible that we return count blocks as being read but that
- * 	 any number (between zero and count!) of these blocks is actually
- * 	 subject to a multi sector transfer error. This should be detected by
- * 	 the caller by checking for the magic being "BAAD".
- * 
- * NOTE: If a read error is encountered we return -1 even if we have already
- * 	 read some blocks successfully (this is subject to change!!!).
- */
-__s64 mst_pread(const int fd, void *b, const __u32 bksize, __s64 count,
-		const __s64 pos);
-
-/**
- * get_clusters - read ntfs clusters
- * @vol:	volume to read from
- * @buf:	output data buffer
- * @lcn:	starting logical cluster number
- * @count:	number of clusters to read
- *
- * Read @count ntfs clusters starting at logical cluster number @lcn from volume
- * @vol into buffer @buf. Return number of clusters read or -ERRNO on error, 
- * where ERRNO is the error code. This function will do the error reporting so
- * caller really only needs to check for sucess / failure.
- *
- * NOTE: @buf has to be at least of size vol->ClusterSize * @count. No checking
- * is performed for this!
- */
-int get_clusters(const ntfs_volume *vol, __u8 *buf, const __s64 lcn,
-		 const int count);
-
-/**
- * put_clusters - write ntfs clusters
- * @vol:	volume to write to
- * @buf:	data buffer to write to disk
- * @lcn:	starting logical cluster number
- * @count:	number of clusters to write
- *
- * Write @count ntfs clusters starting at logical cluster number @lcn from
- * buffer @buf to volume @vol. Return @count on success or -ERRNO on error,
- * where ERRNO is the error code. This function will do the error reporting so
- * caller really only needs to check for sucess / failure.
- */
-int put_clusters(ntfs_volume *vol, const __u8 *buf, const __s64 lcn, int count);
-
-int get_mft_records(const ntfs_volume *vol, const MFT_RECORD *mrec,
-		    const MFT_REF *mref, const int count);
-
-extern __inline__ int get_mft_record(const ntfs_volume *vol,
-				     const MFT_RECORD *mrec,
-				     const MFT_REF *mref);
-
-int __read_file_record(const ntfs_volume *vol, const MFT_REF *mref,
-			MFT_RECORD **mrec, ATTR_RECORD **attr);
-
-/**
- * put_mft_record - write a record to the mft
- * @vol:	volume to write to
- * @buf:	data buffer containing the mft record to write
- * @mref:	mft record number to write to
- *
- * Write mft record @mref from buffer @buf to volume @vol. Return 1 on
- * success or -ERRNO on error, where ERRNO is the error code. This function
- * will do the error reporting so caller really only needs to check for sucess
- * / failure.
- */
-int put_mft_record(ntfs_volume *vol, const __u8 *buf,
-		   const MFT_REF *mref);
+extern __s64 ntfs_mst_pread(const int fd, const __s64 pos, __s64 count,
+		const __u32 bksize, void *b);
+extern __s64 ntfs_mst_pwrite(int fd, const __s64 pos, const __s64 count,
+		const __u32 bksize, const void *b);
+
+extern __s64 ntfs_read_clusters(const ntfs_volume *vol, const __s64 lcn,
+		__s64 count, void *b)
+extern __s64 ntfs_write_clusters(ntfs_volume *vol, const __s64 lcn,
+		__s64 count, const void *b)
 
 #endif /* defined DISK_IO_H */

Index: mft.h
===================================================================
RCS file: /cvsroot/linux-ntfs/linux-ntfs/include/mft.h,v
retrieving revision 1.26
retrieving revision 1.27
diff -U2 -r1.26 -r1.27
--- mft.h	14 Apr 2002 13:56:45 -0000	1.26
+++ mft.h	15 Apr 2002 00:45:28 -0000	1.27
@@ -52,4 +52,16 @@
 }
 
+extern int get_mft_records(const ntfs_volume *vol, const MFT_RECORD *mrec,
+		const MFT_REF *mref, const int count);
+
+extern int get_mft_record(const ntfs_volume *vol, const MFT_RECORD *mrec,
+		const MFT_REF *mref);
+
+extern int __read_file_record(const ntfs_volume *vol, const MFT_REF *mref,
+		MFT_RECORD **mrec, ATTR_RECORD **attr);
+
+extern int put_mft_record(ntfs_volume *vol, const __u8 *buf,
+		const MFT_REF *mref);
+
 #endif /* defined MFT_H */
 

[Linux-NTFS-cvs] CVS: linux-ntfs/libntfs attrib.c,1.18,1.19 disk_io.c,1.16,1.17 mft.c,1.13,1.14 volume.c,1.21,1.22

[Anton A. <an...@us...>]

Changes by: antona

Update of /cvsroot/linux-ntfs/linux-ntfs/libntfs
In directory usw-pr-cvs1:/tmp/cvs-serv29096

Modified Files:
	attrib.c disk_io.c mft.c volume.c 
Log Message:
Big rewrite of disk_io.c. Now should have stable API for low level disk access. Move all mft record related stuff from disk_io.c to mft.c.


Index: attrib.c
===================================================================
RCS file: /cvsroot/linux-ntfs/linux-ntfs/libntfs/attrib.c,v
retrieving revision 1.18
retrieving revision 1.19
diff -U2 -r1.18 -r1.19
--- attrib.c	14 Apr 2002 15:26:23 -0000	1.18
+++ attrib.c	15 Apr 2002 00:42:07 -0000	1.19
@@ -341,8 +341,8 @@
 				 */
 				r = ntfs_pread(vol->fd, intbuf,
-					       vol->cluster_size, 
-					       rl[i].length,
-					       rl[i].lcn << 
-							vol->cluster_size_bits);
+						vol->cluster_size *
+						rl[i].length,
+						rl[i].lcn <<
+						vol->cluster_size_bits);
 				if (r != rl[i].length) {
 #define ESTR "Error reading attribute value"
@@ -377,8 +377,7 @@
 				 */
 				r = ntfs_pread(vol->fd, b + total,
-					       vol->cluster_size, 
-					       rl[i].length,
-					       rl[i].lcn <<
-							vol->cluster_size_bits);
+						vol->cluster_size *
+						rl[i].length, rl[i].lcn <<
+						vol->cluster_size_bits);
 				if (r != rl[i].length) {
 #define ESTR "Error reading attribute value"

Index: disk_io.c
===================================================================
RCS file: /cvsroot/linux-ntfs/linux-ntfs/libntfs/disk_io.c,v
retrieving revision 1.16
retrieving revision 1.17
diff -U2 -r1.16 -r1.17
--- disk_io.c	14 Apr 2002 15:26:23 -0000	1.16
+++ disk_io.c	15 Apr 2002 00:42:07 -0000	1.17
@@ -30,12 +30,75 @@
 #include "types.h"
 #include "disk_io.h"
-#include "bitmap.h"
+#include "debug.h"
 
-__s64 ntfs_pwrite(int fd, const void *b, __s64 count, const __s64 pos)
+/**
+ * ntfs_pread - positioned read from disk
+ * @fd:		file descriptor to read from
+ * @pos:	position in file descriptor to read from
+ * @count:	number of bytes to read
+ * @b:		output data buffer
+ * 
+ * This function will read @count bytes from file descriptor @fd at position
+ * @pos into the buffer @b.
+ * 
+ * On success, return the number of successfully read bytes. If this number is
+ * lower than @count this means that we have reached end of file. 0 means end
+ * of file or nothing to read (@count is 0). On error, return -1 with errno set
+ * appropriately to the return code of either lseek or read, or to EINVAL in
+ * case the data pointer @b was NULL.
+ */
+__s64 ntfs_pread(const int fd, const __s64 pos, __s64 count, void *b)
+{
+	__s64 br, total;
+	char retry;
+	
+	if (!b || count < 0 || pos < 0) {
+		errno = EINVAL;
+		return -1;
+	}
+	if (!count)
+		return 0;
+	/* Locate to position. */
+	if (lseek(fd, pos, SEEK_SET) == (off_t)-1) {
+		Dprintf("ntfs_pread: lseek to 0x%Lx returned error: %s\n", pos,
+				strerror(errno));
+		return -1;
+	}
+	/* Read the data. */
+	total = retry = 0;
+	do {
+		br = read(fd, ((char *)b) + total, count);
+		if (br == -1)
+			return br;
+		else if (!br)
+			++retry;
+		/* We just recycle count as a local variable here. */
+		count -= br;
+		total += br;
+	} while (count && (retry < 3));
+	/* Finally, return the number of bytes read. */
+	return count;
+}
+
+/**
+ * ntfs_pwrite - positioned write to disk
+ * @fd:		file descriptor to write to
+ * @pos:	position in file descriptor to write to
+ * @count:	number of bytes to write
+ * @b:		data buffer to write to disk
+ * 
+ * This function will write @count bytes of data @b to file descriptor @fd at
+ * position @pos.
+ *
+ * On success return bytes written (0 means nothing written).
+ * On error return -1 with errno set appropriately to the return code of 
+ * either lseek, malloc, write or fdatasync. Or errno is EINVAL if @b is null.
+ */
+__s64 ntfs_pwrite(int fd, const __s64 pos, __s64 count, const void *b)
 {
 	__s64 written, total;
 	char retry;
 	
-	if (!b) {
+	if (!b || count < 0 || pos < 0) {
 		errno = EINVAL;
 		return -1;
@@ -44,6 +107,9 @@
 		return 0;
 	/* Locate to position. */
-	if (lseek(fd, pos, SEEK_SET) == (off_t)-1)
+	if (lseek(fd, pos, SEEK_SET) == (off_t)-1) {
+		Dprintf("ntfs_pwrite: lseek to 0x%Lx returned error: %s\n",
+				pos, strerror(errno));
 		return -1;
+	}
 	/* Write the data. */
 	total = retry = 0;
@@ -65,411 +131,217 @@
 }
 
-/*
+/**
+ * ntfs_mst_pread - multi sector transfer (mst) positioned read
+ * @fd:		file descriptor to read from
+ * @pos:	position in file descriptor to read from
+ * @count:	number of blocks to read
+ * @bksize:	size of each block that needs mst deprotecting
+ * @b:		output data buffer
+ * 
+ * Multi sector transfer (mst) positioned read. This function will read @count
+ * @blocks of size @bksize bytes each from file descriptor @fd at position @pos
+ * into the buffer @b.
+ * 
+ * On success, return the number of successfully read blocks. If this number is
+ * lower than @count this means that we have reached end of file. 0 means end
+ * of file or nothing to read (@count or @bksize is 0). On error, return -1
+ * with errno set appropriately to the return code of either lseek or read, or
+ * to EINVAL in case the data pointer @b was NULL or the block size (@bksize)
+ * was not a multiple of NTFS_SECTOR_SIZE or @bksize was not a power of two.
+ * 
+ * NOTE: If an incomplete multi sector transfer has been detected the magic
+ * 	 will have been changed to magic_BAAD but no error will be returned.
+ * 	 I.e. it is possible that we return count blocks as being read but that
+ * 	 any number (between zero and count!) of these blocks is actually
+ * 	 subject to a multi sector transfer error. This should be detected by
+ * 	 the caller by checking for the magic being "BAAD".
+ */
+__s64 ntfs_mst_pread(const int fd, const __s64 pos, __s64 count,
+		const __u32 bksize, void *b)
+{
+	__s64 br, i;
+
+	if (!b || count < 0 || pos < 0 || bksize & bksize - 1 ||
+			bksize % NTFS_SECTOR_SIZE) {
+		errno = EINVAL;
+		return -1;
+	}
+	/* Do the read. */
+	br = ntfs_pread(fd, pos, count * bksize, b);
+	if (br == -1)
+		return br;
+	/*
+	 * Apply fixups to successfully read data, disregarding any errors
+	 * returned from the MST fixup function. This is because we want to
+	 * fixup everything possible and we rely on the fact that the "BAAD"
+	 * magic will be detected later on.
+	 */
+	count = br / bksize;
+	for (i = 0; i < count; ++i)
+		post_read_mst_fixup((NTFS_RECORD*)(b + i * bksize), bksize);
+	/* Finally, return the number of complete blocks read. */
+	return count;
+}
+
+/**
+ * ntfs_mst_pwrite - multi sector transfer (mst) positioned write
+ * @fd:		file descriptor to write to
+ * @pos:	position in file descriptor to write to
+ * @count:	number of blocks to write
+ * @bksize:	size of each block that needs mst protecting
+ * @b:		data buffer to write to disk
+ * 
+ * Multi sector transfer (mst) positioned write. This function will write
+ * @count bytes of data @b to file descriptor @fd at position @pos.
+ * 
+ * On success return bytes written (0 means nothing written).
+ * On error return -1 with errno set appropriately to the return code of 
+ * either lseek, malloc, write or fdatasync. Or errno is EINVAL if @b is null.
+ *
  * NOTE: We mst protect the data, write it, then mst deprotect it using a quick
  * deprotect algorithm (no checking). This saves us from making a copy before
- * the write and at the same causes the usn to be incremented in the buffer.
- * This conceptually fits in better with the idea that cached data is always
- * deprotected and protection is performed when the data is actually going to
- * hit the disk and the cache is immediately deprotected again simulating an
- * mst read on the written data. This way cache coherency is achieved.
+ * the write and at the same time causes the usn to be incremented in the
+ * buffer. This conceptually fits in better with the idea that cached data is
+ * always deprotected and protection is performed when the data is actually
+ * going to hit the disk and the cache is immediately deprotected again
+ * simulating an mst read on the written data. This way cache coherency is
+ * achieved.
  */
-__s64 mst_pwrite(int fd, const void *b, __s64 count, const __s64 pos)
+__s64 ntfs_mst_pwrite(int fd, const __s64 pos, const __s64 count,
+		const __u32 bksize, const void *b)
 {
-	__s64 written, total, error;
+	__s64 written, towrite, total;
 	char retry;
 	
-	if (!b) {
+	if (!b || count < 0 || pos < 0 || bksize & bksize - 1 ||
+			bksize % NTFS_SECTOR_SIZE) {
 		errno = EINVAL;
-		error = -1;
-		goto error_end;
-	}
-	if (!count) {
-		error = 0;
-		goto error_end;
+		return -1;
 	}
-	/* Locate to position. */
+	if (!count)
+		return 0;
+	/* Seek to position. */
 	if (lseek(fd, pos, SEEK_SET) == (off_t)-1) {
-		error = -1;
-		goto error_end;
+		Dprintf("ntfs_mst_pwrite: lseek to 0x%Lx returned error: %s\n",
+				pos, strerror(errno));
+		return -1;
 	}
 	/* Prepare data for writing. */
-	pre_write_mst_fixup((NTFS_RECORD*)b, count);
+	for (i = 0; i < count; ++i)
+		pre_write_mst_fixup((NTFS_RECORD*)(b + i * bksize), bksize);
 	/* Write the prepared data. */
+	towrite = count * bksize;
 	total = retry = 0;
 	do {
-		written = write(fd, ((char *)b) + total, count);
+		written = write(fd, ((char *)b) + total, towrite);
 		if (written == -1) {
-			error = -1;
+			total = -1;
 			goto finished;
-		}
-		else if (!written)
+		} else if (!written)
 			++retry;
 		/* We just recycle count as a local variable here. */
-		count -= written;
+		towrite -= written;
 		total += written;
-	} while (count && (retry < 3));
-	/* Sync write to disk. */
-	if (fdatasync(fd) == -1) {
-		error = -1;
-		goto finished;
-	}
-	/* Finally return the number of bytes written. */
-	error = total;
+	} while (towrite && (retry < 3));
 finished:
 	/* Quickly deprotect the data again. */
-	post_write_mst_fixup((NTFS_RECORD*)b);
-error_end:
-	return error;
+	for (i = 0; i < count; ++i)
+		post_write_mst_fixup((NTFS_RECORD*)(b + i * bksize));
+	/* Sync write to disk. */
+	if (fdatasync(fd) == -1)
+		total = -1;
+	/* Convert bytes written to blocks written. */
+	if (total != -1)
+		total /= bksize;
+	/*
+	 * Finally return the number of complete blocks written or -1 for
+	 * error. We ignore errors where a partial block was written at the end
+	 * because these will be caught later on anyway.
+	 */
+	return total;
 }
 
-__s64 ntfs_pread(const int fd, void *b, const __u32 bksize, __s64 count,
-	         const __s64 pos)
+/**
+ * ntfs_read_clusters - read ntfs clusters
+ * @vol:	volume to read from
+ * @lcn:	starting logical cluster number
+ * @count:	number of clusters to read
+ * @b:		output data buffer
+ *
+ * Read @count ntfs clusters starting at logical cluster number @lcn from
+ * volume @vol into buffer @b. Return number of clusters read or -1 on error, 
+ * with errno set to the error code.
+ */
+__s64 ntfs_read_clusters(const ntfs_volume *vol, const __s64 lcn, __s64 count,
+		void *b)
 {
-	__s64 br, btr, total;
-	char bksize_bits;
+	__s64 br;
 	
-	/* Nothing to read so, return 0. */
-	if (!count || !bksize)
-		return 0;
-	/* Calculate bksize_bits. */
-	for (bksize_bits = 0, br = bksize; br > 1; br >>= 1)
-		++bksize_bits;
-	/* Check buffer. Only multiples of NTFS_SECTOR_SIZE and powers of
-	   two are alowed for bksize. */
-	if (!b || (bksize_bits < NTFS_SECTOR_SIZE_BITS) ||
-		       			(bksize != 1 << bksize_bits)) {
-#ifdef DEBUG
-		if (!b)
-			puts("ntfs_pread: b is NULL");
-		if (bksize_bits < NTFS_SECTOR_SIZE_BITS)
-			puts("ntfs_pread: bksize_bits < NTFS_SECTOR_SIZE_BITS");
-		if (bksize != 1 << bksize_bits)
-			puts("ntfs_pread: bksize != 1 << bksize_bits");
-		puts("Returning EINVAL");
-#endif
+	if (!vol || !b || count < 0 || lcn < 0) {
 		errno = EINVAL;
 		return -1;
 	}
-	/* Locate to position. */
-	if (lseek(fd, pos, SEEK_SET) == (off_t)-1) {
-#ifdef DEBUG
-		int eo = errno;
-		printf("ntfs_pread: lseek to 0x%Lx returned -1\n", pos);
-		errno = eo;
-#endif
+	if (!vol->fd) {
+		errno = EBADF;
 		return -1;
 	}
-	/* Read the data. */
-	total = 0;
-	btr = count << bksize_bits;
-	/* Loop until we have read all data even if it happens only a byte at
-	   a time. */
-	do {
-		br = read(fd, ((char *)b) + total, btr);
-		if (br == -1)
-			return br;
-		if (!br) {
-			/* Calculate the number of complete blocks read
-			   (and recycle count as a local variable). */
-			count -= btr >> bksize_bits;
-			break;
-		}
-		btr -= br;
-		total += br;
-	} while (btr);
-	/* Finally, return the number of blocks read. */
-	return count;
-}
-
-__s64 mst_pread(const int fd, void *b, const __u32 bksize, __s64 count,
-		       const __s64 pos)
-{
-	__s64 br, i;
-	char bksize_bits;
-	
-	/* Do the read. */
-	count = ntfs_pread(fd, b, bksize, count, pos);
-	/* Calculate bksize_bits. */
-	for (bksize_bits = 0, br = bksize; br > 1; br >>= 1)
-		++bksize_bits;
-	/* Apply fixups to successfully read data. Note, that we disregard
-	   any errors returned from the MST fixup function. This is because we
-	   want to fixup everything possible and we rely on the fact that the
-	   "BAAD" magic will be detected later on anyway (before the data is
-	   made use of). */
-	for (i = 0; i < count; ++i)
-		post_read_mst_fixup((NTFS_RECORD*)(b + 
-						(i << bksize_bits)), bksize);
-	/* Finally, return the number of blocks read. */
-	return count;
-}
-
-int get_clusters(const ntfs_volume *vol, __u8 *buf, const __s64 lcn,
-		 const int count)
-{
-	__s64 br;
-	
-	if (!vol || !buf || count < 0 || lcn < 0)
-		return -EINVAL;
-	if (!vol->fd)
-		return -EBADF;
-	if (vol->number_of_clusters < lcn + count)
-		return -ESPIPE;
-	br = ntfs_pread(vol->fd, buf, vol->cluster_size, count, 
-						lcn << vol->cluster_size_bits);
-	if (br != count) {
-		int eo = errno;
-#define ESTR "Error reading cluster(s)"
-                if (br == -1) {
-                        perror(ESTR);
-			return -eo;
-		} else if (!br)
-                        fprintf(stderr, "Error: partition is smaller than "
-                                        "it should be!?! Weird!\n");
-		else
-                        fprintf(stderr, ESTR ": unknown error\n");
-#undef ESTR
-		return -EIO;
-	}
-	return br;
-}
-
-int put_clusters(ntfs_volume *vol, const __u8 *buf, const __s64 lcn, int count)
-{
-	__s64 bw;
-	
-	if (!vol || !buf || count < 0 || lcn < 0)
-		return -EINVAL;
-	if (!vol->fd)
-		return -EBADF;
-	if (vol->number_of_clusters < lcn + count)
-		return -ESPIPE;
-	bw = ntfs_pwrite(vol->fd, buf, count << vol->cluster_size_bits, 
-						lcn << vol->cluster_size_bits);
-	if (bw != count << vol->cluster_size_bits) {
-		int eo = errno;
-#define ESTR "Error writting cluster(s)"
-                if (bw == -1) {
-                        perror(ESTR);
-			return -eo;
-		} else if (!bw)
-                        fprintf(stderr, ESTR ": Ran out of input data!\n");
-		else
-                        fprintf(stderr, ESTR ": unknown error\n");
-#undef ESTR
-		return -EIO;
+	if (vol->number_of_clusters < lcn + count) {
+		errno = ESPIPE;
+		return -1;
 	}
-	return bw >> vol->cluster_size_bits;
-}
-
-/**
- * get_mft_records - read records from the mft from disk
- * @vol:	volume to read from
- * @mrec:	output data buffer
- * @mref:	starting mft record number
- * @count:	number of mft records to read
- *
- * Read @count mft records starting at @mref from volume @vol into buffer
- * @mrec. Return @count on success or -ERRNO on error, where ERRNO is the error
- * code. This function will do the error reporting so caller really only needs
- * to check for sucess / failure.
- *
- * NOTE: @mrec has to be at least of size @count * vol->mft_record_size.
- */
-int get_mft_records(const ntfs_volume *vol, const MFT_RECORD *mrec,
-		    const MFT_REF *mref, const int count)
-{
-	__s64 br, ofs;
-	LCN lcn;
-	VCN m;
-	
-	if (!vol || !mrec)
-		return -EINVAL;
-	if (!vol->fd)
-		return -EBADF;
-	m = MREF(*mref);
-	if (vol->number_of_mft_records < m + count)
-		return -ESPIPE;
-	if (!ntfs_get_bit(vol->mft_bitmap, m))
-		return -ENOENT;
-	lcn = vcn_to_lcn(vol->mft_runlist, m << vol->mft_record_size_bits >>
-						vol->cluster_size_bits);
-	if (lcn == -1) {
-		perror("Error sparse $Mft records are not supported");
-		return -ENOTSUP;
-	}
-	ofs = m << vol->mft_record_size_bits & vol->cluster_size - 1;
-	br = mst_pread(vol->fd, (__u8*)mrec, vol->mft_record_size, count, 
-					(lcn << vol->cluster_size_bits) + ofs);
+	count <<= vol->cluster_size_bits;
+	br = ntfs_pread(vol->fd, lcn << vol->cluster_size_bits, count, b);
 	if (br != count) {
-		int eo = errno;
-#define ESTR "Error reading $Mft record"
-                if (br == -1) {
-                        perror(ESTR);
-			return -eo;
-		} else if (!br)
-                        fprintf(stderr, "Error: partition is smaller than "
-                                        "it should be!?! Weird!\n");
+		if (br != -1)
+			errno = EIO;
+		if (!br)
+			Dputs("Error: partition is smaller than it should be!");
 		else
-                        fprintf(stderr, ESTR ": unknown error\n");
-#undef ESTR
-		return -EIO;
+			Dperror("Error reading cluster(s)");
+		return -1;
 	}
-	return br;
-}
-
-/**
- * get_mft_record - read a record from the mft
- * @vol:	volume to read from
- * @mrec:	output data buffer
- * @mref:	starting mft record number
- * @count:	number of mft records to read
- *
- * Read mft record specified by @mref from volume @vol into buffer @mrec.
- * Return 1 on success or -ERRNO on error, where ERRNO is the error
- * code. This function will do the error reporting so caller really only needs
- * to check for sucess / failure.
- *
- * NOTE: @mrec has to be at least of size vol->mft_record_size.
- */
-__inline__ int get_mft_record(const ntfs_volume *vol, const MFT_RECORD *mrec,
-			      const MFT_REF *mref)
-{
-	return get_mft_records(vol, mrec, mref, 1);
+	return br >> vol->cluster_size_bits;
 }
 
 /**
- * __read_file_record - read a FILE record from the mft from disk
- * @vol:	volume to read from
- * @mref:	mft reference specifying mft record to read
- * @mrec:	address of pointer in which to return the mft record
- * @attr:	address of pointer in which to return the first attribute
- * 
- * Read a FILE record from the mft of @vol from the storage medium. @mref
- * specifies the mft record to read, including the sequence number. When the
- * function returns, @mrec and @attr will contain pointers to the read mft
- * record and to the first attribute within the mft record, respectively.
- * @attr is optional (can be NULL).
+ * ntfs_write_clusters - write ntfs clusters
+ * @vol:	volume to write to
+ * @lcn:	starting logical cluster number
+ * @count:	number of clusters to write
+ * @b:		data buffer to write to disk
  *
- * The read mft record is checked for having the magic FILE, for being in use,
- * and for having a matching sequence number (if MSEQNO(*@mref) != 0).
- * If either of these fails, return -EIO.
- * 
- * Return 0 on success, or -ERRNO on error, where ERRNO is the error code.
- * 
- * Note: Caller has to free *@mrec when finished.
+ * Write @count ntfs clusters starting at logical cluster number @lcn from
+ * buffer @b to volume @vol. Return the nu,ber of clusters written or -1 on
+ * error, with errno set to the error code.
  */
-int __read_file_record(const ntfs_volume *vol, const MFT_REF *mref,
-			MFT_RECORD **mrec, ATTR_RECORD **attr)
+__s64 ntfs_write_clusters(ntfs_volume *vol, const __s64 lcn, __s64 count,
+		const void *b)
 {
-	MFT_RECORD *m;
-	ATTR_RECORD *a;
-	int er = 0;
-	
-	if (!vol || !mrec) {
-#ifdef DEBUG
-		fprintf(stderr, "read_file_record() received NULL pointer!\n");
-#endif
-		return -EINVAL;
-	}
-	if (!(m = malloc(vol->mft_record_size)))
-		return -ENOMEM;
-	if ((er = get_mft_record(vol, m, mref)) != 1)
-		goto failed;
-	if (!is_file_record(m->magic))
-		goto file_corrupt;
-	if (MSEQNO(*mref) && MSEQNO(*mref) != le16_to_cpu(m->sequence_number))
-		goto file_corrupt;
-	if (!(m->flags & MFT_RECORD_IN_USE))
-		goto file_corrupt;
-	a = (ATTR_RECORD*)((char*)m + le16_to_cpu(m->attrs_offset));
-	if (p2n(a) < p2n(m) || (char*)a > (char*)m + vol->mft_record_size)
-		goto file_corrupt;
-	*mrec = m;
-	if (attr)
-		*attr = a;
-	return 0;
-file_corrupt:
-#ifdef DEBUG
-	fprintf(stderr, "read_file_record(): file is corrupt.\n");
-#endif
-	er = -EIO;
-failed:
-	free(m);
-	return er < 0 ? er : -EINVAL;
-}
-
-/**
- * read_file_record - read a FILE record from the mft from @vol
- * @vol:	volume to read from
- * @mref:	mft reference specifying mft record to read
- * @mrec:	address of pointer in which to return the mft record
- * @attr:	address of pointer in which to return the first attribute
- * 
- * Return the FILE record @mref from the mft of @vol. @mref, the mft record to
- * return, includes the sequence number, which can be 0 if no sequence number
- * checking is to be performed. If the mft record is already loaded in the
- * volume's mft cache this is returned straight away. Otherwise a new mft entry
- * is allocated and inserted into the cache and the mft record is within the
- * entry is returned. When the function returns, @mrec and @attr will contain
- * pointers to the mft record and to the first attribute within the mft record,
- * respectively. @attr is optional (can be NULL).
- *
- * The mft record is checked for having the magic FILE, for being in use,
- * and for having a matching sequence number (if MSEQNO(*@mref) != 0).
- * If either of these fails, return -EIO.
- * 
- * Return 0 on success, or -ERRNO on error, where ERRNO is the error code.
- * 
- * Note: Caller has to free *@mrec when finished.
- */
-int read_file_record(const ntfs_volume *vol, const MFT_REF *mref,
-		     MFT_RECORD **mrec, ATTR_RECORD **attr)
-{
-	return -ENOTSUP;
-}
+	__s64 bw;
 
-int put_mft_record(ntfs_volume *vol, const __u8 *buf, const MFT_REF *mref)
-{
-	__s64 bw, m;
-	__s64 lcn, ofs;
-	
-	if (!vol || !buf)
-		return -EINVAL;
-	if (!vol->fd)
-		return -EBADF;
-	m = MREF(*mref);
-	if (vol->number_of_mft_records <= m)
-		return -ESPIPE;
-	if (!ntfs_get_bit(vol->mft_bitmap, m))
-		return -ENOENT;
-	lcn = vcn_to_lcn(vol->mft_runlist, m << vol->mft_record_size_bits >>
-						vol->cluster_size_bits);
-	if (lcn == -1) {
-		perror("Error sparse $Mft records are not supported");
-		return -ENOTSUP;
-	}
-	ofs = m << vol->mft_record_size_bits & vol->cluster_size - 1;
-	if (lcn == -1) {
-		int eo = errno;
-		perror("Error determining on disk location of $Mft record");
-		return -eo;
-	}
-	bw = mst_pwrite(vol->fd, buf, vol->mft_record_size, 
-					(lcn << vol->cluster_size_bits) + ofs);
-	if (bw != vol->mft_record_size) {
-		int eo = errno;
-#define ESTR "Error writing $Mft record"
-                if (bw == -1) {
-                        perror(ESTR);
-			return -eo;
-		} else if (!bw)
-                        fprintf(stderr, ESTR ": Ran out of input data!\n");
+	if (!vol || !b || count < 0 || lcn < 0) {
+		errno = EINVAL;
+		return -1;
+	}
+	if (!vol->fd) {
+		errno = EBADF;
+		return -1;
+	}
+	if (vol->number_of_clusters < lcn + count) {
+		errno = ESPIPE;
+		return -1;
+	}
+	count <<= vol->cluster_size_bits;
+	bw = ntfs_pwrite(vol->fd, lcn << vol->cluster_size_bits, count, b);
+	if (bw != count) {
+		if (bw != -1)
+			errno = EIO;
+		if (!bw)
+			Dputs("Ran out of input data while writing clusters!");
 		else
-                        fprintf(stderr, ESTR ": unknown error\n");
-#undef ESTR
-		return -EIO;
+			Dperror("Error writing cluster(s)");
+		return -1;
 	}
-	return 1;
+	return bw >> vol->cluster_size_bits;
 }
 

Index: mft.c
===================================================================
RCS file: /cvsroot/linux-ntfs/linux-ntfs/libntfs/mft.c,v
retrieving revision 1.13
retrieving revision 1.14
diff -U2 -r1.13 -r1.14
--- mft.c	14 Apr 2002 14:08:30 -0000	1.13
+++ mft.c	15 Apr 2002 00:42:07 -0000	1.14
@@ -23,3 +23,227 @@
 
 #include "mft.h"
+#include "disk_io.h"
+#include "bitmap.h"
+
+/**
+ * get_mft_records - read records from the mft from disk
+ * @vol:	volume to read from
+ * @mrec:	output data buffer
+ * @mref:	starting mft record number
+ * @count:	number of mft records to read
+ *
+ * Read @count mft records starting at @mref from volume @vol into buffer
+ * @mrec. Return @count on success or -ERRNO on error, where ERRNO is the error
+ * code. This function will do the error reporting so caller really only needs
+ * to check for sucess / failure.
+ *
+ * NOTE: @mrec has to be at least of size @count * vol->mft_record_size.
+ */
+int get_mft_records(const ntfs_volume *vol, const MFT_RECORD *mrec,
+		    const MFT_REF *mref, const int count)
+{
+	__s64 br, ofs;
+	LCN lcn;
+	VCN m;
+	
+	if (!vol || !mrec)
+		return -EINVAL;
+	if (!vol->fd)
+		return -EBADF;
+	m = MREF(*mref);
+	if (vol->number_of_mft_records < m + count)
+		return -ESPIPE;
+	if (!ntfs_get_bit(vol->mft_bitmap, m))
+		return -ENOENT;
+	lcn = vcn_to_lcn(vol->mft_runlist, m << vol->mft_record_size_bits >>
+						vol->cluster_size_bits);
+	if (lcn == -1) {
+		perror("Error sparse $Mft records are not supported");
+		return -ENOTSUP;
+	}
+	ofs = m << vol->mft_record_size_bits & vol->cluster_size - 1;
+	br = mst_pread(vol->fd, (__u8*)mrec, vol->mft_record_size, count, 
+					(lcn << vol->cluster_size_bits) + ofs);
+	if (br != count) {
+		int eo = errno;
+#define ESTR "Error reading $Mft record"
+                if (br == -1) {
+                        perror(ESTR);
+			return -eo;
+		} else if (!br)
+                        fprintf(stderr, "Error: partition is smaller than "
+                                        "it should be!?! Weird!\n");
+		else
+                        fprintf(stderr, ESTR ": unknown error\n");
+#undef ESTR
+		return -EIO;
+	}
+	return br;
+}
+
+/**
+ * get_mft_record - read a record from the mft
+ * @vol:	volume to read from
+ * @mrec:	output data buffer
+ * @mref:	starting mft record number
+ * @count:	number of mft records to read
+ *
+ * Read mft record specified by @mref from volume @vol into buffer @mrec.
+ * Return 1 on success or -ERRNO on error, where ERRNO is the error
+ * code. This function will do the error reporting so caller really only needs
+ * to check for sucess / failure.
+ *
+ * NOTE: @mrec has to be at least of size vol->mft_record_size.
+ */
+__inline__ int get_mft_record(const ntfs_volume *vol, const MFT_RECORD *mrec,
+			      const MFT_REF *mref)
+{
+	return get_mft_records(vol, mrec, mref, 1);
+}
+
+/**
+ * __read_file_record - read a FILE record from the mft from disk
+ * @vol:	volume to read from
+ * @mref:	mft reference specifying mft record to read
+ * @mrec:	address of pointer in which to return the mft record
+ * @attr:	address of pointer in which to return the first attribute
+ * 
+ * Read a FILE record from the mft of @vol from the storage medium. @mref
+ * specifies the mft record to read, including the sequence number. When the
+ * function returns, @mrec and @attr will contain pointers to the read mft
+ * record and to the first attribute within the mft record, respectively.
+ * @attr is optional (can be NULL).
+ *
+ * The read mft record is checked for having the magic FILE, for being in use,
+ * and for having a matching sequence number (if MSEQNO(*@mref) != 0).
+ * If either of these fails, return -EIO.
+ * 
+ * Return 0 on success, or -ERRNO on error, where ERRNO is the error code.
+ * 
+ * Note: Caller has to free *@mrec when finished.
+ */
+int __read_file_record(const ntfs_volume *vol, const MFT_REF *mref,
+			MFT_RECORD **mrec, ATTR_RECORD **attr)
+{
+	MFT_RECORD *m;
+	ATTR_RECORD *a;
+	int er = 0;
+	
+	if (!vol || !mrec) {
+#ifdef DEBUG
+		fprintf(stderr, "read_file_record() received NULL pointer!\n");
+#endif
+		return -EINVAL;
+	}
+	if (!(m = malloc(vol->mft_record_size)))
+		return -ENOMEM;
+	if ((er = get_mft_record(vol, m, mref)) != 1)
+		goto failed;
+	if (!is_file_record(m->magic))
+		goto file_corrupt;
+	if (MSEQNO(*mref) && MSEQNO(*mref) != le16_to_cpu(m->sequence_number))
+		goto file_corrupt;
+	if (!(m->flags & MFT_RECORD_IN_USE))
+		goto file_corrupt;
+	a = (ATTR_RECORD*)((char*)m + le16_to_cpu(m->attrs_offset));
+	if (p2n(a) < p2n(m) || (char*)a > (char*)m + vol->mft_record_size)
+		goto file_corrupt;
+	*mrec = m;
+	if (attr)
+		*attr = a;
+	return 0;
+file_corrupt:
+#ifdef DEBUG
+	fprintf(stderr, "read_file_record(): file is corrupt.\n");
+#endif
+	er = -EIO;
+failed:
+	free(m);
+	return er < 0 ? er : -EINVAL;
+}
+
+/**
+ * read_file_record - read a FILE record from the mft from @vol
+ * @vol:	volume to read from
+ * @mref:	mft reference specifying mft record to read
+ * @mrec:	address of pointer in which to return the mft record
+ * @attr:	address of pointer in which to return the first attribute
+ * 
+ * Return the FILE record @mref from the mft of @vol. @mref, the mft record to
+ * return, includes the sequence number, which can be 0 if no sequence number
+ * checking is to be performed. If the mft record is already loaded in the
+ * volume's mft cache this is returned straight away. Otherwise a new mft entry
+ * is allocated and inserted into the cache and the mft record is within the
+ * entry is returned. When the function returns, @mrec and @attr will contain
+ * pointers to the mft record and to the first attribute within the mft record,
+ * respectively. @attr is optional (can be NULL).
+ *
+ * The mft record is checked for having the magic FILE, for being in use,
+ * and for having a matching sequence number (if MSEQNO(*@mref) != 0).
+ * If either of these fails, return -EIO.
+ * 
+ * Return 0 on success, or -ERRNO on error, where ERRNO is the error code.
+ * 
+ * Note: Caller has to free *@mrec when finished.
+ */
+int read_file_record(const ntfs_volume *vol, const MFT_REF *mref,
+		     MFT_RECORD **mrec, ATTR_RECORD **attr)
+{
+	return -ENOTSUP;
+}
+
+/**
+ * put_mft_record - write a record to the mft
+ * @vol:	volume to write to
+ * @buf:	data buffer containing the mft record to write
+ * @mref:	mft record number to write to
+ *
+ * Write mft record @mref from buffer @buf to volume @vol. Return 1 on
+ * success or -ERRNO on error, where ERRNO is the error code. This function
+ * will do the error reporting so caller really only needs to check for sucess
+ * / failure.
+ */
+int put_mft_record(ntfs_volume *vol, const __u8 *buf, const MFT_REF *mref)
+{
+	__s64 bw, m;
+	__s64 lcn, ofs;
+	
+	if (!vol || !buf)
+		return -EINVAL;
+	if (!vol->fd)
+		return -EBADF;
+	m = MREF(*mref);
+	if (vol->number_of_mft_records <= m)
+		return -ESPIPE;
+	if (!ntfs_get_bit(vol->mft_bitmap, m))
+		return -ENOENT;
+	lcn = vcn_to_lcn(vol->mft_runlist, m << vol->mft_record_size_bits >>
+						vol->cluster_size_bits);
+	if (lcn == -1) {
+		perror("Error sparse $Mft records are not supported");
+		return -ENOTSUP;
+	}
+	ofs = m << vol->mft_record_size_bits & vol->cluster_size - 1;
+	if (lcn == -1) {
+		int eo = errno;
+		perror("Error determining on disk location of $Mft record");
+		return -eo;
+	}
+	bw = mst_pwrite(vol->fd, buf, vol->mft_record_size, 
+					(lcn << vol->cluster_size_bits) + ofs);
+	if (bw != vol->mft_record_size) {
+		int eo = errno;
+#define ESTR "Error writing $Mft record"
+                if (bw == -1) {
+                        perror(ESTR);
+			return -eo;
+		} else if (!bw)
+                        fprintf(stderr, ESTR ": Ran out of input data!\n");
+		else
+                        fprintf(stderr, ESTR ": unknown error\n");
+#undef ESTR
+		return -EIO;
+	}
+	return 1;
+}
 

Index: volume.c
===================================================================
RCS file: /cvsroot/linux-ntfs/linux-ntfs/libntfs/volume.c,v
retrieving revision 1.21
retrieving revision 1.22
diff -U2 -r1.21 -r1.22
--- volume.c	14 Apr 2002 14:08:30 -0000	1.21
+++ volume.c	15 Apr 2002 00:42:08 -0000	1.22
@@ -137,5 +137,5 @@
 	}
 	/* Now read the bootsector. */
-	br = ntfs_pread(vol->fd, bs, sizeof(NTFS_BOOT_SECTOR), 1, 0);
+	br = ntfs_pread(vol->fd, bs, sizeof(NTFS_BOOT_SECTOR), 0);
 	if (br != 1) {
 		Dputs(FAILED);

[Linux-NTFS-cvs] CVS: dynamic-disk/linux/fs/partitions ldm.c,1.69,1.70 ldm.h,1.42,1.43

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

Changes by: flatcap

Update of /cvsroot/linux-ntfs/dynamic-disk/linux/fs/partitions
In directory usw-pr-cvs1:/tmp/cvs-serv23349/linux/fs/partitions

Modified Files:
	ldm.c ldm.h 
Log Message:
more shufflings about.  more fixmes.  nothing significant.


Index: ldm.c
===================================================================
RCS file: /cvsroot/linux-ntfs/dynamic-disk/linux/fs/partitions/ldm.c,v
retrieving revision 1.69
retrieving revision 1.70
diff -U2 -r1.69 -r1.70
--- ldm.c	11 Apr 2002 14:27:39 -0000	1.69
+++ ldm.c	15 Apr 2002 00:14:20 -0000	1.70
@@ -1,4 +1,4 @@
 /**
- * ldm - Support for Windows' Logical Disk Manager (Dynamic Disks)
+ * ldm - Support for Windows Logical Disk Manager (Dynamic Disks)
  *
  * Copyright (C) 2001,2002 Richard Russon <ld...@fl...>
@@ -152,5 +152,5 @@
 	return TRUE;
 }
-// FIXME: Why doesn't this work ??
+
 
 /**
@@ -175,7 +175,12 @@
 	}
 
-	ph->ver_major = BE16 (data + 0x000C);
-	ph->ver_minor = BE16 (data + 0x000E);
-	// FIXME move checks to validate_*, maybe later coalesce?
+	ph->ver_major          = BE16 (data + 0x000C);
+	ph->ver_minor          = BE16 (data + 0x000E);
+	ph->logical_disk_start = BE64 (data + 0x011B);
+	ph->logical_disk_size  = BE64 (data + 0x0123);
+	ph->config_start       = BE64 (data + 0x012B);
+	ph->config_size        = BE64 (data + 0x0133);
+
+	// FIXME move checks to validate_*?
 	if ((ph->ver_major != 2) || (ph->ver_minor != 11)) {
 		ldm_error ("Expected PRIVHEAD version %d.%d, got %d.%d."
@@ -183,6 +188,4 @@
 		return FALSE;
 	}
-	ph->config_start = BE64 (data + 0x012B);
-	ph->config_size  = BE64 (data + 0x0133);
 	if (ph->config_size != LDM_DB_SIZE) {	/* 1 MiB in sectors. */
 		/* Warn the user and continue, carefully */
@@ -191,6 +194,4 @@
 			(unsigned long long)ph->config_size );
 	}
-	ph->logical_disk_start = BE64 (data + 0x011B);
-	ph->logical_disk_size  = BE64 (data + 0x0123);
 	if ((ph->logical_disk_size == 0) ||
 	    (ph->logical_disk_start + ph->logical_disk_size > ph->config_start)) {
@@ -200,5 +201,5 @@
 
 	if (!ldm_parse_guid (data + 0x0030, ph->disk_id)) {
-		ldm_error ("PRIVHEAD contains an invalid GUID.");
+		ldm_error ("PRIVHEAD contains an invalid GUID."); // FIXME too specific?
 		return FALSE;
 	}
@@ -295,5 +296,4 @@
 }
 
-
 /**
  * ldm_compare_privheads - Compare two privhead objects
@@ -345,58 +345,4 @@
 }
 
-
-/**
- * ldm_validate_partition_table - Determine whether bdev might be a dynamic disk
- * @bdev:  Device to test
- *
- * This function provides a weak test to decide whether the device is a dynamic
- * disk or not.  It looks for an MS-DOS-style partition table containing at
- * least one partition of type 0x42 (formerly SFS, now used by Windows for
- * dynamic disks).
- *
- * N.B.  The only possible error can come from the read_dev_sector and that is
- *       only likely to happen if the underlying device is strange.  If that IS
- *       the case we should return zero to let someone else try.
- *
- * Return: TRUE   @bdev is a dynamic disk
- *         FALSE  @bdev is not a dynamic disk, or an error occurred
- */
-static BOOL ldm_validate_partition_table (struct block_device *bdev)
-{
-	Sector sect;
-	u8 *data;
-	struct partition *p;
-	int i;
-	BOOL result = FALSE;
-
-	DEBUG_ON (!bdev);
-
-	data = read_dev_sector (bdev, 0, &sect);
-	if (!data) {
-		ldm_crit ("Disk read failed.");
-		return FALSE;
-	}
-
-	if (*(u16*) (data + 0x01FE) != cpu_to_le16 (MSDOS_LABEL_MAGIC)) {
-		ldm_debug ("No MS-DOS partition table found.");
-		goto out;
-	}
-
-	p = (struct partition*)(data + 0x01BE);
-	for (i = 0; i < 4; i++, p++)
-		if (SYS_IND(p) == WIN2K_DYNAMIC_PARTITION) {
-			result = TRUE;
-			break;
-		}
-
-	if (result)
-		ldm_debug ("Parsed partition table successfully.");
-	else
-		ldm_debug ("Found an MS-DOS partition table, not a dynamic disk.");
-out:
-	put_dev_sector(sect);
-	return result;
-}
-
 /**
  * ldm_validate_privheads - Compare the primary privhead with its backups
@@ -445,8 +391,9 @@
 		put_dev_sector (sect);
 		if (!result) {
-			//if (i < 2)
+			// FIXME it IS already logged, but we don't know _which_ privhead failed
+			if (i < 2)
 				goto out;	/* Already logged */
-			//else
-				//ldm_info ("Ignoring error");
+			else
+				break;	// FIXME ignore for now
 		}
 	}
@@ -469,7 +416,7 @@
 	if (!ldm_compare_privheads (ph[0], ph[1]) ||
 	    !ldm_compare_privheads (ph[0], ph[2])) {
-		ldm_crit ("Primary and backup PRIVHEADs don't match.");
-		goto out;
+		//ldm_crit ("Primary and backup PRIVHEADs don't match.");
 		// FIXME ignore this too?
+		//goto out;
 	}
 
@@ -511,5 +458,5 @@
 	ph    = &ldb->ph;
 	tb[0] = &ldb->toc;
-	tb[1] = kmalloc (sizeof (*tb[1]), GFP_KERNEL); // FIXME coalesce?
+	tb[1] = kmalloc (sizeof (*tb[1]), GFP_KERNEL); // FIXME coalesce? - maybe not, but do we really need four, why not two?
 	tb[2] = kmalloc (sizeof (*tb[2]), GFP_KERNEL);
 	tb[3] = kmalloc (sizeof (*tb[3]), GFP_KERNEL);
@@ -611,4 +558,58 @@
 }
 
+
+/**
+ * ldm_validate_partition_table - Determine whether bdev might be a dynamic disk
+ * @bdev:  Device to test
+ *
+ * This function provides a weak test to decide whether the device is a dynamic
+ * disk or not.  It looks for an MS-DOS-style partition table containing at
+ * least one partition of type 0x42 (formerly SFS, now used by Windows for
+ * dynamic disks).
+ *
+ * N.B.  The only possible error can come from the read_dev_sector and that is
+ *       only likely to happen if the underlying device is strange.  If that IS
+ *       the case we should return zero to let someone else try.
+ *
+ * Return: TRUE   @bdev is a dynamic disk
+ *         FALSE  @bdev is not a dynamic disk, or an error occurred
+ */
+static BOOL ldm_validate_partition_table (struct block_device *bdev)
+{
+	Sector sect;
+	u8 *data;
+	struct partition *p;
+	int i;
+	BOOL result = FALSE;
+
+	DEBUG_ON (!bdev);
+
+	data = read_dev_sector (bdev, 0, &sect);
+	if (!data) {
+		ldm_crit ("Disk read failed.");
+		return FALSE;
+	}
+
+	if (*(u16*) (data + 0x01FE) != cpu_to_le16 (MSDOS_LABEL_MAGIC)) {
+		ldm_debug ("No MS-DOS partition table found.");
+		goto out;
+	}
+
+	p = (struct partition*)(data + 0x01BE);
+	for (i = 0; i < 4; i++, p++)
+		if (SYS_IND(p) == WIN2K_DYNAMIC_PARTITION) {
+			result = TRUE;
+			break;
+		}
+
+	if (result)
+		ldm_debug ("Parsed partition table successfully.");
+	else
+		ldm_debug ("Found an MS-DOS partition table, not a dynamic disk.");
+out:
+	put_dev_sector(sect);
+	return result;
+}
+
 /**
  * ldm_find_vblk - Search a linked list of VBLKs for a given object id
@@ -638,4 +639,30 @@
 
 /**
+ * ldm_get_disk_objid - Search a linked list of vblk's for a given Disk Id
+ * @ldb:  ldmdb struct
+ *
+ * The LDM Database contains a list of all partitions on all dynamic disks.  The
+ * primary PRIVHEAD, at the beginning of the physical disk, tells us the GUID of
+ * this disk.  This function searches for the GUID in a linked list of vblk's.
+ *
+ * Return: Pointer, A matching vblk was found
+ *         NULL,    No match, or an error
+ */
+static struct vblk * ldm_get_disk_objid (const struct ldmdb *ldb)
+{
+	list_t *item;
+
+	DEBUG_ON (!ldb);
+
+	list_for_each (item, &ldb->v_disk) {
+		struct vblk *v = list_entry (item, struct vblk, list);
+		if (!memcmp(v->vblk.disk.disk_id, ldb->ph.disk_id, GUID_SIZE))
+			return v;
+	}
+
+	return NULL;
+}
+
+/**
  * ldm_create_partition - Create a kernel partition device
  * @hd:     gendisk structure in which to create partition
@@ -692,9 +719,10 @@
 static BOOL ldm_create_data_partitions (struct gendisk *hd,
 	unsigned long first_sector, int first_minor,
-	const struct ldmdb *ldb, const struct vblk *disk)
+	const struct ldmdb *ldb)
 {
 	// FIXME THIS FUNCTION CANNOT FAIL!
 	list_t *item;
 	struct vblk_part *part;
+	struct vblk *disk;
 	int disk_minor;
 	int minor;
@@ -702,4 +730,10 @@
 	DEBUG_ON (!hd || !ldb || !disk);
 
+	disk = ldm_get_disk_objid (ldb);
+	if (!disk) {
+		ldm_crit ("can't find this disk"); //FIXME
+		return FALSE;
+	}
+
 	/**
 	 * Get the minor number of the parent device so we can check we don't
@@ -729,10 +763,10 @@
 		/* Try to get parent component */
 		c = ldm_find_vblk(&ldb->v_comp, part->parent_id);
-		if (c == NULL)
+		if (c == NULL)	// FIXME logging
 			continue;
 
 		/* Try to get parent volume */
 		v = ldm_find_vblk(&ldb->v_volu, c->vblk.comp.parent_id);
-		if (v == NULL)
+		if (v == NULL)	// FIXME logging
 			continue;
 
@@ -912,12 +946,11 @@
 	ldm_get_vstr (buffer + 0x18 + r_name, comp->state,
 		sizeof (comp->state));
-	comp->type  = buffer[0x18 + r_vstate];
-	comp->n_childs = ldm_get_vnum (buffer + 0x1D + r_vstate);
+	comp->type      = buffer[0x18 + r_vstate];
+	comp->children  = ldm_get_vnum (buffer + 0x1D + r_vstate);
 	comp->parent_id = ldm_get_vnum (buffer + 0x2D + r_child);
 
-	comp->chunksize = (r_stripe)
-		? ldm_get_vnum (buffer + 0x2E + r_parent)
-		: 0;
-
+#ifdef CONFIG_BLK_DEV_MD
+	comp->chunksize = (r_stripe) ? ldm_get_vnum (buffer+0x2E+r_parent) : 0;
+#endif
 	return TRUE;
 }
@@ -1045,5 +1078,5 @@
 		sizeof (disk->alt_name));
 	if (!ldm_parse_guid (buffer + 0x19 + r_name, disk->disk_id)) {
-		ldm_error ("VBLK DISK contains an invalid GUID.");
+		ldm_error ("VBLK DSK3 contains an invalid GUID."); // FIXME do we want to be specific?
 		return FALSE;
 	}
@@ -1070,7 +1103,7 @@
 	DEBUG_ON (!buffer || !vb);
 
-	r_objid  = ldm_relative (buffer, buflen, 0x18, 0);
-	r_name   = ldm_relative (buffer, buflen, 0x18, r_objid);
-	len = r_name;
+	r_objid = ldm_relative (buffer, buflen, 0x18, 0);
+	r_name  = ldm_relative (buffer, buflen, 0x18, r_objid);
+	len     = r_name;
 	if (len < 0)
 		return FALSE;
@@ -1206,69 +1239,43 @@
 
 /**
- * ldm_parse_vblk_head - Read a raw VBLK header into a vblk_head structure
- * @src:   The block of data being worked on
- * @vbh:   In-memory vblk_head in which to return information
- *
- * This function just reads the information necessary for to identify
- * multipart VBLKS.
- *
- * Return: TRUE
- *         FALSE
- */
-static BOOL ldm_parse_vblk_head (const u8 *src, struct vblk_head *vbh)
-{
-	DEBUG_ON (!src || !vbh);
-
-	if (MAGIC_VBLK != BE32 (src))
-		return FALSE;
-
-	vbh->group = BE32 (src + 0x08);
-	vbh->rec   = BE16 (src + 0x0C);
-	vbh->nrec  = BE16 (src + 0x0E);
-
-	return TRUE;
-}
-
-/**
  * ldm_parse_vblk - Read a raw VBLK object into a vblk structure
- * @src:  The block of data being worked on
- * @size: The size of the block of data
+ * @buf:  The block of data being worked on
+ * @len:  The size of the block of data
  * @vb:   In-memory vblk in which to return information
  *
  * Read a raw VBLK object into a vblk structure.  This function just reads the
  * information common to all VBLK types, then delegates the rest of the work to
- * help functions: ldm_parse_*.
+ * helper functions: ldm_parse_*.
  *
  * Return: TRUE   @vb contains a VBLK
  *         FALSE  @vb contents are not defined
  */
-static BOOL ldm_parse_vblk (const u8 *src, int size, struct vblk *vb)
+static BOOL ldm_parse_vblk (const u8 *buf, int len, struct vblk *vb)
 {
-	// FIXME: this is ugly.
-	/* Compensate for vblk_head. */
-	const u8 *buffer = src - VBLK_SIZE_HEAD;
-	const int buflen = size + VBLK_SIZE_HEAD;
 	BOOL result = FALSE;
 
-	DEBUG_ON (!src || !vb);
+	DEBUG_ON (!buf || !vb);
+
+	buf -= VBLK_SIZE_HEAD;		/* Skip the header FIXME WHAT? */
+	len += VBLK_SIZE_HEAD;
 
-	if (ldm_out_of_range (buffer, buflen, 0x18)) {
+	if (ldm_out_of_range (buf, len, 0x18)) {
 		// FIXME logging
 		return FALSE;
 	}
 
-	vb->flags  = buffer[0x12];
-	vb->type   = buffer[0x13];
-	vb->obj_id = ldm_get_vnum (buffer + 0x18);
-	ldm_get_vstr (buffer+0x19+buffer[0x18], vb->name, sizeof (vb->name));
+	vb->flags  = buf[0x12];
+	vb->type   = buf[0x13];
+	vb->obj_id = ldm_get_vnum (buf + 0x18);
+	ldm_get_vstr (buf+0x19+buf[0x18], vb->name, sizeof (vb->name)); //FIXME use relative?
 
 	switch (vb->type) {
-	case VBLK_CMP3:  result = ldm_parse_cmp3 (buffer, buflen, vb); break;
-	case VBLK_DSK3:  result = ldm_parse_dsk3 (buffer, buflen, vb); break;
-	case VBLK_DSK4:  result = ldm_parse_dsk4 (buffer, buflen, vb); break;
-	case VBLK_DGR3:  result = ldm_parse_dgr3 (buffer, buflen, vb); break;
-	case VBLK_DGR4:  result = ldm_parse_dgr4 (buffer, buflen, vb); break;
-	case VBLK_PRT3:  result = ldm_parse_prt3 (buffer, buflen, vb); break;
-	case VBLK_VOL5:  result = ldm_parse_vol5 (buffer, buflen, vb); break;
+		case VBLK_CMP3:  result = ldm_parse_cmp3 (buf, len, vb); break;
+		case VBLK_DSK3:  result = ldm_parse_dsk3 (buf, len, vb); break;
+		case VBLK_DSK4:  result = ldm_parse_dsk4 (buf, len, vb); break;
+		case VBLK_DGR3:  result = ldm_parse_dgr3 (buf, len, vb); break;
+		case VBLK_DGR4:  result = ldm_parse_dgr4 (buf, len, vb); break;
+		case VBLK_PRT3:  result = ldm_parse_prt3 (buf, len, vb); break;
+		case VBLK_VOL5:  result = ldm_parse_vol5 (buf, len, vb); break;
 	}
 
@@ -1289,6 +1296,8 @@
  * @ldb: ldmdb structure containing VBLK lists
  *
- * Place vblk in correct list by type. Partitions are added in sorted order.
+ * Place vblk in correct list by type. Partitions are sorted by offset.
+ *
  * Strange vblk's should've been removed in ldm_parse_vblk.
+ * FIXME prereq:vb is already sanity-checked.
  *
  * Return: none
@@ -1300,5 +1309,5 @@
 	DEBUG_ON (!vb || !ldb);
 
-	/* Put vblk into the correct list. @vb is already sanity-checked. */
+	/* Put vblk into the correct list. */
 	switch (vb->type) {
 	case VBLK_DGR3:
@@ -1317,9 +1326,9 @@
 		return;
 	case VBLK_PRT3:
-		/* Sort by partition's start sector */
+		/* Sort by the partition's start sector. */
 		list_for_each(item, &ldb->v_part) {
 			struct vblk *v = list_entry(item, struct vblk, list);
-			if (v->vblk.part.disk_id == vb->vblk.part.disk_id &&
-			    v->vblk.part.start > vb->vblk.part.start) {
+			if ((v->vblk.part.disk_id == vb->vblk.part.disk_id) &&
+			    (v->vblk.part.start > vb->vblk.part.start)) {
 				list_add_tail(&vb->list, &v->list);
 				return;
@@ -1521,7 +1530,6 @@
 	BOOL result = FALSE;
 
-	DEBUG_ON (!bdev || !ldb);
+	DEBUG_ON (!bdev || !ldb); // FIXME useless after deref'ing ldb (above)
 
-	/* FIXME what about overrun x%y!=0, can it actually happen? */
 	/* Loop through sectors */
 	for (s = skip; s < finish; s++) {
@@ -1531,5 +1539,5 @@
 		data = read_dev_sector (bdev, base + OFF_VMDB + s, &sect);
 		if (!data) {
-			ldm_crit ("Disk read failed in get buffers.");
+			ldm_crit ("Disk read failed in get buffers."); //FIXME
 			goto out;
 		}
@@ -1541,13 +1549,17 @@
 			struct vblk_head vbh;
 
-			if (!ldm_parse_vblk_head (block, &vbh)) {
-				ldm_error ("not a VBLK");
+			if (MAGIC_VBLK != BE32 (block)) {
+				ldm_error ("not a VBLK"); //FIXME
 				goto out;
 			}
 
-			if (vbh.nrec == 0)	/* Not in use */
+			/* Common to all VBLKs */
+			vbh.group = BE32 (block + 0x08);
+			vbh.rec   = BE16 (block + 0x0C);
+			vbh.nrec  = BE16 (block + 0x0E);
+			if (vbh.nrec == 0)	/* Record is not in use */
 				continue;
 
-			// Record is multipart
+			/* Record is multipart */
 			if (vbh.nrec > 1) {
 				if (ldm_frag_add(&fraglist, &vbh, body_data, body_size) < 0)
@@ -1587,30 +1599,4 @@
 
 /**
- * ldm_get_disk_objid - Search a linked list of vblk's for a given Disk Id
- * @ldb:  ldmdb struct
- *
- * The LDM Database contains a list of all partitions on all dynamic disks.  The
- * primary PRIVHEAD, at the beginning of the physical disk, tells us the GUID of
- * this disk.  This function searches for the GUID in a linked list of vblk's.
- *
- * Return: Pointer, A matching vblk was found
- *         NULL,    No match, or an error
- */
-static struct vblk * ldm_get_disk_objid (const struct ldmdb *ldb)
-{
-	list_t *item;
-
-	DEBUG_ON (!ldb);
-
-	list_for_each (item, &ldb->v_disk) {
-		struct vblk *v = list_entry (item, struct vblk, list);
-		if (!memcmp(v->vblk.disk.disk_id, ldb->ph.disk_id, GUID_SIZE))
-			return v;
-	}
-
-	return NULL;
-}
-
-/**
  * ldm_free_vblks - Free a linked list of vblk's
  * @lh: Head of a linked list of struct vblk
@@ -1654,7 +1640,6 @@
 	unsigned long first_sector, int first_minor)
 {
-	struct ldmdb    *ldb;
-	struct vblk     *disk;
-	unsigned long   base;
+	struct ldmdb  *ldb;
+	unsigned long base;
 	int err = -1;
 
@@ -1662,5 +1647,5 @@
 
 	/* Look for signs of a Dynamic Disk */
-	if (!ldm_validate_partition_table (bdev))
+	if (!ldm_validate_partition_table (bdev))	// FIXME rename to find_dynamic_disk?
 		return 0;
 
@@ -1695,17 +1680,10 @@
 
 	if (!ldm_get_vblks (bdev, base, ldb)) {
-		ldm_crit ("get buffers failed");
-		goto cleanup;
-	}
-
-	disk = ldm_get_disk_objid (ldb);
-	if (!disk) {
-		ldm_crit ("can't find this disk");
+		ldm_crit ("get buffers failed"); //FIXME
 		goto cleanup;
 	}
 
 	/* Finally, create the data partition devices. */
-	if (ldm_create_data_partitions (hd, first_sector, first_minor,
-				      ldb, disk)) {
+	if (ldm_create_data_partitions (hd, first_sector, first_minor, ldb)) {
 		ldm_debug ("Parsed LDM database successfully.");
 		err = 1;

Index: ldm.h
===================================================================
RCS file: /cvsroot/linux-ntfs/dynamic-disk/linux/fs/partitions/ldm.h,v
retrieving revision 1.42
retrieving revision 1.43
diff -U2 -r1.42 -r1.43
--- ldm.h	11 Apr 2002 14:29:47 -0000	1.42
+++ ldm.h	15 Apr 2002 00:14:20 -0000	1.43
@@ -72,5 +72,4 @@
 /* size of a vblk's static parts */
 #define VBLK_SIZE_HEAD		16
-
 #define VBLK_SIZE_CMP3		22		/* Name and version */
 #define VBLK_SIZE_DGR3		12
@@ -168,6 +167,8 @@
 	u64	parent_id;
 	u8	type;
-	u8	n_childs;
+	u8	children;
+#ifdef CONFIG_BLK_DEV_MD
 	u16	chunksize;
+#endif
 };
 

[Linux-NTFS-cvs] CVS: dynamic-disk/test ldminfo.c,1.25,1.26

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

Changes by: flatcap

Update of /cvsroot/linux-ntfs/dynamic-disk/test
In directory usw-pr-cvs1:/tmp/cvs-serv23349/test

Modified Files:
	ldminfo.c 
Log Message:
more shufflings about.  more fixmes.  nothing significant.


Index: ldminfo.c
===================================================================
RCS file: /cvsroot/linux-ntfs/dynamic-disk/test/ldminfo.c,v
retrieving revision 1.25
retrieving revision 1.26
diff -U2 -r1.25 -r1.26
--- ldminfo.c	11 Apr 2002 14:27:39 -0000	1.25
+++ ldminfo.c	15 Apr 2002 00:14:20 -0000	1.26
@@ -219,10 +219,15 @@
 		bdev.bd_dev = kdev_val(drive);	 /* hack (bd_dev isn't a kdev_t) */
 
-		ldm_partition2 (&hd_gendisk, &bdev, &ldb, minor + 1);
+		if (ldm_partition2 (&hd_gendisk, &bdev, &ldb, minor + 1) != 1) {
+			printf ("Something went wrong, skipping device '%s'\n", argv[a]);
+			continue;
+		}
 
+#if 1
 		if (dump)
 			dump_database (argv[a], &ldb);
 		else
 			dump_info     (argv[a], maxminor);
+#endif
 
 		ldm_free_vblks(&ldb.v_dgrp);

[Linux-NTFS-cvs] CVS: linux-ntfs/ntfstools mkntfs.c,1.60,1.61 ntfsdump_logfile.c,1.12,1.13

[Anton A. <an...@us...>]

Changes by: antona

Update of /cvsroot/linux-ntfs/linux-ntfs/ntfstools
In directory usw-pr-cvs1:/tmp/cvs-serv7324/ntfstools

Modified Files:
	mkntfs.c ntfsdump_logfile.c 
Log Message:
Remove find_first_attr and make all users use get_attr_search_ctx + find_attr instead.


Index: mkntfs.c
===================================================================
RCS file: /cvsroot/linux-ntfs/linux-ntfs/ntfstools/mkntfs.c,v
retrieving revision 1.60
retrieving revision 1.61
diff -U2 -r1.60 -r1.61
--- mkntfs.c	12 Mar 2002 22:11:02 -0000	1.60
+++ mkntfs.c	14 Apr 2002 15:26:24 -0000	1.61
@@ -110,4 +110,5 @@
 #include "disk_io.h"
 #include "attrib.h"
+#include "bitmap.h"
 
 extern const unsigned char attrdef_ntfs12_array[2400];
@@ -1183,5 +1184,5 @@
 		const char *val, const __s64 val_len)
 {
-	attr_search_context ctx;
+	attr_search_context *ctx;
 	ATTR_RECORD *a;
 	__u16 hdr_size;
@@ -1208,26 +1209,27 @@
 		uname = NULL;
 	/* Check if the attribute is already there. */
-	memset(&ctx, 0, sizeof(ctx));
-	ctx.mrec = m;
-	if (find_first_attr(type, uname, name_len, ic, upcase, upcase_len,
-			NULL, 0, &ctx)) {
-		if (uname)
-			free(uname);
-		return -EEXIST;
+	ctx = get_attr_search_ctx(NULL, m);
+	if (!ctx) {
+		Eprintf("Failed to allocate attribute search context.\n");
+		err = -ENOMEM;
+		goto err_out;
+	}
+	if (find_attr(type, uname, name_len, ic, upcase, upcase_len, NULL, 0,
+			ctx)) {
+		err = -EEXIST;
+		goto err_out;
 	}
-	a = ctx.attr;
+	a = ctx->attr;
 	if (flags & ATTR_COMPRESSION_MASK) {
 		Eprintf("Compressed attributes not supported yet.\n");
 		// FIXME: Compress attribute into a temporary buffer, set
 		// val accordingly and save the compressed size.
-		if (uname)
-			free(uname);
-		return -ENOTSUP;
+		err = -ENOTSUP;
+		goto err_out;
 	}
 	if (flags & (ATTR_IS_ENCRYPTED || ATTR_IS_SPARSE)) {
 		Eprintf("Encrypted/sparse attributes not supported yet.\n");
-		if (uname)
-			free(uname);
-		return -ENOTSUP;
+		err = -ENOTSUP;
+		goto err_out;
 	}
 	if (flags & ATTR_COMPRESSION_MASK) {
@@ -1254,7 +1256,6 @@
 	if (highest_vcn * opt.cluster_size < val_len) {
 		Eprintf("BUG: Allocated size is smaller than data size!\n");
-		if (uname)
-			free(uname);
-		return -EINVAL;
+		err = -EINVAL;
+		goto err_out;
 	}
 	err = make_room_for_attribute(m, (char*)a, asize);
@@ -1274,7 +1275,6 @@
 		// FIXME: the check for needing extension records should be
 		// earlier on as it is very quick: asize > m->bytes_allocated?
-		if (uname)
-			free(uname);
-		return -ENOTSUP;
+		err = -ENOTSUP;
+		goto err_out;
 	}
 #ifdef DEBUG
@@ -1283,7 +1283,5 @@
 				"record(): make_room_for_attribute() returned "
 				"error: EINVAL!\n");
-		if (uname)
-			free(uname);
-		return err;
+		goto err_out;
 	}
 #endif
@@ -1339,4 +1337,7 @@
 				"error %i.\n", err < 0 ? err : bw);
 	}
+err_out:
+	if (ctx)
+		put_attr_search_ctx(ctx);
 	if (uname)
 		free(uname);
@@ -1350,5 +1351,5 @@
 		const ATTR_FLAGS flags, const char *val, const __s64 val_len)
 {
-	attr_search_context ctx;
+	attr_search_context *ctx;
 	ATTR_RECORD *a;
 	__u16 hdr_size;
@@ -1375,26 +1376,27 @@
 		uname = NULL;
 	/* Check if the attribute is already there. */
-	memset(&ctx, 0, sizeof(ctx));
-	ctx.mrec = m;
-	if (find_first_attr(type, uname, name_len, ic, upcase, upcase_len,
-			NULL, 0, &ctx)) {
-		if (uname)
-			free(uname);
-		return -EEXIST;
+	ctx = get_attr_search_ctx(NULL, m);
+	if (!ctx) {
+		Eprintf("Failed to allocate attribute search context.\n");
+		err = -ENOMEM;
+		goto err_out;
+	}
+	if (find_attr(type, uname, name_len, ic, upcase, upcase_len, NULL, 0,
+			ctx)) {
+		err = -EEXIST;
+		goto err_out;
 	}
-	a = ctx.attr;
+	a = ctx->attr;
 	if (flags & ATTR_COMPRESSION_MASK) {
 		Eprintf("Compressed attributes not supported yet.\n");
 		// FIXME: Compress attribute into a temporary buffer, set
 		// val accordingly and save the compressed size.
-		if (uname)
-			free(uname);
-		return -ENOTSUP;
+		err = -ENOTSUP;
+		goto err_out;
 	}
 	if (flags & (ATTR_IS_ENCRYPTED || ATTR_IS_SPARSE)) {
 		Eprintf("Encrypted/sparse attributes not supported yet.\n");
-		if (uname)
-			free(uname);
-		return -ENOTSUP;
+		err = -ENOTSUP;
+		goto err_out;
 	}
 	if (val_len) {
@@ -1402,10 +1404,8 @@
 				opt.cluster_size - 1) / opt.cluster_size);
 		if (!rl) {
-			err = errno;
+			err = -errno;
 			Eprintf("Failed to allocate scattered clusters: %s\n",
-					strerror(err));
-			if (uname)
-				free(uname);
-			return -err;
+					strerror(-err));
+			goto err_out;
 		}
 	} else
@@ -1444,9 +1444,6 @@
 		// FIXME: the check for needing extension records should be
 		// earlier on as it is very quick: asize > m->bytes_allocated?
-		if (uname)
-			free(uname);
-		if (rl)
-			free(rl);
-		return -ENOTSUP;
+		err = -ENOTSUP;
+		goto err_out;
 	}
 #ifdef DEBUG
@@ -1455,9 +1452,5 @@
 				"mft_record(): make_room_for_attribute() "
 				"returned error: EINVAL!\n");
-		if (uname)
-			free(uname);
-		if (rl)
-			free(rl);
-		return err;
+		goto err_out;
 	}
 #endif
@@ -1515,4 +1508,7 @@
 				"error %i.\n", err < 0 ? err : bw);
 	}
+err_out:
+	if (ctx)
+		put_attr_search_ctx(ctx);
 	if (uname)
 		free(uname);
@@ -1529,5 +1525,5 @@
 		const char *val, const __u32 val_len)
 {
-	attr_search_context ctx;
+	attr_search_context *ctx;
 	ATTR_RECORD *a;
 	int asize, err, i;
@@ -1547,13 +1543,16 @@
 		uname = NULL;
 	/* Check if the attribute is already there. */
-	memset(&ctx, 0, sizeof(ctx));
-	ctx.mrec = m;
-	if (find_first_attr(type, uname, name_len, ic, upcase, upcase_len,
-			val, val_len, &ctx)) {
-		if (uname)
-			free(uname);
-		return -EEXIST;
+	ctx = get_attr_search_ctx(NULL, m);
+	if (!ctx) {
+		Eprintf("Failed to allocate attribute search context.\n");
+		err = -ENOMEM;
+		goto err_out;
+	}
+	if (find_attr(type, uname, name_len, ic, upcase, upcase_len, val,
+			val_len, ctx)) {
+		err = -EEXIST;
+		goto err_out;
 	}
-	a = ctx.attr;
+	a = ctx->attr;
 	/* sizeof(resident attribute record header) == 24 */
 	asize = (24 + (name_len + 7 & ~7) + val_len) + 7 & ~7;
@@ -1574,7 +1573,6 @@
 		// FIXME: the check for needing extension records should be
 		// earlier on as it is very quick: asize > m->bytes_allocated?
-		if (uname)
-			free(uname);
-		return -ENOTSUP;
+		err = -ENOTSUP;
+		goto err_out;
 	}
 #ifdef DEBUG
@@ -1583,7 +1581,5 @@
 				"record(): make_room_for_attribute() returned "
 				"error: EINVAL!\n");
-		if (uname)
-			free(uname);
-		return err;
+		goto err_out;
 	}
 #endif
@@ -1603,9 +1599,12 @@
 	if (name_len)
 		memcpy((char*)a + 24, uname, name_len << 1);
+err_out:
+	if (ctx)
+		put_attr_search_ctx(ctx);
 	if (uname)
 		free(uname);
 	if (val_len)
 		memcpy((char*)a + le16_to_cpu(a->value_offset), val, val_len);
-	return 0;
+	return err;
 }
 
@@ -1657,5 +1656,5 @@
 		const FILE_NAME_TYPE_FLAGS file_name_type)
 {
-	attr_search_context ctx;
+	attr_search_context *ctx;
 	STANDARD_INFORMATION *si;
 	FILE_NAME_ATTR *fn;
@@ -1663,24 +1662,33 @@
 
 	/* Check if the attribute is already there. */
-	memset(&ctx, 0, sizeof(ctx));
-	ctx.mrec = m;
-	if (!find_first_attr($STANDARD_INFORMATION, NULL, 0, 0, NULL, 0,
-			NULL, 0, &ctx)) {
+	ctx = get_attr_search_ctx(NULL, m);
+	if (!ctx) {
+		Eprintf("Failed to allocate attribute search context.\n");
+		return -ENOMEM;
+	}
+	if (!find_attr($STANDARD_INFORMATION, NULL, 0, 0, NULL, 0, NULL, 0,
+			ctx)) {
 		Eprintf("BUG: Standard information attribute not present in "
 				"file record\n");
+		put_attr_search_ctx(ctx);
 		return -EINVAL;
 	}
-	si = (STANDARD_INFORMATION*)((char*)ctx.attr +
-			le16_to_cpu(ctx.attr->value_offset));
+	si = (STANDARD_INFORMATION*)((char*)ctx->attr +
+			le16_to_cpu(ctx->attr->value_offset));
 	i = (strlen(file_name) + 1) * sizeof(uchar_t);
 	fn_size = sizeof(FILE_NAME_ATTR) + i;
 	fn = (FILE_NAME_ATTR*)malloc(fn_size);
-	if (!fn)
+	if (!fn) {
+		put_attr_search_ctx(ctx);
 		return -errno;
+	}
 	fn->parent_directory = parent_dir;
+
 	fn->creation_time = si->creation_time;
 	fn->last_data_change_time = si->last_data_change_time;
 	fn->last_mft_change_time = si->last_mft_change_time;
 	fn->last_access_time = si->last_access_time;
+	put_attr_search_ctx(ctx);
+
 	fn->allocated_size = cpu_to_le64(allocated_size);
 	fn->data_size = cpu_to_le64(data_size);
@@ -2012,9 +2020,9 @@
 		INDEX_ALLOCATION **index)
 {
-	attr_search_context ctx;
+	attr_search_context *ctx;
 	ATTR_RECORD *a;
 	INDEX_ROOT *r;
 	INDEX_ENTRY *re, *ae;
-	INDEX_ALLOCATION *ia_val;
+	INDEX_ALLOCATION *ia_val = NULL;
 	uchar_t *uname;
 	char bmp[8];
@@ -2035,15 +2043,22 @@
 		uname = NULL;
 	/* Find the index root attribute. */
-	memset(&ctx, 0, sizeof(ctx));
-	ctx.mrec = m;
-	err = find_first_attr($INDEX_ROOT, uname, name_len, ic, upcase,
-			upcase_len, NULL, 0, &ctx);
+	ctx = get_attr_search_ctx(NULL, m);
+	if (!ctx) {
+		Eprintf("Failed to allocate attribute search context.\n");
+		return -ENOMEM;
+	}
+	err = find_attr($INDEX_ROOT, uname, name_len, ic, upcase, upcase_len,
+			NULL, 0, ctx);
 	if (uname)
 		free(uname);
-	if (!err)
-		return -ENOTDIR;
-	a = ctx.attr;
-	if (a->non_resident || a->flags)
-		return -EINVAL;
+	if (!err) {
+		err = -ENOTDIR;
+		goto err_out;
+	}
+	a = ctx->attr;
+	if (a->non_resident || a->flags) {
+		err = -EINVAL;
+		goto err_out;
+	}
 	r = (INDEX_ROOT*)((char*)a + le16_to_cpu(a->value_offset));
 	re_end = (char*)r + le32_to_cpu(a->value_length);
@@ -2052,13 +2067,15 @@
 	index_block_size = le32_to_cpu(r->index_block_size);
 	memset(bmp, 0, sizeof(bmp));
-	ntfs_set_bit(&bmp, 0ULL, 1);
+	ntfs_set_bit(bmp, 0ULL, 1);
 	/* Bitmap has to be at least 8 bytes in size. */
 	err = add_attr_bitmap(m, name, name_len, ic, upcase, upcase_len,
 			(char*)&bmp, sizeof(bmp));
 	if (err)
-		return err;
+		goto err_out;
 	ia_val = calloc(1, index_block_size);
-	if (!ia_val)
-		return -errno;
+	if (!ia_val) {
+		err = -errno;
+		goto err_out;
+	}
 	/* Setup header. */
 	ia_val->magic = magic_INDX;
@@ -2118,6 +2135,5 @@
 		// TODO: Remove the added bitmap!
 		// Revert index root from index allocation.
-		free(ia_val);
-		return err;
+		goto err_out;
 	}
 	/* Set VCN pointer to 0LL. */
@@ -2128,18 +2144,23 @@
 		Eprintf("pre_write_mst_fixup() failed in "
 				"upgrade_to_large_index.\n");
-		free(ia_val);
-		return -EINVAL;
+		err = -EINVAL;
+		goto err_out;
 	}
 	err = add_attr_index_alloc(m, name, name_len, ic, upcase, upcase_len,
 			(char*)ia_val, index_block_size);
-	__post_read_mst_fixup((NTFS_RECORD*)ia_val, index_block_size);
+	post_write_mst_fixup((NTFS_RECORD*)ia_val);
 	if (err) {
 		// TODO: Remove the added bitmap!
 		// Revert index root from index allocation.
-		free(ia_val);
-		return err;
+		goto err_out;
 	}
 	*index = ia_val;
 	return 0;
+err_out:
+	if (ctx)
+		put_attr_search_ctx(ctx);
+	if (ia_val)
+		free(ia_val);
+	return err;
 }
 
@@ -2712,5 +2733,5 @@
 	ATTR_RECORD *a;
 	MFT_REF root_ref;
-	attr_search_context ctx;
+	attr_search_context *ctx;
 	char *sd;
 	NTFS_BOOT_SECTOR *bs;
@@ -3250,15 +3271,19 @@
 				opt.upcase, opt.upcase_len, &index_block);
 	if (!err) {
-		memset(&ctx, 0, sizeof(ctx));
-		ctx.mrec = m;
+		ctx = get_attr_search_ctx(NULL, m);
+		if (!ctx)
+			err_exit("Failed to allocate attribute search "
+					"context: %s\n", strerror(errno));
 		/* There is exactly one file name so this is ok. */
-		if (!find_first_attr($FILE_NAME, NULL, 0, 0, NULL, 0, NULL, 0,
-				&ctx))
+		if (!find_attr($FILE_NAME, NULL, 0, 0, NULL, 0, NULL, 0, ctx)) {
+			put_attr_search_ctx(ctx);
 			err_exit("BUG: $FILE_NAME attribute not found.\n");
-		a = ctx.attr;
+		}
+		a = ctx->attr;
 		err = insert_file_link_in_dir_index(index_block, root_ref,
 				(FILE_NAME_ATTR*)((char*)a +
 				le16_to_cpu(a->value_offset)),
 				le32_to_cpu(a->value_length));
+		put_attr_search_ctx(ctx);
 	}
 	if (err)
@@ -3597,16 +3622,25 @@
 		err_exit("Not enough memory to allocate internal buffer.\n");;
 	j = stoucs(ustr, "$I30", i);
-	memset(&ctx, 0, sizeof(ctx));
-	ctx.mrec = m;
-	if (!find_first_attr($INDEX_ALLOCATION, ustr, j, IGNORE_CASE,
-			opt.upcase, opt.upcase_len, NULL, 0, &ctx))
+	ctx = get_attr_search_ctx(NULL, m);
+	if (!ctx)
+		err_exit("Failed to allocate attribute search context: %s\n",
+				strerror(errno));
+	if (!find_attr($INDEX_ALLOCATION, ustr, j, IGNORE_CASE, opt.upcase,
+			opt.upcase_len, NULL, 0, ctx)) {
+		put_attr_search_ctx(ctx);
 		err_exit("BUG: $INDEX_ALLOCATION attribute not found.\n");
-	a = ctx.attr;
+	}
+	a = ctx->attr;
 	rl_index = decompress_run_list(a);
-	if (!rl_index)
+	if (!rl_index) {
+		put_attr_search_ctx(ctx);
 		err_exit("Failed to decompress run list of $INDEX_ALLOCATION "
 				"attribute.\n");
-	if (sle64_to_cpu(a->initialized_size) < i)
+	}
+	if (sle64_to_cpu(a->initialized_size) < i) {
+		put_attr_search_ctx(ctx);
 		err_exit("BUG: $INDEX_ALLOCATION attribute too short.\n");
+	}
+	put_attr_search_ctx(ctx);
 	i = sizeof(INDEX_BLOCK) - sizeof(INDEX_HEADER) +
 			le32_to_cpu(index_block->index.allocated_size);
@@ -3619,14 +3653,19 @@
 		err_exit("Error writing $INDEX_ALLOCATION.\n");
 	/* No more changes to @index_block below here so no need for fixup: */
-	// __post_read_mst_fixup((NTFS_RECORD*)index_block, i);
+	// post_write_mst_fixup((NTFS_RECORD*)index_block);
 	Vprintf("Syncing $Bitmap.\n");
 	m = (MFT_RECORD*)(buf + 6 * opt.mft_record_size);
-	memset(&ctx, 0, sizeof(ctx));
-	ctx.mrec = m;
-	if (!find_first_attr($DATA, NULL, 0, 0, NULL, 0, NULL, 0, &ctx))
+	ctx = get_attr_search_ctx(NULL, m);
+	if (!ctx)
+		err_exit("Failed to allocate attribute search context: %s\n",
+				strerror(errno));
+	if (!find_attr($DATA, NULL, 0, 0, NULL, 0, NULL, 0, ctx)) {
+		put_attr_search_ctx(ctx);
 		err_exit("BUG: $DATA attribute not found.\n");
-	a = ctx.attr;
+	}
+	a = ctx->attr;
 	if (a->non_resident) {
 		rl = decompress_run_list(a);
+		put_attr_search_ctx(ctx);
 		if (!rl)
 			err_exit("decompress_run_list() failed\n");
@@ -3636,7 +3675,9 @@
 			err_exit("%s\n", lw == -1 ? strerror(errno) :
 					"unknown error");
-	} else
+	} else {
 		memcpy((char*)a + le16_to_cpu(a->value_offset), lcn_bitmap,
 				le32_to_cpu(a->value_length));
+		put_attr_search_ctx(ctx);
+	}
 	/*
 	 * No need to sync $MFT/$BITMAP as that has never been modified since

Index: ntfsdump_logfile.c
===================================================================
RCS file: /cvsroot/linux-ntfs/linux-ntfs/ntfstools/ntfsdump_logfile.c,v
retrieving revision 1.12
retrieving revision 1.13
diff -U2 -r1.12 -r1.13
--- ntfsdump_logfile.c	6 Dec 2001 01:14:52 -0000	1.12
+++ ntfsdump_logfile.c	14 Apr 2002 15:26:24 -0000	1.13
@@ -67,4 +67,5 @@
 	unsigned char *lfd = NULL;
 	ntfs_volume *vol = NULL;
+	attr_search_context *ctx = NULL;
 	RESTART_PAGE_HEADER *rph;
 	RESTART_AREA *rr;
@@ -75,5 +76,4 @@
 	int i, lps, client;
 	MFT_REF mref;
-	attr_search_context ctx;
 	char zero[4096];
 
@@ -123,5 +123,4 @@
 	}
 	/* Read in $LogFile. */
-	memset(&ctx, 0, sizeof(attr_search_context));
 	*(__u64*)&mref = FILE_$LogFile;
 	if (__read_file_record(vol, &mref, &m, NULL)) {
@@ -129,7 +128,11 @@
 		goto error_exit;
 	}
-	ctx.mrec = m;
+	ctx = get_attr_search_ctx(NULL, m);
+	if (!ctx) {
+		perror("Failed to allocate attribute search context");
+		goto error_exit;
+	}
 	/* Find the $DATA attribute of the $LogFile. */
-	if (!find_first_attr($DATA, NULL, 0, 0, NULL, 0, NULL, 0, &ctx)) {
+	if (!find_attr($DATA, NULL, 0, 0, NULL, 0, NULL, 0, ctx)) {
 		fprintf(stderr, "Error: Attribute $DATA was not found in" \
 		                "$LogFile!\n");
@@ -353,4 +356,6 @@
 	if (lfd)
 		free(lfd);
+	if (ctx)
+		put_attr_search_ctx(ctx);
 	if (m)
 		free(m);

[Linux-NTFS-cvs] CVS: linux-ntfs/libntfs attrib.c,1.17,1.18 disk_io.c,1.15,1.16

[Anton A. <an...@us...>]

Changes by: antona

Update of /cvsroot/linux-ntfs/linux-ntfs/libntfs
In directory usw-pr-cvs1:/tmp/cvs-serv7324/libntfs

Modified Files:
	attrib.c disk_io.c 
Log Message:
Remove find_first_attr and make all users use get_attr_search_ctx + find_attr instead.


Index: attrib.c
===================================================================
RCS file: /cvsroot/linux-ntfs/linux-ntfs/libntfs/attrib.c,v
retrieving revision 1.17
retrieving revision 1.18
diff -U2 -r1.17 -r1.18
--- attrib.c	14 Apr 2002 14:08:29 -0000	1.17
+++ attrib.c	14 Apr 2002 15:26:23 -0000	1.18
@@ -186,48 +186,4 @@
 }
 
-/**
- * find_first_attr - find first attribute in mft record
- * @type:	attribute type to find
- * @name:	attribute name to find (optional, i.e. NULL means don't care)
- * @name_len:	attribute name length (only needed if @name present)
- * @ic:		IGNORE_CASE or CASE_SENSITIVE (ignored if @name not present)
- * @upcase:	unicode upcase table
- * @ucpase_len:	length of upcase table in unicode characters
- * @val:	attribute value to find (optional, resident attributes only)
- * @val_len:	attribute value length
- * @ctx:	search context with mft record and attribute to search from
- *
- * find_first_attr() is just an inlined wrapper for find_attr(). For details
- * see description of find_attr() above.
- */
-__inline__ BOOL find_first_attr(const ATTR_TYPES type, const uchar_t *name,
-		const __u32 name_len, const IGNORE_CASE_BOOL ic,
-		const uchar_t *upcase, const __u32 upcase_len,
-		const __u8 *val, const __u32 val_len, attr_search_context *ctx)
-{
-	MFT_RECORD *m;
-	ATTR_RECORD *a;
-	
-#ifdef DEBUG
-	if (!ctx || !ctx->mrec) {
-		Dputs("find_first_attr() received NULL pointer!");
-		return FALSE;
-	}
-	if (ctx->attr)
-		Dprintf("find_first_attr(): received non-NULL attribute "
-				"pointer.\nThis will be overwritten resulting "
-				"in possible memory leakage.\n");
-#endif
-	m = ctx->mrec;
-	ctx->is_first = TRUE;
-	ctx->attr = a = (ATTR_RECORD*)((char*)m + le16_to_cpu(m->attrs_offset));
-	if (p2n(a) >= p2n(m) && (char*)a <= (char*)m +
-						le32_to_cpu(m->bytes_allocated))
-		return find_attr(type, name, name_len, ic, upcase, upcase_len,
-				val, val_len, ctx);
-	Dputs("find_first_attr(): file is corrupt.");
-	return FALSE;
-}
-
 /* FIXME: Need to write the new flags to disk. */
 int set_ntfs_volume_flags(ntfs_volume *v, MFT_RECORD *b,
@@ -236,5 +192,5 @@
 	ATTR_RECORD *r;
 	VOLUME_INFORMATION *c;
-	attr_search_context ctx;
+	attr_search_context *ctx;
 
 	/* Sanity checks. */
@@ -242,18 +198,21 @@
                 return 0;
 	/* Get a pointer to the volume information attribute. */
-	memset(&ctx, 0, sizeof(attr_search_context));
-	ctx.mrec = b;
-	if (!find_first_attr($VOLUME_INFORMATION, NULL, 0, 0, NULL, 0, NULL, 0,
-			     &ctx)) {
-		fprintf(stderr, "Error: Attribute $VOLUME_INFORMATION was " \
-				"not found in $Volume!\n");
+	ctx = get_attr_search_ctx(NULL, b);
+	if (!ctx) {
+		Dperror("Failed to allocate attribute search context");
 		return 0;
 	}
-	r = ctx.attr;
+	if (!find_attr($VOLUME_INFORMATION, NULL, 0, 0, NULL, 0, NULL, 0,
+			ctx)) {
+		Dputs("Error: Attribute $VOLUME_INFORMATION was not found in "
+				"$Volume!");
+		goto err_out;
+	}
+	r = ctx->attr;
 	/* Sanity check. */
 	if (r->non_resident) {
-		fprintf(stderr, "Error: Attribute $VOLUME_INFORMATION must " \
-				"be resident (and it isn't)!\n");
-		return 0;
+		Dputs("Error: Attribute $VOLUME_INFORMATION must be resident "
+				"(and it isn't)!");
+		goto err_out;
 	}
 	/* Get a pointer to the value of the attribute. */
@@ -261,15 +220,19 @@
 	/* Sanity checks. */
 	if ((char*)c + le32_to_cpu(r->value_length) > 
-				le16_to_cpu(b->bytes_in_use) + (char*)b ||
-	    le16_to_cpu(r->value_offset) + le32_to_cpu(r->value_length) >
-				le32_to_cpu(r->length)) {
-		fprintf(stderr, "Error: Attribute $VOLUME_INFORMATION in " \
-				"$Volume is corrupt!\n");
-		return 0;
+			le16_to_cpu(b->bytes_in_use) + (char*)b ||
+	    		le16_to_cpu(r->value_offset) +
+			le32_to_cpu(r->value_length) > le32_to_cpu(r->length)) {
+		Dputs("Error: Attribute $VOLUME_INFORMATION in $Volume is "
+				"corrupt!");
+		goto err_out;
 	}
 	/* Set the volume flags. */
 	c->flags = cpu_to_le16(flags);
+	put_attr_search_ctx(ctx);
 	/* Success! */
 	return 1;
+err_out:
+	put_attr_search_ctx(ctx);
+	return 0;
 }
 

Index: disk_io.c
===================================================================
RCS file: /cvsroot/linux-ntfs/linux-ntfs/libntfs/disk_io.c,v
retrieving revision 1.15
retrieving revision 1.16
diff -U2 -r1.15 -r1.16
--- disk_io.c	14 Apr 2002 14:08:30 -0000	1.15
+++ disk_io.c	14 Apr 2002 15:26:23 -0000	1.16
@@ -30,4 +30,5 @@
 #include "types.h"
 #include "disk_io.h"
+#include "bitmap.h"
 
 __s64 ntfs_pwrite(int fd, const void *b, __s64 count, const __s64 pos)
@@ -117,5 +118,5 @@
 finished:
 	/* Quickly deprotect the data again. */
-	__post_read_mst_fixup((NTFS_RECORD*)b, count);
+	post_write_mst_fixup((NTFS_RECORD*)b);
 error_end:
 	return error;

[Linux-NTFS-cvs] CVS: linux-ntfs ChangeLog,1.32,1.33

[Anton A. <an...@us...>]

Changes by: antona

Update of /cvsroot/linux-ntfs/linux-ntfs
In directory usw-pr-cvs1:/tmp/cvs-serv7324

Modified Files:
	ChangeLog 
Log Message:
Remove find_first_attr and make all users use get_attr_search_ctx + find_attr instead.


Index: ChangeLog
===================================================================
RCS file: /cvsroot/linux-ntfs/linux-ntfs/ChangeLog,v
retrieving revision 1.32
retrieving revision 1.33
diff -U2 -r1.32 -r1.33
--- ChangeLog	14 Apr 2002 14:20:10 -0000	1.32
+++ ChangeLog	14 Apr 2002 15:26:23 -0000	1.33
@@ -3,7 +3,12 @@
 	  me to make it fit in with e2label better.
 	- Extend ntfs_mount() to also read in the volume label.
-	- Added man page for ntfslabel.
+	- Add man page for ntfslabel.
 	- Silence verbosity of output from ntfs_mount(). It is now only output
 	  if ./configure was run with --enable-debug.
+	- Remove a LOT of dead code. Massive cleanup.
+	- Add full attribute search context and allocation/init/deallocation
+	  functions (see attrib.c).
+	- Remove find_first_attr(). Just use get_attr_search_ctx() +
+	  find_attr() which has the same effect.
 
 12/03/2002 - 1.6.0 - More mkntfs options and cleanups.

[Linux-NTFS-cvs] CVS: linux-ntfs/include bitmap.h,1.8,1.9

[Anton A. <an...@us...>]

Changes by: antona

Update of /cvsroot/linux-ntfs/linux-ntfs/include
In directory usw-pr-cvs1:/tmp/cvs-serv7324/include

Modified Files:
	bitmap.h 
Log Message:
Remove find_first_attr and make all users use get_attr_search_ctx + find_attr instead.


Index: bitmap.h
===================================================================
RCS file: /cvsroot/linux-ntfs/linux-ntfs/include/bitmap.h,v
retrieving revision 1.8
retrieving revision 1.9
diff -U2 -r1.8 -r1.9
--- bitmap.h	14 Apr 2002 13:56:45 -0000	1.8
+++ bitmap.h	14 Apr 2002 15:26:23 -0000	1.9
@@ -46,5 +46,5 @@
  */
 static __inline__ void ntfs_set_bit(__u8 *bitmap, const __u64 bit,
-		const __u8 new_value);
+		const __u8 new_value)
 {
 //	Dprintf("bitmap %p, bit 0x%Lx, new_value %i\n", bitmap, bit, new_value);

[Linux-NTFS-cvs] CVS: linux-ntfs ChangeLog,1.31,1.32

[Anton A. <an...@us...>]

Changes by: antona

Update of /cvsroot/linux-ntfs/linux-ntfs
In directory usw-pr-cvs1:/tmp/cvs-serv22988

Modified Files:
	ChangeLog 
Log Message:
Prepare changelog to accept a long list of changes. (-;


Index: ChangeLog
===================================================================
RCS file: /cvsroot/linux-ntfs/linux-ntfs/ChangeLog,v
retrieving revision 1.31
retrieving revision 1.32
diff -U2 -r1.31 -r1.32
--- ChangeLog	12 Apr 2002 15:35:27 -0000	1.31
+++ ChangeLog	14 Apr 2002 14:20:10 -0000	1.32
@@ -1,9 +1,9 @@
-12/04/2002 - 1.7.0.WIP - New tool ntfslabel.
-	New tool ntfslabel written by Matthew Fanto with a few cleanups from
-	me to make it fit in with e2label better.
-	Extend ntfs_mount() to also read in the volume label.
-	Added man page for ntfslabel.
-	Silence verbosity of output from ntfs_mount(). It is now only output if
-	./configure was run with --enable-debug.
+12/04/2002 - 1.6.99 - Work in progress.
+	- New tool ntfslabel written by Matthew Fanto with a few cleanups from
+	  me to make it fit in with e2label better.
+	- Extend ntfs_mount() to also read in the volume label.
+	- Added man page for ntfslabel.
+	- Silence verbosity of output from ntfs_mount(). It is now only output
+	  if ./configure was run with --enable-debug.
 
 12/03/2002 - 1.6.0 - More mkntfs options and cleanups.