Commit 7f4238a0 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge branch 'hpfs' 

* hpfs:
  HPFS: Remove unused variable
  HPFS: Move declaration up, so that there are no out-of-scope pointers
  HPFS: Fix some unaligned accesses
  HPFS: Fix endianity. Make hpfs work on big-endian machines
  HPFS: Implement fsync for hpfs
  HPFS: Fix a bug that filesystem was not marked dirty when remounting it
  HPFS: Restrict uid and gid to 16-bit values
  HPFS: When marking or clearing the dirty bit, sync the filesystem
  HPFS: Use types with defined width
  HPFS: Remove mark_inode_dirty
  HPFS: Remove CR/LF conversion option
  HPFS: Remove remaining locks
  HPFS: Introduce a global mutex and lock it on every callback from VFS.
  HPFS: Make HPFS compile on preempt and SMP
parents 8b061610 88f4e9e8

fs/hpfs/Kconfig

+0 −1
Original line number Diff line number Diff line 
config HPFS_FS

	tristate "OS/2 HPFS file system support"

	depends on BLOCK

	depends on BROKEN || !PREEMPT

	help

	  OS/2 is IBM's operating system for PC's, the same as Warp, and HPFS

	  is the file system used for organizing files on OS/2 hard disk

fs/hpfs/alloc.c

+43 −75
Original line number Diff line number Diff line
@@ -8,8 +8,6 @@ 


#include "hpfs_fn.h"



static int hpfs_alloc_if_possible_nolock(struct super_block *s, secno sec);



/*

 * Check if a sector is allocated in bitmap

 * This is really slow. Turned on only if chk==2
@@ -18,9 +16,9 @@ static int hpfs_alloc_if_possible_nolock(struct super_block *s, secno sec); 
static int chk_if_allocated(struct super_block *s, secno sec, char *msg)

{

	struct quad_buffer_head qbh;

	unsigned *bmp;

	u32 *bmp;

	if (!(bmp = hpfs_map_bitmap(s, sec >> 14, &qbh, "chk"))) goto fail;

	if ((bmp[(sec & 0x3fff) >> 5] >> (sec & 0x1f)) & 1) {

	if ((cpu_to_le32(bmp[(sec & 0x3fff) >> 5]) >> (sec & 0x1f)) & 1) {

		hpfs_error(s, "sector '%s' - %08x not allocated in bitmap", msg, sec);

		goto fail1;

	}
@@ -28,7 +26,7 @@ static int chk_if_allocated(struct super_block *s, secno sec, char *msg) 
	if (sec >= hpfs_sb(s)->sb_dirband_start && sec < hpfs_sb(s)->sb_dirband_start + hpfs_sb(s)->sb_dirband_size) {

		unsigned ssec = (sec - hpfs_sb(s)->sb_dirband_start) / 4;

		if (!(bmp = hpfs_map_dnode_bitmap(s, &qbh))) goto fail;

		if ((bmp[ssec >> 5] >> (ssec & 0x1f)) & 1) {

		if ((le32_to_cpu(bmp[ssec >> 5]) >> (ssec & 0x1f)) & 1) {

			hpfs_error(s, "sector '%s' - %08x not allocated in directory bitmap", msg, sec);

			goto fail1;

		}
@@ -75,7 +73,6 @@ static secno alloc_in_bmp(struct super_block *s, secno near, unsigned n, unsigne 
		hpfs_error(s, "Bad allocation size: %d", n);

		return 0;

	}

	lock_super(s);

	if (bs != ~0x3fff) {

		if (!(bmp = hpfs_map_bitmap(s, near >> 14, &qbh, "aib"))) goto uls;

	} else {
@@ -85,10 +82,6 @@ static secno alloc_in_bmp(struct super_block *s, secno near, unsigned n, unsigne 
		ret = bs + nr;

		goto rt;

	}

	/*if (!tstbits(bmp, nr + n, n + forward)) {

		ret = bs + nr + n;

		goto rt;

	}*/

	q = nr + n; b = 0;

	while ((a = tstbits(bmp, q, n + forward)) != 0) {

		q += a;
@@ -105,14 +98,14 @@ static secno alloc_in_bmp(struct super_block *s, secno near, unsigned n, unsigne 
		goto rt;

	}

	nr >>= 5;

	/*for (i = nr + 1; i != nr; i++, i &= 0x1ff) {*/

	/*for (i = nr + 1; i != nr; i++, i &= 0x1ff) */

	i = nr;

	do {

		if (!bmp[i]) goto cont;

		if (n + forward >= 0x3f && bmp[i] != -1) goto cont;

		if (!le32_to_cpu(bmp[i])) goto cont;

		if (n + forward >= 0x3f && le32_to_cpu(bmp[i]) != 0xffffffff) goto cont;

		q = i<<5;

		if (i > 0) {

			unsigned k = bmp[i-1];

			unsigned k = le32_to_cpu(bmp[i-1]);

			while (k & 0x80000000) {

				q--; k <<= 1;

			}
@@ -132,18 +125,17 @@ static secno alloc_in_bmp(struct super_block *s, secno near, unsigned n, unsigne 
	} while (i != nr);

	rt:

	if (ret) {

		if (hpfs_sb(s)->sb_chk && ((ret >> 14) != (bs >> 14) || (bmp[(ret & 0x3fff) >> 5] | ~(((1 << n) - 1) << (ret & 0x1f))) != 0xffffffff)) {

		if (hpfs_sb(s)->sb_chk && ((ret >> 14) != (bs >> 14) || (le32_to_cpu(bmp[(ret & 0x3fff) >> 5]) | ~(((1 << n) - 1) << (ret & 0x1f))) != 0xffffffff)) {

			hpfs_error(s, "Allocation doesn't work! Wanted %d, allocated at %08x", n, ret);

			ret = 0;

			goto b;

		}

		bmp[(ret & 0x3fff) >> 5] &= ~(((1 << n) - 1) << (ret & 0x1f));

		bmp[(ret & 0x3fff) >> 5] &= cpu_to_le32(~(((1 << n) - 1) << (ret & 0x1f)));

		hpfs_mark_4buffers_dirty(&qbh);

	}

	b:

	hpfs_brelse4(&qbh);

	uls:

	unlock_super(s);

	return ret;

}
@@ -155,7 +147,7 @@ static secno alloc_in_bmp(struct super_block *s, secno near, unsigned n, unsigne 
 *				sectors

 */



secno hpfs_alloc_sector(struct super_block *s, secno near, unsigned n, int forward, int lock)

secno hpfs_alloc_sector(struct super_block *s, secno near, unsigned n, int forward)

{

	secno sec;

	int i;
@@ -167,7 +159,6 @@ secno hpfs_alloc_sector(struct super_block *s, secno near, unsigned n, int forwa 
		forward = -forward;

		f_p = 1;

	}

	if (lock) hpfs_lock_creation(s);

	n_bmps = (sbi->sb_fs_size + 0x4000 - 1) >> 14;

	if (near && near < sbi->sb_fs_size) {

		if ((sec = alloc_in_bmp(s, near, n, f_p ? forward : forward/4))) goto ret;
@@ -214,18 +205,17 @@ secno hpfs_alloc_sector(struct super_block *s, secno near, unsigned n, int forwa 
	ret:

	if (sec && f_p) {

		for (i = 0; i < forward; i++) {

			if (!hpfs_alloc_if_possible_nolock(s, sec + i + 1)) {

			if (!hpfs_alloc_if_possible(s, sec + i + 1)) {

				hpfs_error(s, "Prealloc doesn't work! Wanted %d, allocated at %08x, can't allocate %d", forward, sec, i);

				sec = 0;

				break;

			}

		}

	}

	if (lock) hpfs_unlock_creation(s);

	return sec;

}



static secno alloc_in_dirband(struct super_block *s, secno near, int lock)

static secno alloc_in_dirband(struct super_block *s, secno near)

{

	unsigned nr = near;

	secno sec;
@@ -236,49 +226,35 @@ static secno alloc_in_dirband(struct super_block *s, secno near, int lock) 
		nr = sbi->sb_dirband_start + sbi->sb_dirband_size - 4;

	nr -= sbi->sb_dirband_start;

	nr >>= 2;

	if (lock) hpfs_lock_creation(s);

	sec = alloc_in_bmp(s, (~0x3fff) | nr, 1, 0);

	if (lock) hpfs_unlock_creation(s);

	if (!sec) return 0;

	return ((sec & 0x3fff) << 2) + sbi->sb_dirband_start;

}



/* Alloc sector if it's free */



static int hpfs_alloc_if_possible_nolock(struct super_block *s, secno sec)

int hpfs_alloc_if_possible(struct super_block *s, secno sec)

{

	struct quad_buffer_head qbh;

	unsigned *bmp;

	lock_super(s);

	u32 *bmp;

	if (!(bmp = hpfs_map_bitmap(s, sec >> 14, &qbh, "aip"))) goto end;

	if (bmp[(sec & 0x3fff) >> 5] & (1 << (sec & 0x1f))) {

		bmp[(sec & 0x3fff) >> 5] &= ~(1 << (sec & 0x1f));

	if (le32_to_cpu(bmp[(sec & 0x3fff) >> 5]) & (1 << (sec & 0x1f))) {

		bmp[(sec & 0x3fff) >> 5] &= cpu_to_le32(~(1 << (sec & 0x1f)));

		hpfs_mark_4buffers_dirty(&qbh);

		hpfs_brelse4(&qbh);

		unlock_super(s);

		return 1;

	}

	hpfs_brelse4(&qbh);

	end:

	unlock_super(s);

	return 0;

}



int hpfs_alloc_if_possible(struct super_block *s, secno sec)

{

	int r;

	hpfs_lock_creation(s);

	r = hpfs_alloc_if_possible_nolock(s, sec);

	hpfs_unlock_creation(s);

	return r;

}



/* Free sectors in bitmaps */



void hpfs_free_sectors(struct super_block *s, secno sec, unsigned n)

{

	struct quad_buffer_head qbh;

	unsigned *bmp;

	u32 *bmp;

	struct hpfs_sb_info *sbi = hpfs_sb(s);

	/*printk("2 - ");*/

	if (!n) return;
@@ -286,26 +262,22 @@ void hpfs_free_sectors(struct super_block *s, secno sec, unsigned n) 
		hpfs_error(s, "Trying to free reserved sector %08x", sec);

		return;

	}

	lock_super(s);

	sbi->sb_max_fwd_alloc += n > 0xffff ? 0xffff : n;

	if (sbi->sb_max_fwd_alloc > 0xffffff) sbi->sb_max_fwd_alloc = 0xffffff;

	new_map:

	if (!(bmp = hpfs_map_bitmap(s, sec >> 14, &qbh, "free"))) {

		unlock_super(s);

		return;

	}	

	new_tst:

	if ((bmp[(sec & 0x3fff) >> 5] >> (sec & 0x1f) & 1)) {

	if ((le32_to_cpu(bmp[(sec & 0x3fff) >> 5]) >> (sec & 0x1f) & 1)) {

		hpfs_error(s, "sector %08x not allocated", sec);

		hpfs_brelse4(&qbh);

		unlock_super(s);

		return;

	}

	bmp[(sec & 0x3fff) >> 5] |= 1 << (sec & 0x1f);

	bmp[(sec & 0x3fff) >> 5] |= cpu_to_le32(1 << (sec & 0x1f));

	if (!--n) {

		hpfs_mark_4buffers_dirty(&qbh);

		hpfs_brelse4(&qbh);

		unlock_super(s);

		return;

	}	

	if (!(++sec & 0x3fff)) {
@@ -327,13 +299,13 @@ int hpfs_check_free_dnodes(struct super_block *s, int n) 
	int n_bmps = (hpfs_sb(s)->sb_fs_size + 0x4000 - 1) >> 14;

	int b = hpfs_sb(s)->sb_c_bitmap & 0x0fffffff;

	int i, j;

	unsigned *bmp;

	u32 *bmp;

	struct quad_buffer_head qbh;

	if ((bmp = hpfs_map_dnode_bitmap(s, &qbh))) {

		for (j = 0; j < 512; j++) {

			unsigned k;

			if (!bmp[j]) continue;

			for (k = bmp[j]; k; k >>= 1) if (k & 1) if (!--n) {

			if (!le32_to_cpu(bmp[j])) continue;

			for (k = le32_to_cpu(bmp[j]); k; k >>= 1) if (k & 1) if (!--n) {

				hpfs_brelse4(&qbh);

				return 0;

			}
@@ -352,10 +324,10 @@ int hpfs_check_free_dnodes(struct super_block *s, int n) 
	chk_bmp:

	if (bmp) {

		for (j = 0; j < 512; j++) {

			unsigned k;

			if (!bmp[j]) continue;

			u32 k;

			if (!le32_to_cpu(bmp[j])) continue;

			for (k = 0xf; k; k <<= 4)

				if ((bmp[j] & k) == k) {

				if ((le32_to_cpu(bmp[j]) & k) == k) {

					if (!--n) {

						hpfs_brelse4(&qbh);

						return 0;
@@ -379,44 +351,40 @@ void hpfs_free_dnode(struct super_block *s, dnode_secno dno) 
		hpfs_free_sectors(s, dno, 4);

	} else {

		struct quad_buffer_head qbh;

		unsigned *bmp;

		u32 *bmp;

		unsigned ssec = (dno - hpfs_sb(s)->sb_dirband_start) / 4;

		lock_super(s);

		if (!(bmp = hpfs_map_dnode_bitmap(s, &qbh))) {

			unlock_super(s);

			return;

		}

		bmp[ssec >> 5] |= 1 << (ssec & 0x1f);

		bmp[ssec >> 5] |= cpu_to_le32(1 << (ssec & 0x1f));

		hpfs_mark_4buffers_dirty(&qbh);

		hpfs_brelse4(&qbh);

		unlock_super(s);

	}

}



struct dnode *hpfs_alloc_dnode(struct super_block *s, secno near,

			 dnode_secno *dno, struct quad_buffer_head *qbh,

			 int lock)

			 dnode_secno *dno, struct quad_buffer_head *qbh)

{

	struct dnode *d;

	if (hpfs_count_one_bitmap(s, hpfs_sb(s)->sb_dmap) > FREE_DNODES_ADD) {

		if (!(*dno = alloc_in_dirband(s, near, lock)))

			if (!(*dno = hpfs_alloc_sector(s, near, 4, 0, lock))) return NULL;

		if (!(*dno = alloc_in_dirband(s, near)))

			if (!(*dno = hpfs_alloc_sector(s, near, 4, 0))) return NULL;

	} else {

		if (!(*dno = hpfs_alloc_sector(s, near, 4, 0, lock)))

			if (!(*dno = alloc_in_dirband(s, near, lock))) return NULL;

		if (!(*dno = hpfs_alloc_sector(s, near, 4, 0)))

			if (!(*dno = alloc_in_dirband(s, near))) return NULL;

	}

	if (!(d = hpfs_get_4sectors(s, *dno, qbh))) {

		hpfs_free_dnode(s, *dno);

		return NULL;

	}

	memset(d, 0, 2048);

	d->magic = DNODE_MAGIC;

	d->first_free = 52;

	d->magic = cpu_to_le32(DNODE_MAGIC);

	d->first_free = cpu_to_le32(52);

	d->dirent[0] = 32;

	d->dirent[2] = 8;

	d->dirent[30] = 1;

	d->dirent[31] = 255;

	d->self = *dno;

	d->self = cpu_to_le32(*dno);

	return d;

}
@@ -424,16 +392,16 @@ struct fnode *hpfs_alloc_fnode(struct super_block *s, secno near, fnode_secno *f 
			  struct buffer_head **bh)

{

	struct fnode *f;

	if (!(*fno = hpfs_alloc_sector(s, near, 1, FNODE_ALLOC_FWD, 1))) return NULL;

	if (!(*fno = hpfs_alloc_sector(s, near, 1, FNODE_ALLOC_FWD))) return NULL;

	if (!(f = hpfs_get_sector(s, *fno, bh))) {

		hpfs_free_sectors(s, *fno, 1);

		return NULL;

	}	

	memset(f, 0, 512);

	f->magic = FNODE_MAGIC;

	f->ea_offs = 0xc4;

	f->magic = cpu_to_le32(FNODE_MAGIC);

	f->ea_offs = cpu_to_le16(0xc4);

	f->btree.n_free_nodes = 8;

	f->btree.first_free = 8;

	f->btree.first_free = cpu_to_le16(8);

	return f;

}
@@ -441,16 +409,16 @@ struct anode *hpfs_alloc_anode(struct super_block *s, secno near, anode_secno *a 
			  struct buffer_head **bh)

{

	struct anode *a;

	if (!(*ano = hpfs_alloc_sector(s, near, 1, ANODE_ALLOC_FWD, 1))) return NULL;

	if (!(*ano = hpfs_alloc_sector(s, near, 1, ANODE_ALLOC_FWD))) return NULL;

	if (!(a = hpfs_get_sector(s, *ano, bh))) {

		hpfs_free_sectors(s, *ano, 1);

		return NULL;

	}

	memset(a, 0, 512);

	a->magic = ANODE_MAGIC;

	a->self = *ano;

	a->magic = cpu_to_le32(ANODE_MAGIC);

	a->self = cpu_to_le32(*ano);

	a->btree.n_free_nodes = 40;

	a->btree.n_used_nodes = 0;

	a->btree.first_free = 8;

	a->btree.first_free = cpu_to_le16(8);

	return a;

}

fs/hpfs/anode.c

+69 −69
Original line number Diff line number Diff line
@@ -22,8 +22,8 @@ secno hpfs_bplus_lookup(struct super_block *s, struct inode *inode, 
	if (hpfs_sb(s)->sb_chk) if (hpfs_stop_cycles(s, a, &c1, &c2, "hpfs_bplus_lookup")) return -1;

	if (btree->internal) {

		for (i = 0; i < btree->n_used_nodes; i++)

			if (btree->u.internal[i].file_secno > sec) {

				a = btree->u.internal[i].down;

			if (le32_to_cpu(btree->u.internal[i].file_secno) > sec) {

				a = le32_to_cpu(btree->u.internal[i].down);

				brelse(bh);

				if (!(anode = hpfs_map_anode(s, a, &bh))) return -1;

				btree = &anode->btree;
@@ -34,18 +34,18 @@ secno hpfs_bplus_lookup(struct super_block *s, struct inode *inode, 
		return -1;

	}

	for (i = 0; i < btree->n_used_nodes; i++)

		if (btree->u.external[i].file_secno <= sec &&

		    btree->u.external[i].file_secno + btree->u.external[i].length > sec) {

			a = btree->u.external[i].disk_secno + sec - btree->u.external[i].file_secno;

		if (le32_to_cpu(btree->u.external[i].file_secno) <= sec &&

		    le32_to_cpu(btree->u.external[i].file_secno) + le32_to_cpu(btree->u.external[i].length) > sec) {

			a = le32_to_cpu(btree->u.external[i].disk_secno) + sec - le32_to_cpu(btree->u.external[i].file_secno);

			if (hpfs_sb(s)->sb_chk) if (hpfs_chk_sectors(s, a, 1, "data")) {

				brelse(bh);

				return -1;

			}

			if (inode) {

				struct hpfs_inode_info *hpfs_inode = hpfs_i(inode);

				hpfs_inode->i_file_sec = btree->u.external[i].file_secno;

				hpfs_inode->i_disk_sec = btree->u.external[i].disk_secno;

				hpfs_inode->i_n_secs = btree->u.external[i].length;

				hpfs_inode->i_file_sec = le32_to_cpu(btree->u.external[i].file_secno);

				hpfs_inode->i_disk_sec = le32_to_cpu(btree->u.external[i].disk_secno);

				hpfs_inode->i_n_secs = le32_to_cpu(btree->u.external[i].length);

			}

			brelse(bh);

			return a;
@@ -83,8 +83,8 @@ secno hpfs_add_sector_to_btree(struct super_block *s, secno node, int fnod, unsi 
		return -1;

	}

	if (btree->internal) {

		a = btree->u.internal[n].down;

		btree->u.internal[n].file_secno = -1;

		a = le32_to_cpu(btree->u.internal[n].down);

		btree->u.internal[n].file_secno = cpu_to_le32(-1);

		mark_buffer_dirty(bh);

		brelse(bh);

		if (hpfs_sb(s)->sb_chk)
@@ -94,15 +94,15 @@ secno hpfs_add_sector_to_btree(struct super_block *s, secno node, int fnod, unsi 
		goto go_down;

	}

	if (n >= 0) {

		if (btree->u.external[n].file_secno + btree->u.external[n].length != fsecno) {

		if (le32_to_cpu(btree->u.external[n].file_secno) + le32_to_cpu(btree->u.external[n].length) != fsecno) {

			hpfs_error(s, "allocated size %08x, trying to add sector %08x, %cnode %08x",

				btree->u.external[n].file_secno + btree->u.external[n].length, fsecno,

				le32_to_cpu(btree->u.external[n].file_secno) + le32_to_cpu(btree->u.external[n].length), fsecno,

				fnod?'f':'a', node);

			brelse(bh);

			return -1;

		}

		if (hpfs_alloc_if_possible(s, se = btree->u.external[n].disk_secno + btree->u.external[n].length)) {

			btree->u.external[n].length++;

		if (hpfs_alloc_if_possible(s, se = le32_to_cpu(btree->u.external[n].disk_secno) + le32_to_cpu(btree->u.external[n].length))) {

			btree->u.external[n].length = cpu_to_le32(le32_to_cpu(btree->u.external[n].length) + 1);

			mark_buffer_dirty(bh);

			brelse(bh);

			return se;
@@ -115,20 +115,20 @@ secno hpfs_add_sector_to_btree(struct super_block *s, secno node, int fnod, unsi 
		}

		se = !fnod ? node : (node + 16384) & ~16383;

	}	

	if (!(se = hpfs_alloc_sector(s, se, 1, fsecno*ALLOC_M>ALLOC_FWD_MAX ? ALLOC_FWD_MAX : fsecno*ALLOC_M<ALLOC_FWD_MIN ? ALLOC_FWD_MIN : fsecno*ALLOC_M, 1))) {

	if (!(se = hpfs_alloc_sector(s, se, 1, fsecno*ALLOC_M>ALLOC_FWD_MAX ? ALLOC_FWD_MAX : fsecno*ALLOC_M<ALLOC_FWD_MIN ? ALLOC_FWD_MIN : fsecno*ALLOC_M))) {

		brelse(bh);

		return -1;

	}

	fs = n < 0 ? 0 : btree->u.external[n].file_secno + btree->u.external[n].length;

	fs = n < 0 ? 0 : le32_to_cpu(btree->u.external[n].file_secno) + le32_to_cpu(btree->u.external[n].length);

	if (!btree->n_free_nodes) {

		up = a != node ? anode->up : -1;

		up = a != node ? le32_to_cpu(anode->up) : -1;

		if (!(anode = hpfs_alloc_anode(s, a, &na, &bh1))) {

			brelse(bh);

			hpfs_free_sectors(s, se, 1);

			return -1;

		}

		if (a == node && fnod) {

			anode->up = node;

			anode->up = cpu_to_le32(node);

			anode->btree.fnode_parent = 1;

			anode->btree.n_used_nodes = btree->n_used_nodes;

			anode->btree.first_free = btree->first_free;
@@ -137,9 +137,9 @@ secno hpfs_add_sector_to_btree(struct super_block *s, secno node, int fnod, unsi 
			btree->internal = 1;

			btree->n_free_nodes = 11;

			btree->n_used_nodes = 1;

			btree->first_free = (char *)&(btree->u.internal[1]) - (char *)btree;

			btree->u.internal[0].file_secno = -1;

			btree->u.internal[0].down = na;

			btree->first_free = cpu_to_le16((char *)&(btree->u.internal[1]) - (char *)btree);

			btree->u.internal[0].file_secno = cpu_to_le32(-1);

			btree->u.internal[0].down = cpu_to_le32(na);

			mark_buffer_dirty(bh);

		} else if (!(ranode = hpfs_alloc_anode(s, /*a*/0, &ra, &bh2))) {

			brelse(bh);
@@ -153,15 +153,15 @@ secno hpfs_add_sector_to_btree(struct super_block *s, secno node, int fnod, unsi 
		btree = &anode->btree;

	}

	btree->n_free_nodes--; n = btree->n_used_nodes++;

	btree->first_free += 12;

	btree->u.external[n].disk_secno = se;

	btree->u.external[n].file_secno = fs;

	btree->u.external[n].length = 1;

	btree->first_free = cpu_to_le16(le16_to_cpu(btree->first_free) + 12);

	btree->u.external[n].disk_secno = cpu_to_le32(se);

	btree->u.external[n].file_secno = cpu_to_le32(fs);

	btree->u.external[n].length = cpu_to_le32(1);

	mark_buffer_dirty(bh);

	brelse(bh);

	if ((a == node && fnod) || na == -1) return se;

	c2 = 0;

	while (up != -1) {

	while (up != (anode_secno)-1) {

		struct anode *new_anode;

		if (hpfs_sb(s)->sb_chk)

			if (hpfs_stop_cycles(s, up, &c1, &c2, "hpfs_add_sector_to_btree #2")) return -1;
@@ -174,47 +174,47 @@ secno hpfs_add_sector_to_btree(struct super_block *s, secno node, int fnod, unsi 
		}

		if (btree->n_free_nodes) {

			btree->n_free_nodes--; n = btree->n_used_nodes++;

			btree->first_free += 8;

			btree->u.internal[n].file_secno = -1;

			btree->u.internal[n].down = na;

			btree->u.internal[n-1].file_secno = fs;

			btree->first_free = cpu_to_le16(le16_to_cpu(btree->first_free) + 8);

			btree->u.internal[n].file_secno = cpu_to_le32(-1);

			btree->u.internal[n].down = cpu_to_le32(na);

			btree->u.internal[n-1].file_secno = cpu_to_le32(fs);

			mark_buffer_dirty(bh);

			brelse(bh);

			brelse(bh2);

			hpfs_free_sectors(s, ra, 1);

			if ((anode = hpfs_map_anode(s, na, &bh))) {

				anode->up = up;

				anode->up = cpu_to_le32(up);

				anode->btree.fnode_parent = up == node && fnod;

				mark_buffer_dirty(bh);

				brelse(bh);

			}

			return se;

		}

		up = up != node ? anode->up : -1;

		btree->u.internal[btree->n_used_nodes - 1].file_secno = /*fs*/-1;

		up = up != node ? le32_to_cpu(anode->up) : -1;

		btree->u.internal[btree->n_used_nodes - 1].file_secno = cpu_to_le32(/*fs*/-1);

		mark_buffer_dirty(bh);

		brelse(bh);

		a = na;

		if ((new_anode = hpfs_alloc_anode(s, a, &na, &bh))) {

			anode = new_anode;

			/*anode->up = up != -1 ? up : ra;*/

			/*anode->up = cpu_to_le32(up != -1 ? up : ra);*/

			anode->btree.internal = 1;

			anode->btree.n_used_nodes = 1;

			anode->btree.n_free_nodes = 59;

			anode->btree.first_free = 16;

			anode->btree.u.internal[0].down = a;

			anode->btree.u.internal[0].file_secno = -1;

			anode->btree.first_free = cpu_to_le16(16);

			anode->btree.u.internal[0].down = cpu_to_le32(a);

			anode->btree.u.internal[0].file_secno = cpu_to_le32(-1);

			mark_buffer_dirty(bh);

			brelse(bh);

			if ((anode = hpfs_map_anode(s, a, &bh))) {

				anode->up = na;

				anode->up = cpu_to_le32(na);

				mark_buffer_dirty(bh);

				brelse(bh);

			}

		} else na = a;

	}

	if ((anode = hpfs_map_anode(s, na, &bh))) {

		anode->up = node;

		anode->up = cpu_to_le32(node);

		if (fnod) anode->btree.fnode_parent = 1;

		mark_buffer_dirty(bh);

		brelse(bh);
@@ -232,14 +232,14 @@ secno hpfs_add_sector_to_btree(struct super_block *s, secno node, int fnod, unsi 
		}

		btree = &fnode->btree;

	}

	ranode->up = node;

	memcpy(&ranode->btree, btree, btree->first_free);

	ranode->up = cpu_to_le32(node);

	memcpy(&ranode->btree, btree, le16_to_cpu(btree->first_free));

	if (fnod) ranode->btree.fnode_parent = 1;

	ranode->btree.n_free_nodes = (ranode->btree.internal ? 60 : 40) - ranode->btree.n_used_nodes;

	if (ranode->btree.internal) for (n = 0; n < ranode->btree.n_used_nodes; n++) {

		struct anode *unode;

		if ((unode = hpfs_map_anode(s, ranode->u.internal[n].down, &bh1))) {

			unode->up = ra;

		if ((unode = hpfs_map_anode(s, le32_to_cpu(ranode->u.internal[n].down), &bh1))) {

			unode->up = cpu_to_le32(ra);

			unode->btree.fnode_parent = 0;

			mark_buffer_dirty(bh1);

			brelse(bh1);
@@ -248,11 +248,11 @@ secno hpfs_add_sector_to_btree(struct super_block *s, secno node, int fnod, unsi 
	btree->internal = 1;

	btree->n_free_nodes = fnod ? 10 : 58;

	btree->n_used_nodes = 2;

	btree->first_free = (char *)&btree->u.internal[2] - (char *)btree;

	btree->u.internal[0].file_secno = fs;

	btree->u.internal[0].down = ra;

	btree->u.internal[1].file_secno = -1;

	btree->u.internal[1].down = na;

	btree->first_free = cpu_to_le16((char *)&btree->u.internal[2] - (char *)btree);

	btree->u.internal[0].file_secno = cpu_to_le32(fs);

	btree->u.internal[0].down = cpu_to_le32(ra);

	btree->u.internal[1].file_secno = cpu_to_le32(-1);

	btree->u.internal[1].down = cpu_to_le32(na);

	mark_buffer_dirty(bh);

	brelse(bh);

	mark_buffer_dirty(bh2);
@@ -279,7 +279,7 @@ void hpfs_remove_btree(struct super_block *s, struct bplus_header *btree) 
	go_down:

	d2 = 0;

	while (btree1->internal) {

		ano = btree1->u.internal[pos].down;

		ano = le32_to_cpu(btree1->u.internal[pos].down);

		if (level) brelse(bh);

		if (hpfs_sb(s)->sb_chk)

			if (hpfs_stop_cycles(s, ano, &d1, &d2, "hpfs_remove_btree #1"))
@@ -290,7 +290,7 @@ void hpfs_remove_btree(struct super_block *s, struct bplus_header *btree) 
		pos = 0;

	}

	for (i = 0; i < btree1->n_used_nodes; i++)

		hpfs_free_sectors(s, btree1->u.external[i].disk_secno, btree1->u.external[i].length);

		hpfs_free_sectors(s, le32_to_cpu(btree1->u.external[i].disk_secno), le32_to_cpu(btree1->u.external[i].length));

	go_up:

	if (!level) return;

	brelse(bh);
@@ -298,13 +298,13 @@ void hpfs_remove_btree(struct super_block *s, struct bplus_header *btree) 
		if (hpfs_stop_cycles(s, ano, &c1, &c2, "hpfs_remove_btree #2")) return;

	hpfs_free_sectors(s, ano, 1);

	oano = ano;

	ano = anode->up;

	ano = le32_to_cpu(anode->up);

	if (--level) {

		if (!(anode = hpfs_map_anode(s, ano, &bh))) return;

		btree1 = &anode->btree;

	} else btree1 = btree;

	for (i = 0; i < btree1->n_used_nodes; i++) {

		if (btree1->u.internal[i].down == oano) {

		if (le32_to_cpu(btree1->u.internal[i].down) == oano) {

			if ((pos = i + 1) < btree1->n_used_nodes)

				goto go_down;

			else
@@ -411,7 +411,7 @@ void hpfs_truncate_btree(struct super_block *s, secno f, int fno, unsigned secs) 
		if (fno) {

			btree->n_free_nodes = 8;

			btree->n_used_nodes = 0;

			btree->first_free = 8;

			btree->first_free = cpu_to_le16(8);

			btree->internal = 0;

			mark_buffer_dirty(bh);

		} else hpfs_free_sectors(s, f, 1);
@@ -421,22 +421,22 @@ void hpfs_truncate_btree(struct super_block *s, secno f, int fno, unsigned secs) 
	while (btree->internal) {

		nodes = btree->n_used_nodes + btree->n_free_nodes;

		for (i = 0; i < btree->n_used_nodes; i++)

			if (btree->u.internal[i].file_secno >= secs) goto f;

			if (le32_to_cpu(btree->u.internal[i].file_secno) >= secs) goto f;

		brelse(bh);

		hpfs_error(s, "internal btree %08x doesn't end with -1", node);

		return;

		f:

		for (j = i + 1; j < btree->n_used_nodes; j++)

			hpfs_ea_remove(s, btree->u.internal[j].down, 1, 0);

			hpfs_ea_remove(s, le32_to_cpu(btree->u.internal[j].down), 1, 0);

		btree->n_used_nodes = i + 1;

		btree->n_free_nodes = nodes - btree->n_used_nodes;

		btree->first_free = 8 + 8 * btree->n_used_nodes;

		btree->first_free = cpu_to_le16(8 + 8 * btree->n_used_nodes);

		mark_buffer_dirty(bh);

		if (btree->u.internal[i].file_secno == secs) {

		if (btree->u.internal[i].file_secno == cpu_to_le32(secs)) {

			brelse(bh);

			return;

		}

		node = btree->u.internal[i].down;

		node = le32_to_cpu(btree->u.internal[i].down);

		brelse(bh);

		if (hpfs_sb(s)->sb_chk)

			if (hpfs_stop_cycles(s, node, &c1, &c2, "hpfs_truncate_btree"))
@@ -446,25 +446,25 @@ void hpfs_truncate_btree(struct super_block *s, secno f, int fno, unsigned secs) 
	}	

	nodes = btree->n_used_nodes + btree->n_free_nodes;

	for (i = 0; i < btree->n_used_nodes; i++)

		if (btree->u.external[i].file_secno + btree->u.external[i].length >= secs) goto ff;

		if (le32_to_cpu(btree->u.external[i].file_secno) + le32_to_cpu(btree->u.external[i].length) >= secs) goto ff;

	brelse(bh);

	return;

	ff:

	if (secs <= btree->u.external[i].file_secno) {

	if (secs <= le32_to_cpu(btree->u.external[i].file_secno)) {

		hpfs_error(s, "there is an allocation error in file %08x, sector %08x", f, secs);

		if (i) i--;

	}

	else if (btree->u.external[i].file_secno + btree->u.external[i].length > secs) {

		hpfs_free_sectors(s, btree->u.external[i].disk_secno + secs -

			btree->u.external[i].file_secno, btree->u.external[i].length

			- secs + btree->u.external[i].file_secno); /* I hope gcc optimizes this :-) */

		btree->u.external[i].length = secs - btree->u.external[i].file_secno;

	else if (le32_to_cpu(btree->u.external[i].file_secno) + le32_to_cpu(btree->u.external[i].length) > secs) {

		hpfs_free_sectors(s, le32_to_cpu(btree->u.external[i].disk_secno) + secs -

			le32_to_cpu(btree->u.external[i].file_secno), le32_to_cpu(btree->u.external[i].length)

			- secs + le32_to_cpu(btree->u.external[i].file_secno)); /* I hope gcc optimizes this :-) */

		btree->u.external[i].length = cpu_to_le32(secs - le32_to_cpu(btree->u.external[i].file_secno));

	}

	for (j = i + 1; j < btree->n_used_nodes; j++)

		hpfs_free_sectors(s, btree->u.external[j].disk_secno, btree->u.external[j].length);

		hpfs_free_sectors(s, le32_to_cpu(btree->u.external[j].disk_secno), le32_to_cpu(btree->u.external[j].length));

	btree->n_used_nodes = i + 1;

	btree->n_free_nodes = nodes - btree->n_used_nodes;

	btree->first_free = 8 + 12 * btree->n_used_nodes;

	btree->first_free = cpu_to_le16(8 + 12 * btree->n_used_nodes);

	mark_buffer_dirty(bh);

	brelse(bh);

}
@@ -480,12 +480,12 @@ void hpfs_remove_fnode(struct super_block *s, fnode_secno fno) 
	struct extended_attribute *ea_end;

	if (!(fnode = hpfs_map_fnode(s, fno, &bh))) return;

	if (!fnode->dirflag) hpfs_remove_btree(s, &fnode->btree);

	else hpfs_remove_dtree(s, fnode->u.external[0].disk_secno);

	else hpfs_remove_dtree(s, le32_to_cpu(fnode->u.external[0].disk_secno));

	ea_end = fnode_end_ea(fnode);

	for (ea = fnode_ea(fnode); ea < ea_end; ea = next_ea(ea))

		if (ea->indirect)

			hpfs_ea_remove(s, ea_sec(ea), ea->anode, ea_len(ea));

	hpfs_ea_ext_remove(s, fnode->ea_secno, fnode->ea_anode, fnode->ea_size_l);

	hpfs_ea_ext_remove(s, le32_to_cpu(fnode->ea_secno), fnode->ea_anode, le32_to_cpu(fnode->ea_size_l));

	brelse(bh);

	hpfs_free_sectors(s, fno, 1);

}

fs/hpfs/buffer.c

+8 −16
Original line number Diff line number Diff line
@@ -9,22 +9,6 @@ 
#include <linux/slab.h>

#include "hpfs_fn.h"



void hpfs_lock_creation(struct super_block *s)

{

#ifdef DEBUG_LOCKS

	printk("lock creation\n");

#endif

	mutex_lock(&hpfs_sb(s)->hpfs_creation_de);

}



void hpfs_unlock_creation(struct super_block *s)

{

#ifdef DEBUG_LOCKS

	printk("unlock creation\n");

#endif

	mutex_unlock(&hpfs_sb(s)->hpfs_creation_de);

}



/* Map a sector into a buffer and return pointers to it and to the buffer. */



void *hpfs_map_sector(struct super_block *s, unsigned secno, struct buffer_head **bhp,
@@ -32,6 +16,8 @@ void *hpfs_map_sector(struct super_block *s, unsigned secno, struct buffer_head 
{

	struct buffer_head *bh;



	hpfs_lock_assert(s);



	cond_resched();



	*bhp = bh = sb_bread(s, secno);
@@ -50,6 +36,8 @@ void *hpfs_get_sector(struct super_block *s, unsigned secno, struct buffer_head 
	struct buffer_head *bh;

	/*return hpfs_map_sector(s, secno, bhp, 0);*/



	hpfs_lock_assert(s);



	cond_resched();



	if ((*bhp = bh = sb_getblk(s, secno)) != NULL) {
@@ -70,6 +58,8 @@ void *hpfs_map_4sectors(struct super_block *s, unsigned secno, struct quad_buffe 
	struct buffer_head *bh;

	char *data;



	hpfs_lock_assert(s);



	cond_resched();



	if (secno & 3) {
@@ -125,6 +115,8 @@ void *hpfs_get_4sectors(struct super_block *s, unsigned secno, 
{

	cond_resched();



	hpfs_lock_assert(s);



	if (secno & 3) {

		printk("HPFS: hpfs_get_4sectors: unaligned read\n");

		return NULL;

fs/hpfs/dir.c

+10 −12

File changed.

Preview size limit exceeded, changes collapsed.

CRA Git | Maintained and supported by SUSTech CRA and CCSE