1 files changed, 43 insertions, 75 deletions

diff --git a/fs/hpfs/alloc.c b/fs/hpfs/alloc.c
index 5503e2c28910..7a5eb2c718c8 100644
--- a/fs/hpfs/alloc.c
+++ b/fs/hpfs/alloc.c
@@ -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;
 }