lkml.org 
[lkml]   [2001]   [Oct]   [29]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
Patch in this message
/
Date
From
Subject[PATCH] ufs byteswapping cleanup
Hi Linus,

the appended patch cleans up ufs to use sane inlines
for byteswapping instead of the current macros that
use variables from the enviroment (yuck!).

Older version already was in -ac.

Please apply,

Christoph

--
Of course it doesn't work. We've performed a software upgrade.

diff -uNr -Xdontdiff ../master/linux-2.4.14-pre3/fs/ufs/balloc.c linux/fs/ufs/balloc.c
--- ../master/linux-2.4.14-pre3/fs/ufs/balloc.c Wed Oct 10 10:34:16 2001
+++ linux/fs/ufs/balloc.c Mon Oct 29 16:46:54 2001
@@ -44,11 +44,9 @@
struct ufs_cg_private_info * ucpi;
struct ufs_cylinder_group * ucg;
unsigned cgno, bit, end_bit, bbase, blkmap, i, blkno, cylno;
- unsigned swab;

sb = inode->i_sb;
uspi = sb->u.ufs_sb.s_uspi;
- swab = sb->u.ufs_sb.s_swab;
usb1 = ubh_get_usb_first(USPI_UBH);

UFSD(("ENTER, fragment %u, count %u\n", fragment, count))
@@ -69,7 +67,7 @@
if (!ucpi)
goto failed;
ucg = ubh_get_ucg (UCPI_UBH);
- if (!ufs_cg_chkmagic (ucg)) {
+ if (!ufs_cg_chkmagic(sb, ucg)) {
ufs_panic (sb, "ufs_free_fragments", "internal error, bad magic number on cg %u", cgno);
goto failed;
}
@@ -86,9 +84,11 @@
}

DQUOT_FREE_BLOCK (inode, count);
- ADD_SWAB32(ucg->cg_cs.cs_nffree, count);
- ADD_SWAB32(usb1->fs_cstotal.cs_nffree, count);
- ADD_SWAB32(sb->fs_cs(cgno).cs_nffree, count);
+
+
+ fs32_add(sb, &ucg->cg_cs.cs_nffree, count);
+ fs32_add(sb, &usb1->fs_cstotal.cs_nffree, count);
+ fs32_add(sb, &sb->fs_cs(cgno).cs_nffree, count);
blkmap = ubh_blkmap (UCPI_UBH, ucpi->c_freeoff, bbase);
ufs_fragacct(sb, blkmap, ucg->cg_frsum, 1);

@@ -97,17 +97,17 @@
*/
blkno = ufs_fragstoblks (bbase);
if (ubh_isblockset(UCPI_UBH, ucpi->c_freeoff, blkno)) {
- SUB_SWAB32(ucg->cg_cs.cs_nffree, uspi->s_fpb);
- SUB_SWAB32(usb1->fs_cstotal.cs_nffree, uspi->s_fpb);
- SUB_SWAB32(sb->fs_cs(cgno).cs_nffree, uspi->s_fpb);
+ fs32_sub(sb, &ucg->cg_cs.cs_nffree, uspi->s_fpb);
+ fs32_sub(sb, &usb1->fs_cstotal.cs_nffree, uspi->s_fpb);
+ fs32_sub(sb, &sb->fs_cs(cgno).cs_nffree, uspi->s_fpb);
if ((sb->u.ufs_sb.s_flags & UFS_CG_MASK) == UFS_CG_44BSD)
ufs_clusteracct (sb, ucpi, blkno, 1);
- INC_SWAB32(ucg->cg_cs.cs_nbfree);
- INC_SWAB32(usb1->fs_cstotal.cs_nbfree);
- INC_SWAB32(sb->fs_cs(cgno).cs_nbfree);
+ fs32_add(sb, &ucg->cg_cs.cs_nbfree, 1);
+ fs32_add(sb, &usb1->fs_cstotal.cs_nbfree, 1);
+ fs32_add(sb, &sb->fs_cs(cgno).cs_nbfree, 1);
cylno = ufs_cbtocylno (bbase);
- INC_SWAB16(ubh_cg_blks (ucpi, cylno, ufs_cbtorpos(bbase)));
- INC_SWAB32(ubh_cg_blktot (ucpi, cylno));
+ fs16_add(sb, &ubh_cg_blks(ucpi, cylno, ufs_cbtorpos(bbase)), 1);
+ fs32_add(sb, &ubh_cg_blktot(ucpi, cylno), 1);
}

ubh_mark_buffer_dirty (USPI_UBH);
@@ -138,11 +138,9 @@
struct ufs_cg_private_info * ucpi;
struct ufs_cylinder_group * ucg;
unsigned overflow, cgno, bit, end_bit, blkno, i, cylno;
- unsigned swab;

sb = inode->i_sb;
uspi = sb->u.ufs_sb.s_uspi;
- swab = sb->u.ufs_sb.s_swab;
usb1 = ubh_get_usb_first(USPI_UBH);

UFSD(("ENTER, fragment %u, count %u\n", fragment, count))
@@ -174,7 +172,7 @@
if (!ucpi)
goto failed;
ucg = ubh_get_ucg (UCPI_UBH);
- if (!ufs_cg_chkmagic (ucg)) {
+ if (!ufs_cg_chkmagic(sb, ucg)) {
ufs_panic (sb, "ufs_free_blocks", "internal error, bad magic number on cg %u", cgno);
goto failed;
}
@@ -188,12 +186,13 @@
if ((sb->u.ufs_sb.s_flags & UFS_CG_MASK) == UFS_CG_44BSD)
ufs_clusteracct (sb, ucpi, blkno, 1);
DQUOT_FREE_BLOCK(inode, uspi->s_fpb);
- INC_SWAB32(ucg->cg_cs.cs_nbfree);
- INC_SWAB32(usb1->fs_cstotal.cs_nbfree);
- INC_SWAB32(sb->fs_cs(cgno).cs_nbfree);
+
+ fs32_add(sb, &ucg->cg_cs.cs_nbfree, 1);
+ fs32_add(sb, &usb1->fs_cstotal.cs_nbfree, 1);
+ fs32_add(sb, &sb->fs_cs(cgno).cs_nbfree, 1);
cylno = ufs_cbtocylno(i);
- INC_SWAB16(ubh_cg_blks(ucpi, cylno, ufs_cbtorpos(i)));
- INC_SWAB32(ubh_cg_blktot(ucpi, cylno));
+ fs16_add(sb, &ubh_cg_blks(ucpi, cylno, ufs_cbtorpos(i)), 1);
+ fs32_add(sb, &ubh_cg_blktot(ucpi, cylno), 1);
}

ubh_mark_buffer_dirty (USPI_UBH);
@@ -243,19 +242,17 @@
struct ufs_super_block_first * usb1;
struct buffer_head * bh;
unsigned cgno, oldcount, newcount, tmp, request, i, result;
- unsigned swab;

UFSD(("ENTER, ino %lu, fragment %u, goal %u, count %u\n", inode->i_ino, fragment, goal, count))

sb = inode->i_sb;
- swab = sb->u.ufs_sb.s_swab;
uspi = sb->u.ufs_sb.s_uspi;
usb1 = ubh_get_usb_first(USPI_UBH);
*err = -ENOSPC;

lock_super (sb);

- tmp = SWAB32(*p);
+ tmp = fs32_to_cpu(sb, *p);
if (count + ufs_fragnum(fragment) > uspi->s_fpb) {
ufs_warning (sb, "ufs_new_fragments", "internal warning"
" fragment %u, count %u", fragment, count);
@@ -310,7 +307,7 @@
if (oldcount == 0) {
result = ufs_alloc_fragments (inode, cgno, goal, count, err);
if (result) {
- *p = SWAB32(result);
+ *p = cpu_to_fs32(sb, result);
*err = 0;
inode->i_blocks += count << uspi->s_nspfshift;
inode->u.ufs_i.i_lastfrag = max_t(u32, inode->u.ufs_i.i_lastfrag, fragment + count);
@@ -338,23 +335,23 @@
/*
* allocate new block and move data
*/
- switch (SWAB32(usb1->fs_optim)) {
+ switch (fs32_to_cpu(sb, usb1->fs_optim)) {
case UFS_OPTSPACE:
request = newcount;
- if (uspi->s_minfree < 5 || SWAB32(usb1->fs_cstotal.cs_nffree)
+ if (uspi->s_minfree < 5 || fs32_to_cpu(sb, usb1->fs_cstotal.cs_nffree)
> uspi->s_dsize * uspi->s_minfree / (2 * 100) )
break;
- usb1->fs_optim = SWAB32(UFS_OPTTIME);
+ usb1->fs_optim = cpu_to_fs32(sb, UFS_OPTTIME);
break;
default:
- usb1->fs_optim = SWAB32(UFS_OPTTIME);
+ usb1->fs_optim = cpu_to_fs32(sb, UFS_OPTTIME);

case UFS_OPTTIME:
request = uspi->s_fpb;
- if (SWAB32(usb1->fs_cstotal.cs_nffree) < uspi->s_dsize *
+ if (fs32_to_cpu(sb, usb1->fs_cstotal.cs_nffree) < uspi->s_dsize *
(uspi->s_minfree - 2) / 100)
break;
- usb1->fs_optim = SWAB32(UFS_OPTSPACE);
+ usb1->fs_optim = cpu_to_fs32(sb, UFS_OPTTIME);
break;
}
result = ufs_alloc_fragments (inode, cgno, goal, request, err);
@@ -378,7 +375,7 @@
return 0;
}
}
- *p = SWAB32(result);
+ *p = cpu_to_fs32(sb, result);
*err = 0;
inode->i_blocks += count << uspi->s_nspfshift;
inode->u.ufs_i.i_lastfrag = max_t(u32, inode->u.ufs_i.i_lastfrag, fragment + count);
@@ -405,12 +402,10 @@
struct ufs_cg_private_info * ucpi;
struct ufs_cylinder_group * ucg;
unsigned cgno, fragno, fragoff, count, fragsize, i;
- unsigned swab;

UFSD(("ENTER, fragment %u, oldcount %u, newcount %u\n", fragment, oldcount, newcount))

sb = inode->i_sb;
- swab = sb->u.ufs_sb.s_swab;
uspi = sb->u.ufs_sb.s_uspi;
usb1 = ubh_get_usb_first (USPI_UBH);
count = newcount - oldcount;
@@ -424,7 +419,7 @@
if (!ucpi)
return 0;
ucg = ubh_get_ucg (UCPI_UBH);
- if (!ufs_cg_chkmagic(ucg)) {
+ if (!ufs_cg_chkmagic(sb, ucg)) {
ufs_panic (sb, "ufs_add_fragments",
"internal error, bad magic number on cg %u", cgno);
return 0;
@@ -438,26 +433,27 @@
/*
* Block can be extended
*/
- ucg->cg_time = SWAB32(CURRENT_TIME);
+ ucg->cg_time = cpu_to_fs32(sb, CURRENT_TIME);
for (i = newcount; i < (uspi->s_fpb - fragoff); i++)
if (ubh_isclr (UCPI_UBH, ucpi->c_freeoff, fragno + i))
break;
fragsize = i - oldcount;
- if (!SWAB32(ucg->cg_frsum[fragsize]))
+ if (!fs32_to_cpu(sb, ucg->cg_frsum[fragsize]))
ufs_panic (sb, "ufs_add_fragments",
"internal error or corrupted bitmap on cg %u", cgno);
- DEC_SWAB32(ucg->cg_frsum[fragsize]);
+ fs32_sub(sb, &ucg->cg_frsum[fragsize], 1);
if (fragsize != count)
- INC_SWAB32(ucg->cg_frsum[fragsize - count]);
+ fs32_add(sb, &ucg->cg_frsum[fragsize - count], 1);
for (i = oldcount; i < newcount; i++)
ubh_clrbit (UCPI_UBH, ucpi->c_freeoff, fragno + i);
if(DQUOT_ALLOC_BLOCK(inode, count)) {
*err = -EDQUOT;
return 0;
}
- SUB_SWAB32(ucg->cg_cs.cs_nffree, count);
- SUB_SWAB32(sb->fs_cs(cgno).cs_nffree, count);
- SUB_SWAB32(usb1->fs_cstotal.cs_nffree, count);
+
+ fs32_sub(sb, &ucg->cg_cs.cs_nffree, count);
+ fs32_sub(sb, &sb->fs_cs(cgno).cs_nffree, count);
+ fs32_sub(sb, &usb1->fs_cstotal.cs_nffree, count);

ubh_mark_buffer_dirty (USPI_UBH);
ubh_mark_buffer_dirty (UCPI_UBH);
@@ -474,10 +470,10 @@

#define UFS_TEST_FREE_SPACE_CG \
ucg = (struct ufs_cylinder_group *) sb->u.ufs_sb.s_ucg[cgno]->b_data; \
- if (SWAB32(ucg->cg_cs.cs_nbfree)) \
+ if (fs32_to_cpu(sb, ucg->cg_cs.cs_nbfree)) \
goto cg_found; \
for (k = count; k < uspi->s_fpb; k++) \
- if (SWAB32(ucg->cg_frsum[k])) \
+ if (fs32_to_cpu(sb, ucg->cg_frsum[k])) \
goto cg_found;

unsigned ufs_alloc_fragments (struct inode * inode, unsigned cgno,
@@ -489,12 +485,10 @@
struct ufs_cg_private_info * ucpi;
struct ufs_cylinder_group * ucg;
unsigned oldcg, i, j, k, result, allocsize;
- unsigned swab;

UFSD(("ENTER, ino %lu, cgno %u, goal %u, count %u\n", inode->i_ino, cgno, goal, count))

sb = inode->i_sb;
- swab = sb->u.ufs_sb.s_swab;
uspi = sb->u.ufs_sb.s_uspi;
usb1 = ubh_get_usb_first(USPI_UBH);
oldcg = cgno;
@@ -534,10 +528,10 @@
if (!ucpi)
return 0;
ucg = ubh_get_ucg (UCPI_UBH);
- if (!ufs_cg_chkmagic(ucg))
+ if (!ufs_cg_chkmagic(sb, ucg))
ufs_panic (sb, "ufs_alloc_fragments",
"internal error, bad magic number on cg %u", cgno);
- ucg->cg_time = SWAB32(CURRENT_TIME);
+ ucg->cg_time = cpu_to_fs32(sb, CURRENT_TIME);

if (count == uspi->s_fpb) {
result = ufs_alloccg_block (inode, ucpi, goal, err);
@@ -547,7 +541,7 @@
}

for (allocsize = count; allocsize < uspi->s_fpb; allocsize++)
- if (SWAB32(ucg->cg_frsum[allocsize]) != 0)
+ if (fs32_to_cpu(sb, ucg->cg_frsum[allocsize]) != 0)
break;

if (allocsize == uspi->s_fpb) {
@@ -559,10 +553,11 @@
ubh_setbit (UCPI_UBH, ucpi->c_freeoff, goal + i);
i = uspi->s_fpb - count;
DQUOT_FREE_BLOCK(inode, i);
- ADD_SWAB32(ucg->cg_cs.cs_nffree, i);
- ADD_SWAB32(usb1->fs_cstotal.cs_nffree, i);
- ADD_SWAB32(sb->fs_cs(cgno).cs_nffree, i);
- INC_SWAB32(ucg->cg_frsum[i]);
+
+ fs32_add(sb, &ucg->cg_cs.cs_nffree, i);
+ fs32_add(sb, &usb1->fs_cstotal.cs_nffree, i);
+ fs32_add(sb, &sb->fs_cs(cgno).cs_nffree, i);
+ fs32_add(sb, &ucg->cg_frsum[i], 1);
goto succed;
}

@@ -575,12 +570,14 @@
}
for (i = 0; i < count; i++)
ubh_clrbit (UCPI_UBH, ucpi->c_freeoff, result + i);
- SUB_SWAB32(ucg->cg_cs.cs_nffree, count);
- SUB_SWAB32(usb1->fs_cstotal.cs_nffree, count);
- SUB_SWAB32(sb->fs_cs(cgno).cs_nffree, count);
- DEC_SWAB32(ucg->cg_frsum[allocsize]);
+
+ fs32_sub(sb, &ucg->cg_cs.cs_nffree, count);
+ fs32_sub(sb, &usb1->fs_cstotal.cs_nffree, count);
+ fs32_sub(sb, &sb->fs_cs(cgno).cs_nffree, count);
+ fs32_sub(sb, &ucg->cg_frsum[allocsize], 1);
+
if (count != allocsize)
- INC_SWAB32(ucg->cg_frsum[allocsize - count]);
+ fs32_add(sb, &ucg->cg_frsum[allocsize - count], 1);

succed:
ubh_mark_buffer_dirty (USPI_UBH);
@@ -604,12 +601,10 @@
struct ufs_super_block_first * usb1;
struct ufs_cylinder_group * ucg;
unsigned result, cylno, blkno;
- unsigned swab;

UFSD(("ENTER, goal %u\n", goal))

sb = inode->i_sb;
- swab = sb->u.ufs_sb.s_swab;
uspi = sb->u.ufs_sb.s_uspi;
usb1 = ubh_get_usb_first(USPI_UBH);
ucg = ubh_get_ucg(UCPI_UBH);
@@ -643,12 +638,13 @@
*err = -EDQUOT;
return (unsigned)-1;
}
- DEC_SWAB32(ucg->cg_cs.cs_nbfree);
- DEC_SWAB32(usb1->fs_cstotal.cs_nbfree);
- DEC_SWAB32(sb->fs_cs(ucpi->c_cgx).cs_nbfree);
+
+ fs32_sub(sb, &ucg->cg_cs.cs_nbfree, 1);
+ fs32_sub(sb, &usb1->fs_cstotal.cs_nbfree, 1);
+ fs32_sub(sb, &sb->fs_cs(ucpi->c_cgx).cs_nbfree, 1);
cylno = ufs_cbtocylno(result);
- DEC_SWAB16(ubh_cg_blks(ucpi, cylno, ufs_cbtorpos(result)));
- DEC_SWAB32(ubh_cg_blktot(ucpi, cylno));
+ fs16_sub(sb, &ubh_cg_blks(ucpi, cylno, ufs_cbtorpos(result)), 1);
+ fs32_sub(sb, &ubh_cg_blktot(ucpi, cylno), 1);

UFSD(("EXIT, result %u\n", result))

@@ -663,11 +659,9 @@
struct ufs_cylinder_group * ucg;
unsigned start, length, location, result;
unsigned possition, fragsize, blockmap, mask;
- unsigned swab;

UFSD(("ENTER, cg %u, goal %u, count %u\n", ucpi->c_cgx, goal, count))

- swab = sb->u.ufs_sb.s_swab;
uspi = sb->u.ufs_sb.s_uspi;
usb1 = ubh_get_usb_first (USPI_UBH);
ucg = ubh_get_ucg(UCPI_UBH);
@@ -733,12 +727,8 @@
{
struct ufs_sb_private_info * uspi;
int i, start, end, forw, back;
- unsigned swab;
-

uspi = sb->u.ufs_sb.s_uspi;
- swab = sb->u.ufs_sb.s_swab;
-
if (uspi->s_contigsumsize <= 0)
return;

@@ -778,11 +768,11 @@
i = back + forw + 1;
if (i > uspi->s_contigsumsize)
i = uspi->s_contigsumsize;
- ADD_SWAB32(*((u32*)ubh_get_addr(UCPI_UBH, ucpi->c_clustersumoff + (i << 2))), cnt);
+ fs32_add(sb, (u32*)ubh_get_addr(UCPI_UBH, ucpi->c_clustersumoff + (i << 2)), cnt);
if (back > 0)
- SUB_SWAB32(*((u32*)ubh_get_addr(UCPI_UBH, ucpi->c_clustersumoff + (back << 2))), cnt);
+ fs32_sub(sb, (u32*)ubh_get_addr(UCPI_UBH, ucpi->c_clustersumoff + (back << 2)), cnt);
if (forw > 0)
- SUB_SWAB32(*((u32*)ubh_get_addr(UCPI_UBH, ucpi->c_clustersumoff + (forw << 2))), cnt);
+ fs32_sub(sb, (u32*)ubh_get_addr(UCPI_UBH, ucpi->c_clustersumoff + (forw << 2)), cnt);
}


diff -uNr -Xdontdiff ../master/linux-2.4.14-pre3/fs/ufs/cylinder.c linux/fs/ufs/cylinder.c
--- ../master/linux-2.4.14-pre3/fs/ufs/cylinder.c Tue Sep 5 23:07:30 2000
+++ linux/fs/ufs/cylinder.c Mon Oct 29 16:46:54 2001
@@ -41,10 +41,8 @@
struct ufs_cg_private_info * ucpi;
struct ufs_cylinder_group * ucg;
unsigned i, j;
- unsigned swab;

UFSD(("ENTER, cgno %u, bitmap_nr %u\n", cgno, bitmap_nr))
- swab = sb->u.ufs_sb.s_swab;
uspi = sb->u.ufs_sb.s_uspi;
ucpi = sb->u.ufs_sb.s_ucpi[bitmap_nr];
ucg = (struct ufs_cylinder_group *)sb->u.ufs_sb.s_ucg[cgno]->b_data;
@@ -60,21 +58,21 @@
goto failed;
sb->u.ufs_sb.s_cgno[bitmap_nr] = cgno;

- ucpi->c_cgx = SWAB32(ucg->cg_cgx);
- ucpi->c_ncyl = SWAB16(ucg->cg_ncyl);
- ucpi->c_niblk = SWAB16(ucg->cg_niblk);
- ucpi->c_ndblk = SWAB32(ucg->cg_ndblk);
- ucpi->c_rotor = SWAB32(ucg->cg_rotor);
- ucpi->c_frotor = SWAB32(ucg->cg_frotor);
- ucpi->c_irotor = SWAB32(ucg->cg_irotor);
- ucpi->c_btotoff = SWAB32(ucg->cg_btotoff);
- ucpi->c_boff = SWAB32(ucg->cg_boff);
- ucpi->c_iusedoff = SWAB32(ucg->cg_iusedoff);
- ucpi->c_freeoff = SWAB32(ucg->cg_freeoff);
- ucpi->c_nextfreeoff = SWAB32(ucg->cg_nextfreeoff);
- ucpi->c_clustersumoff = SWAB32(ucg->cg_u.cg_44.cg_clustersumoff);
- ucpi->c_clusteroff = SWAB32(ucg->cg_u.cg_44.cg_clusteroff);
- ucpi->c_nclusterblks = SWAB32(ucg->cg_u.cg_44.cg_nclusterblks);
+ ucpi->c_cgx = fs32_to_cpu(sb, ucg->cg_cgx);
+ ucpi->c_ncyl = fs16_to_cpu(sb, ucg->cg_ncyl);
+ ucpi->c_niblk = fs16_to_cpu(sb, ucg->cg_niblk);
+ ucpi->c_ndblk = fs32_to_cpu(sb, ucg->cg_ndblk);
+ ucpi->c_rotor = fs32_to_cpu(sb, ucg->cg_rotor);
+ ucpi->c_frotor = fs32_to_cpu(sb, ucg->cg_frotor);
+ ucpi->c_irotor = fs32_to_cpu(sb, ucg->cg_irotor);
+ ucpi->c_btotoff = fs32_to_cpu(sb, ucg->cg_btotoff);
+ ucpi->c_boff = fs32_to_cpu(sb, ucg->cg_boff);
+ ucpi->c_iusedoff = fs32_to_cpu(sb, ucg->cg_iusedoff);
+ ucpi->c_freeoff = fs32_to_cpu(sb, ucg->cg_freeoff);
+ ucpi->c_nextfreeoff = fs32_to_cpu(sb, ucg->cg_nextfreeoff);
+ ucpi->c_clustersumoff = fs32_to_cpu(sb, ucg->cg_u.cg_44.cg_clustersumoff);
+ ucpi->c_clusteroff = fs32_to_cpu(sb, ucg->cg_u.cg_44.cg_clusteroff);
+ ucpi->c_nclusterblks = fs32_to_cpu(sb, ucg->cg_u.cg_44.cg_nclusterblks);
UFSD(("EXIT\n"))
return;

@@ -95,11 +93,9 @@
struct ufs_cg_private_info * ucpi;
struct ufs_cylinder_group * ucg;
unsigned i;
- unsigned swab;

UFSD(("ENTER, bitmap_nr %u\n", bitmap_nr))

- swab = sb->u.ufs_sb.s_swab;
uspi = sb->u.ufs_sb.s_uspi;
if (sb->u.ufs_sb.s_cgno[bitmap_nr] == UFS_CGNO_EMPTY) {
UFSD(("EXIT\n"))
@@ -116,9 +112,9 @@
* rotor is not so important data, so we put it to disk
* at the end of working with cylinder
*/
- ucg->cg_rotor = SWAB32(ucpi->c_rotor);
- ucg->cg_frotor = SWAB32(ucpi->c_frotor);
- ucg->cg_irotor = SWAB32(ucpi->c_irotor);
+ ucg->cg_rotor = cpu_to_fs32(sb, ucpi->c_rotor);
+ ucg->cg_frotor = cpu_to_fs32(sb, ucpi->c_frotor);
+ ucg->cg_irotor = cpu_to_fs32(sb, ucpi->c_irotor);
ubh_mark_buffer_dirty (UCPI_UBH);
for (i = 1; i < UCPI_UBH->count; i++) {
brelse (UCPI_UBH->bh[i]);
diff -uNr -Xdontdiff ../master/linux-2.4.14-pre3/fs/ufs/dir.c linux/fs/ufs/dir.c
--- ../master/linux-2.4.14-pre3/fs/ufs/dir.c Thu Oct 25 19:05:47 2001
+++ linux/fs/ufs/dir.c Mon Oct 29 16:46:54 2001
@@ -29,15 +29,17 @@
#define UFSD(x)
#endif

+
+
/*
* NOTE! unlike strncmp, ufs_match returns 1 for success, 0 for failure.
*
* len <= UFS_MAXNAMLEN and de != NULL are guaranteed by caller.
*/
-static inline int ufs_match (int len, const char * const name,
- struct ufs_dir_entry * de, unsigned flags, unsigned swab)
+static inline int ufs_match(struct super_block *sb, int len,
+ const char * const name, struct ufs_dir_entry * de)
{
- if (len != ufs_get_de_namlen(de))
+ if (len != ufs_get_de_namlen(sb, de))
return 0;
if (!de->d_ino)
return 0;
@@ -58,10 +60,9 @@
struct ufs_dir_entry * de;
struct super_block * sb;
int de_reclen;
- unsigned flags, swab;
+ unsigned flags;

sb = inode->i_sb;
- swab = sb->u.ufs_sb.s_swab;
flags = sb->u.ufs_sb.s_flags;

UFSD(("ENTER, ino %lu f_pos %lu\n", inode->i_ino, (unsigned long) filp->f_pos))
@@ -96,7 +97,7 @@
* least that it is non-zero. A
* failure will be detected in the
* dirent test below. */
- de_reclen = SWAB16(de->d_reclen);
+ de_reclen = fs16_to_cpu(sb, de->d_reclen);
if (de_reclen < 1)
break;
i += de_reclen;
@@ -111,8 +112,7 @@
&& offset < sb->s_blocksize) {
de = (struct ufs_dir_entry *) (bh->b_data + offset);
/* XXX - put in a real ufs_check_dir_entry() */
- if ((de->d_reclen == 0) || (ufs_get_de_namlen(de) == 0)) {
- /* SWAB16() was unneeded -- compare to 0 */
+ if ((de->d_reclen == 0) || (ufs_get_de_namlen(sb, de) == 0)) {
filp->f_pos = (filp->f_pos &
(sb->s_blocksize - 1)) +
sb->s_blocksize;
@@ -129,9 +129,8 @@
brelse (bh);
return stored;
}
- offset += SWAB16(de->d_reclen);
+ offset += fs16_to_cpu(sb, de->d_reclen);
if (de->d_ino) {
- /* SWAB16() was unneeded -- compare to 0 */
/* We might block in the next section
* if the data destination is
* currently swapped out. So, use a
@@ -141,19 +140,22 @@
unsigned long version = filp->f_version;
unsigned char d_type = DT_UNKNOWN;

- UFSD(("filldir(%s,%u)\n", de->d_name, SWAB32(de->d_ino)))
- UFSD(("namlen %u\n", ufs_get_de_namlen(de)))
+ UFSD(("filldir(%s,%u)\n", de->d_name,
+ fs32_to_cpu(sb, de->d_ino)))
+ UFSD(("namlen %u\n", ufs_get_de_namlen(sb, de)))
+
if ((flags & UFS_DE_MASK) == UFS_DE_44BSD)
d_type = de->d_u.d_44.d_type;
- error = filldir(dirent, de->d_name, ufs_get_de_namlen(de),
- filp->f_pos, SWAB32(de->d_ino), d_type);
+ error = filldir(dirent, de->d_name,
+ ufs_get_de_namlen(sb, de), filp->f_pos,
+ fs32_to_cpu(sb, de->d_ino), d_type);
if (error)
break;
if (version != filp->f_version)
goto revalidate;
stored ++;
}
- filp->f_pos += SWAB16(de->d_reclen);
+ filp->f_pos += fs16_to_cpu(sb, de->d_reclen);
}
offset = 0;
brelse (bh);
@@ -186,7 +188,6 @@
struct buffer_head * bh_read[NAMEI_RA_SIZE];
unsigned long offset;
int block, toread, i, err;
- unsigned flags, swab;
struct inode *dir = dentry->d_parent->d_inode;
const char *name = dentry->d_name.name;
int namelen = dentry->d_name.len;
@@ -196,8 +197,6 @@
*res_bh = NULL;

sb = dir->i_sb;
- flags = sb->u.ufs_sb.s_flags;
- swab = sb->u.ufs_sb.s_swab;

if (namelen > UFS_MAXNAMLEN)
return NULL;
@@ -248,7 +247,7 @@
int de_len;

if ((char *) de + namelen <= dlimit &&
- ufs_match (namelen, name, de, flags, swab)) {
+ ufs_match(sb, namelen, name, de)) {
/* found a match -
just to be sure, do a full check */
if (!ufs_check_dir_entry("ufs_find_entry",
@@ -262,7 +261,7 @@
return de;
}
/* prevent looping on a bad block */
- de_len = SWAB16(de->d_reclen);
+ de_len = fs16_to_cpu(sb, de->d_reclen);
if (de_len <= 0)
goto failed;
offset += de_len;
@@ -292,31 +291,31 @@
{
struct super_block * sb;
const char * error_msg;
- unsigned flags, swab;
+ int rlen;

sb = dir->i_sb;
- flags = sb->u.ufs_sb.s_flags;
- swab = sb->u.ufs_sb.s_swab;
+ rlen = fs16_to_cpu(sb, de->d_reclen);
error_msg = NULL;

- if (SWAB16(de->d_reclen) < UFS_DIR_REC_LEN(1))
+ if (rlen < UFS_DIR_REC_LEN(1))
error_msg = "reclen is smaller than minimal";
- else if (SWAB16(de->d_reclen) % 4 != 0)
+ else if (rlen % 4 != 0)
error_msg = "reclen % 4 != 0";
- else if (SWAB16(de->d_reclen) < UFS_DIR_REC_LEN(ufs_get_de_namlen(de)))
+ else if (rlen < UFS_DIR_REC_LEN(ufs_get_de_namlen(sb, de)))
error_msg = "reclen is too small for namlen";
- else if (dir && ((char *) de - bh->b_data) + SWAB16(de->d_reclen) >
+ else if (dir && ((char *) de - bh->b_data) + rlen >
dir->i_sb->s_blocksize)
error_msg = "directory entry across blocks";
- else if (dir && SWAB32(de->d_ino) > (sb->u.ufs_sb.s_uspi->s_ipg * sb->u.ufs_sb.s_uspi->s_ncg))
+ else if (dir && fs32_to_cpu(sb, de->d_ino) >
+ (sb->u.ufs_sb.s_uspi->s_ipg * sb->u.ufs_sb.s_uspi->s_ncg))
error_msg = "inode out of bounds";

if (error_msg != NULL)
ufs_error (sb, function, "bad entry in directory #%lu, size %Lu: %s - "
"offset=%lu, inode=%lu, reclen=%d, namlen=%d",
dir->i_ino, dir->i_size, error_msg, offset,
- (unsigned long) SWAB32(de->d_ino),
- SWAB16(de->d_reclen), ufs_get_de_namlen(de));
+ (unsigned long)fs32_to_cpu(sb, de->d_ino),
+ rlen, ufs_get_de_namlen(sb, de));

return (error_msg == NULL ? 1 : 0);
}
@@ -328,25 +327,22 @@
struct ufs_dir_entry *res = NULL;

if (bh) {
- unsigned swab = dir->i_sb->u.ufs_sb.s_swab;
-
res = (struct ufs_dir_entry *) bh->b_data;
res = (struct ufs_dir_entry *)((char *)res +
- SWAB16(res->d_reclen));
+ fs16_to_cpu(dir->i_sb, res->d_reclen));
}
*p = bh;
return res;
}
ino_t ufs_inode_by_name(struct inode * dir, struct dentry *dentry)
{
- unsigned swab = dir->i_sb->u.ufs_sb.s_swab;
ino_t res = 0;
struct ufs_dir_entry * de;
struct buffer_head *bh;

de = ufs_find_entry (dentry, &bh);
if (de) {
- res = SWAB32(de->d_ino);
+ res = fs32_to_cpu(dir->i_sb, de->d_ino);
brelse(bh);
}
return res;
@@ -355,9 +351,8 @@
void ufs_set_link(struct inode *dir, struct ufs_dir_entry *de,
struct buffer_head *bh, struct inode *inode)
{
- unsigned swab = dir->i_sb->u.ufs_sb.s_swab;
dir->i_version = ++event;
- de->d_ino = SWAB32(inode->i_ino);
+ de->d_ino = cpu_to_fs32(dir->i_sb, inode->i_ino);
mark_buffer_dirty(bh);
if (IS_SYNC(dir)) {
ll_rw_block (WRITE, 1, &bh);
@@ -381,7 +376,6 @@
unsigned short rec_len;
struct buffer_head * bh;
struct ufs_dir_entry * de, * de1;
- unsigned flags, swab;
struct inode *dir = dentry->d_parent->d_inode;
const char *name = dentry->d_name.name;
int namelen = dentry->d_name.len;
@@ -390,8 +384,6 @@
UFSD(("ENTER, name %s, namelen %u\n", name, namelen))

sb = dir->i_sb;
- flags = sb->u.ufs_sb.s_flags;
- swab = sb->u.ufs_sb.s_swab;
uspi = sb->u.ufs_sb.s_uspi;

if (!namelen)
@@ -420,9 +412,9 @@
return -ENOENT;
}
de = (struct ufs_dir_entry *) (bh->b_data + fragoff);
- de->d_ino = SWAB32(0);
- de->d_reclen = SWAB16(UFS_SECTOR_SIZE);
- ufs_set_de_namlen(de,0);
+ de->d_ino = 0;
+ de->d_reclen = cpu_to_fs16(sb, UFS_SECTOR_SIZE);
+ ufs_set_de_namlen(sb, de, 0);
dir->i_size = offset + UFS_SECTOR_SIZE;
mark_inode_dirty(dir);
} else {
@@ -433,32 +425,35 @@
brelse (bh);
return -ENOENT;
}
- if (ufs_match (namelen, name, de, flags, swab)) {
+ if (ufs_match(sb, namelen, name, de)) {
brelse (bh);
return -EEXIST;
}
- if (SWAB32(de->d_ino) == 0 && SWAB16(de->d_reclen) >= rec_len)
+ if (de->d_ino == 0 && fs16_to_cpu(sb, de->d_reclen) >= rec_len)
break;

- if (SWAB16(de->d_reclen) >= UFS_DIR_REC_LEN(ufs_get_de_namlen(de)) + rec_len)
+ if (fs16_to_cpu(sb, de->d_reclen) >=
+ UFS_DIR_REC_LEN(ufs_get_de_namlen(sb, de)) + rec_len)
break;
- offset += SWAB16(de->d_reclen);
- de = (struct ufs_dir_entry *) ((char *) de + SWAB16(de->d_reclen));
+ offset += fs16_to_cpu(sb, de->d_reclen);
+ de = (struct ufs_dir_entry *) ((char *) de + fs16_to_cpu(sb, de->d_reclen));
}

- if (SWAB32(de->d_ino)) {
+ if (de->d_ino) {
de1 = (struct ufs_dir_entry *) ((char *) de +
- UFS_DIR_REC_LEN(ufs_get_de_namlen(de)));
- de1->d_reclen = SWAB16(SWAB16(de->d_reclen) -
- UFS_DIR_REC_LEN(ufs_get_de_namlen(de)));
- de->d_reclen = SWAB16(UFS_DIR_REC_LEN(ufs_get_de_namlen(de)));
+ UFS_DIR_REC_LEN(ufs_get_de_namlen(sb, de)));
+ de1->d_reclen =
+ cpu_to_fs16(sb, fs16_to_cpu(sb, de->d_reclen) -
+ UFS_DIR_REC_LEN(ufs_get_de_namlen(sb, de)));
+ de->d_reclen =
+ cpu_to_fs16(sb, UFS_DIR_REC_LEN(ufs_get_de_namlen(sb, de)));
de = de1;
}
- de->d_ino = SWAB32(0);
- ufs_set_de_namlen(de, namelen);
+ de->d_ino = 0;
+ ufs_set_de_namlen(sb, de, namelen);
memcpy (de->d_name, name, namelen + 1);
- de->d_ino = SWAB32(inode->i_ino);
- ufs_set_de_type (de, inode->i_mode);
+ de->d_ino = cpu_to_fs32(sb, inode->i_ino);
+ ufs_set_de_type(sb, de, inode->i_mode);
mark_buffer_dirty(bh);
if (IS_SYNC(dir)) {
ll_rw_block (WRITE, 1, &bh);
@@ -484,19 +479,18 @@
struct super_block * sb;
struct ufs_dir_entry * de, * pde;
unsigned i;
- unsigned flags, swab;

UFSD(("ENTER\n"))

sb = inode->i_sb;
- flags = sb->u.ufs_sb.s_flags;
- swab = sb->u.ufs_sb.s_swab;
i = 0;
pde = NULL;
de = (struct ufs_dir_entry *) bh->b_data;

- UFSD(("ino %u, reclen %u, namlen %u, name %s\n", SWAB32(de->d_ino),
- SWAB16(de->d_reclen), ufs_get_de_namlen(de), de->d_name))
+ UFSD(("ino %u, reclen %u, namlen %u, name %s\n",
+ fs32_to_cpu(sb, de->d_ino),
+ fs16to_cpu(sb, de->d_reclen),
+ ufs_get_de_namlen(sb, de), de->d_name))

while (i < bh->b_size) {
if (!ufs_check_dir_entry ("ufs_delete_entry", inode, de, bh, i)) {
@@ -505,10 +499,9 @@
}
if (de == dir) {
if (pde)
- pde->d_reclen =
- SWAB16(SWAB16(pde->d_reclen) +
- SWAB16(dir->d_reclen));
- dir->d_ino = SWAB32(0);
+ fs16_add(sb, &pde->d_reclen,
+ fs16_to_cpu(sb, dir->d_reclen));
+ dir->d_ino = 0;
inode->i_version = ++event;
inode->i_ctime = inode->i_mtime = CURRENT_TIME;
mark_inode_dirty(inode);
@@ -521,12 +514,12 @@
UFSD(("EXIT\n"))
return 0;
}
- i += SWAB16(de->d_reclen);
+ i += fs16_to_cpu(sb, de->d_reclen);
if (i == UFS_SECTOR_SIZE) pde = NULL;
else pde = de;
de = (struct ufs_dir_entry *)
- ((char *) de + SWAB16(de->d_reclen));
- if (i == UFS_SECTOR_SIZE && SWAB16(de->d_reclen) == 0)
+ ((char *) de + fs16_to_cpu(sb, de->d_reclen));
+ if (i == UFS_SECTOR_SIZE && de->d_reclen == 0)
break;
}
UFSD(("EXIT\n"))
@@ -537,8 +530,6 @@
int ufs_make_empty(struct inode * inode, struct inode *dir)
{
struct super_block * sb = dir->i_sb;
- unsigned flags = sb->u.ufs_sb.s_flags;
- unsigned swab = sb->u.ufs_sb.s_swab;
struct buffer_head * dir_block;
struct ufs_dir_entry * de;
int err;
@@ -549,16 +540,17 @@

inode->i_blocks = sb->s_blocksize / UFS_SECTOR_SIZE;
de = (struct ufs_dir_entry *) dir_block->b_data;
- de->d_ino = SWAB32(inode->i_ino);
- ufs_set_de_type (de, inode->i_mode);
- ufs_set_de_namlen(de,1);
- de->d_reclen = SWAB16(UFS_DIR_REC_LEN(1));
+ de->d_ino = cpu_to_fs32(sb, inode->i_ino);
+ ufs_set_de_type(sb, de, inode->i_mode);
+ ufs_set_de_namlen(sb, de, 1);
+ de->d_reclen = cpu_to_fs16(sb, UFS_DIR_REC_LEN(1));
strcpy (de->d_name, ".");
- de = (struct ufs_dir_entry *) ((char *) de + SWAB16(de->d_reclen));
- de->d_ino = SWAB32(dir->i_ino);
- ufs_set_de_type (de, dir->i_mode);
- de->d_reclen = SWAB16(UFS_SECTOR_SIZE - UFS_DIR_REC_LEN(1));
- ufs_set_de_namlen(de,2);
+ de = (struct ufs_dir_entry *)
+ ((char *)de + fs16_to_cpu(sb, de->d_reclen));
+ de->d_ino = cpu_to_fs32(sb, dir->i_ino);
+ ufs_set_de_type(sb, de, dir->i_mode);
+ de->d_reclen = cpu_to_fs16(sb, UFS_SECTOR_SIZE - UFS_DIR_REC_LEN(1));
+ ufs_set_de_namlen(sb, de, 2);
strcpy (de->d_name, "..");
mark_buffer_dirty(dir_block);
brelse (dir_block);
@@ -576,10 +568,8 @@
struct buffer_head * bh;
struct ufs_dir_entry * de, * de1;
int err;
- unsigned swab;

sb = inode->i_sb;
- swab = sb->u.ufs_sb.s_swab;

if (inode->i_size < UFS_DIR_REC_LEN(1) + UFS_DIR_REC_LEN(2) ||
!(bh = ufs_bread (inode, 0, 0, &err))) {
@@ -589,16 +579,18 @@
return 1;
}
de = (struct ufs_dir_entry *) bh->b_data;
- de1 = (struct ufs_dir_entry *) ((char *) de + SWAB16(de->d_reclen));
- if (SWAB32(de->d_ino) != inode->i_ino || !SWAB32(de1->d_ino) ||
- strcmp (".", de->d_name) || strcmp ("..", de1->d_name)) {
+ de1 = (struct ufs_dir_entry *)
+ ((char *)de + fs16_to_cpu(sb, de->d_reclen));
+ if (fs32_to_cpu(sb, de->d_ino) != inode->i_ino || de1->d_ino == 0 ||
+ strcmp (".", de->d_name) || strcmp ("..", de1->d_name)) {
ufs_warning (inode->i_sb, "empty_dir",
"bad directory (dir #%lu) - no `.' or `..'",
inode->i_ino);
return 1;
}
- offset = SWAB16(de->d_reclen) + SWAB16(de1->d_reclen);
- de = (struct ufs_dir_entry *) ((char *) de1 + SWAB16(de1->d_reclen));
+ offset = fs16_to_cpu(sb, de->d_reclen) + fs16_to_cpu(sb, de1->d_reclen);
+ de = (struct ufs_dir_entry *)
+ ((char *)de1 + fs16_to_cpu(sb, de1->d_reclen));
while (offset < inode->i_size ) {
if (!bh || (void *) de >= (void *) (bh->b_data + sb->s_blocksize)) {
brelse (bh);
@@ -616,12 +608,13 @@
brelse (bh);
return 1;
}
- if (SWAB32(de->d_ino)) {
+ if (de->d_ino) {
brelse (bh);
return 0;
}
- offset += SWAB16(de->d_reclen);
- de = (struct ufs_dir_entry *) ((char *) de + SWAB16(de->d_reclen));
+ offset += fs16_to_cpu(sb, de->d_reclen);
+ de = (struct ufs_dir_entry *)
+ ((char *)de + fs16_to_cpu(sb, de->d_reclen));
}
brelse (bh);
return 1;
diff -uNr -Xdontdiff ../master/linux-2.4.14-pre3/fs/ufs/ialloc.c linux/fs/ufs/ialloc.c
--- ../master/linux-2.4.14-pre3/fs/ufs/ialloc.c Thu Oct 25 19:05:48 2001
+++ linux/fs/ufs/ialloc.c Mon Oct 29 16:46:54 2001
@@ -66,12 +66,10 @@
struct ufs_cylinder_group * ucg;
int is_directory;
unsigned ino, cg, bit;
- unsigned swab;

UFSD(("ENTER, ino %lu\n", inode->i_ino))

sb = inode->i_sb;
- swab = sb->u.ufs_sb.s_swab;
uspi = sb->u.ufs_sb.s_uspi;
usb1 = ubh_get_usb_first(USPI_UBH);

@@ -93,10 +91,10 @@
return;
}
ucg = ubh_get_ucg(UCPI_UBH);
- if (!ufs_cg_chkmagic(ucg))
+ if (!ufs_cg_chkmagic(sb, ucg))
ufs_panic (sb, "ufs_free_fragments", "internal error, bad cg magic number");

- ucg->cg_time = SWAB32(CURRENT_TIME);
+ ucg->cg_time = cpu_to_fs32(sb, CURRENT_TIME);

is_directory = S_ISDIR(inode->i_mode);

@@ -111,16 +109,17 @@
ubh_clrbit (UCPI_UBH, ucpi->c_iusedoff, bit);
if (ino < ucpi->c_irotor)
ucpi->c_irotor = ino;
- INC_SWAB32(ucg->cg_cs.cs_nifree);
- INC_SWAB32(usb1->fs_cstotal.cs_nifree);
- INC_SWAB32(sb->fs_cs(cg).cs_nifree);
+ fs32_add(sb, &ucg->cg_cs.cs_nifree, 1);
+ fs32_add(sb, &usb1->fs_cstotal.cs_nifree, 1);
+ fs32_add(sb, &sb->fs_cs(cg).cs_nifree, 1);

if (is_directory) {
- DEC_SWAB32(ucg->cg_cs.cs_ndir);
- DEC_SWAB32(usb1->fs_cstotal.cs_ndir);
- DEC_SWAB32(sb->fs_cs(cg).cs_ndir);
+ fs32_sub(sb, &ucg->cg_cs.cs_ndir, 1);
+ fs32_sub(sb, &usb1->fs_cstotal.cs_ndir, 1);
+ fs32_sub(sb, &sb->fs_cs(cg).cs_ndir, 1);
}
}
+
ubh_mark_buffer_dirty (USPI_UBH);
ubh_mark_buffer_dirty (UCPI_UBH);
if (sb->s_flags & MS_SYNCHRONOUS) {
@@ -152,7 +151,6 @@
struct ufs_cylinder_group * ucg;
struct inode * inode;
unsigned cg, bit, i, j, start;
- unsigned swab;

UFSD(("ENTER\n"))

@@ -163,7 +161,6 @@
inode = new_inode(sb);
if (!inode)
return ERR_PTR(-ENOMEM);
- swab = sb->u.ufs_sb.s_swab;
uspi = sb->u.ufs_sb.s_uspi;
usb1 = ubh_get_usb_first(USPI_UBH);

@@ -173,7 +170,7 @@
* Try to place the inode in its parent directory
*/
i = ufs_inotocg(dir->i_ino);
- if (SWAB32(sb->fs_cs(i).cs_nifree)) {
+ if (sb->fs_cs(i).cs_nifree) {
cg = i;
goto cg_found;
}
@@ -185,7 +182,7 @@
i += j;
if (i >= uspi->s_ncg)
i -= uspi->s_ncg;
- if (SWAB32(sb->fs_cs(i).cs_nifree)) {
+ if (sb->fs_cs(i).cs_nifree) {
cg = i;
goto cg_found;
}
@@ -199,7 +196,7 @@
i++;
if (i >= uspi->s_ncg)
i = 0;
- if (SWAB32(sb->fs_cs(i).cs_nifree)) {
+ if (sb->fs_cs(i).cs_nifree) {
cg = i;
goto cg_found;
}
@@ -212,7 +209,7 @@
if (!ucpi)
goto failed;
ucg = ubh_get_ucg(UCPI_UBH);
- if (!ufs_cg_chkmagic(ucg))
+ if (!ufs_cg_chkmagic(sb, ucg))
ufs_panic (sb, "ufs_new_inode", "internal error, bad cg magic number");

start = ucpi->c_irotor;
@@ -233,14 +230,14 @@
goto failed;
}

- DEC_SWAB32(ucg->cg_cs.cs_nifree);
- DEC_SWAB32(usb1->fs_cstotal.cs_nifree);
- DEC_SWAB32(sb->fs_cs(cg).cs_nifree);
+ fs32_sub(sb, &ucg->cg_cs.cs_nifree, 1);
+ fs32_sub(sb, &usb1->fs_cstotal.cs_nifree, 1);
+ fs32_sub(sb, &sb->fs_cs(cg).cs_nifree, 1);

if (S_ISDIR(mode)) {
- INC_SWAB32(ucg->cg_cs.cs_ndir);
- INC_SWAB32(usb1->fs_cstotal.cs_ndir);
- INC_SWAB32(sb->fs_cs(cg).cs_ndir);
+ fs32_add(sb, &ucg->cg_cs.cs_ndir, 1);
+ fs32_add(sb, &usb1->fs_cstotal.cs_ndir, 1);
+ fs32_add(sb, &sb->fs_cs(cg).cs_ndir, 1);
}

ubh_mark_buffer_dirty (USPI_UBH);
diff -uNr -Xdontdiff ../master/linux-2.4.14-pre3/fs/ufs/inode.c linux/fs/ufs/inode.c
--- ../master/linux-2.4.14-pre3/fs/ufs/inode.c Thu Oct 25 19:05:48 2001
+++ linux/fs/ufs/inode.c Mon Oct 29 16:46:54 2001
@@ -50,17 +50,6 @@
#define UFSD(x)
#endif

-static inline unsigned int ufs_block_bmap1(struct buffer_head * bh, unsigned nr,
- struct ufs_sb_private_info * uspi, unsigned swab)
-{
- unsigned int tmp;
- if (!bh)
- return 0;
- tmp = SWAB32(((u32 *) bh->b_data)[nr]);
- brelse (bh);
- return tmp;
-}
-
static int ufs_block_to_path(struct inode *inode, long i_block, int offsets[4])
{
struct ufs_sb_private_info *uspi = inode->i_sb->u.ufs_sb.s_uspi;
@@ -97,7 +86,6 @@
{
struct super_block *sb = inode->i_sb;
struct ufs_sb_private_info *uspi = sb->u.ufs_sb.s_uspi;
- unsigned int swab = sb->u.ufs_sb.s_swab;
int mask = uspi->s_apbmask>>uspi->s_fpbshift;
int shift = uspi->s_apbshift-uspi->s_fpbshift;
int offsets[4], *p;
@@ -118,7 +106,7 @@
struct buffer_head *bh;
int n = *p++;

- bh = bread(sb->s_dev, uspi->s_sbbase+SWAB32(block)+(n>>shift),
+ bh = bread(sb->s_dev, uspi->s_sbbase + fs32_to_cpu(sb, block)+(n>>shift),
sb->s_blocksize);
if (!bh)
goto out;
@@ -127,7 +115,7 @@
if (!block)
goto out;
}
- ret = uspi->s_sbbase + SWAB32(block) + (frag & uspi->s_fpbmask);
+ ret = uspi->s_sbbase + fs32_to_cpu(sb, block) + (frag & uspi->s_fpbmask);
out:
unlock_kernel();
return ret;
@@ -143,13 +131,11 @@
unsigned block, blockoff, lastfrag, lastblock, lastblockoff;
unsigned tmp, goal;
u32 * p, * p2;
- unsigned int swab;

UFSD(("ENTER, ino %lu, fragment %u, new_fragment %u, required %u\n",
inode->i_ino, fragment, new_fragment, required))

sb = inode->i_sb;
- swab = sb->u.ufs_sb.s_swab;
uspi = sb->u.ufs_sb.s_uspi;
block = ufs_fragstoblks (fragment);
blockoff = ufs_fragnum (fragment);
@@ -157,13 +143,13 @@
goal = 0;

repeat:
- tmp = SWAB32(*p);
+ tmp = fs32_to_cpu(sb, *p);
lastfrag = inode->u.ufs_i.i_lastfrag;
if (tmp && fragment < lastfrag) {
if (metadata) {
result = getblk (sb->s_dev, uspi->s_sbbase + tmp + blockoff,
sb->s_blocksize);
- if (tmp == SWAB32(*p)) {
+ if (tmp == fs32_to_cpu(sb, *p)) {
UFSD(("EXIT, result %u\n", tmp + blockoff))
return result;
}
@@ -187,7 +173,7 @@
if (lastblockoff) {
p2 = inode->u.ufs_i.i_u1.i_data + lastblock;
tmp = ufs_new_fragments (inode, p2, lastfrag,
- SWAB32(*p2), uspi->s_fpb - lastblockoff, err);
+ fs32_to_cpu(sb, *p2), uspi->s_fpb - lastblockoff, err);
if (!tmp) {
if (lastfrag != inode->u.ufs_i.i_lastfrag)
goto repeat;
@@ -197,7 +183,7 @@
lastfrag = inode->u.ufs_i.i_lastfrag;

}
- goal = SWAB32(inode->u.ufs_i.i_u1.i_data[lastblock]) + uspi->s_fpb;
+ goal = fs32_to_cpu(sb, inode->u.ufs_i.i_u1.i_data[lastblock]) + uspi->s_fpb;
tmp = ufs_new_fragments (inode, p, fragment - blockoff,
goal, required + blockoff, err);
}
@@ -206,19 +192,19 @@
*/
else if (lastblock == block) {
tmp = ufs_new_fragments (inode, p, fragment - (blockoff - lastblockoff),
- SWAB32(*p), required + (blockoff - lastblockoff), err);
+ fs32_to_cpu(sb, *p), required + (blockoff - lastblockoff), err);
}
/*
* We will allocate new block before last allocated block
*/
else /* (lastblock > block) */ {
- if (lastblock && (tmp = SWAB32(inode->u.ufs_i.i_u1.i_data[lastblock-1])))
+ if (lastblock && (tmp = fs32_to_cpu(sb, inode->u.ufs_i.i_u1.i_data[lastblock-1])))
goal = tmp + uspi->s_fpb;
tmp = ufs_new_fragments (inode, p, fragment - blockoff,
goal, uspi->s_fpb, err);
}
if (!tmp) {
- if ((!blockoff && SWAB32(*p)) ||
+ if ((!blockoff && *p) ||
(blockoff && lastfrag != inode->u.ufs_i.i_lastfrag))
goto repeat;
*err = -ENOSPC;
@@ -255,10 +241,8 @@
struct buffer_head * result;
unsigned tmp, goal, block, blockoff;
u32 * p;
- unsigned int swab;

sb = inode->i_sb;
- swab = sb->u.ufs_sb.s_swab;
uspi = sb->u.ufs_sb.s_uspi;
block = ufs_fragstoblks (fragment);
blockoff = ufs_fragnum (fragment);
@@ -277,12 +261,12 @@

p = (u32 *) bh->b_data + block;
repeat:
- tmp = SWAB32(*p);
+ tmp = fs32_to_cpu(sb, *p);
if (tmp) {
if (metadata) {
result = getblk (bh->b_dev, uspi->s_sbbase + tmp + blockoff,
sb->s_blocksize);
- if (tmp == SWAB32(*p))
+ if (tmp == fs32_to_cpu(sb, *p))
goto out;
brelse (result);
goto repeat;
@@ -292,13 +276,13 @@
}
}

- if (block && (tmp = SWAB32(((u32*)bh->b_data)[block-1]) + uspi->s_fpb))
+ if (block && (tmp = fs32_to_cpu(sb, ((u32*)bh->b_data)[block-1]) + uspi->s_fpb))
goal = tmp + uspi->s_fpb;
else
goal = bh->b_blocknr + uspi->s_fpb;
tmp = ufs_new_fragments (inode, p, ufs_blknum(new_fragment), goal, uspi->s_fpb, err);
if (!tmp) {
- if (SWAB32(*p))
+ if (fs32_to_cpu(sb, *p))
goto repeat;
goto out;
}
@@ -332,13 +316,11 @@
struct super_block * sb;
struct ufs_sb_private_info * uspi;
struct buffer_head * bh;
- unsigned int swab;
int ret, err, new;
unsigned long ptr, phys;

sb = inode->i_sb;
uspi = sb->u.ufs_sb.s_uspi;
- swab = sb->u.ufs_sb.s_swab;

if (!create) {
phys = ufs_frag_map(inode, fragment);
@@ -504,14 +486,13 @@
struct ufs_inode * ufs_inode;
struct buffer_head * bh;
unsigned i;
- unsigned flags, swab;
+ unsigned flags;

UFSD(("ENTER, ino %lu\n", inode->i_ino))

sb = inode->i_sb;
uspi = sb->u.ufs_sb.s_uspi;
flags = sb->u.ufs_sb.s_flags;
- swab = sb->u.ufs_sb.s_swab;

if (inode->i_ino < UFS_ROOTINO ||
inode->i_ino > (uspi->s_ncg * uspi->s_ipg)) {
@@ -529,37 +510,29 @@
/*
* Copy data to the in-core inode.
*/
- inode->i_mode = SWAB16(ufs_inode->ui_mode);
- inode->i_nlink = SWAB16(ufs_inode->ui_nlink);
+ inode->i_mode = fs16_to_cpu(sb, ufs_inode->ui_mode);
+ inode->i_nlink = fs16_to_cpu(sb, ufs_inode->ui_nlink);
if (inode->i_nlink == 0)
ufs_error (sb, "ufs_read_inode", "inode %lu has zero nlink\n", inode->i_ino);

/*
* Linux now has 32-bit uid and gid, so we can support EFT.
*/
- inode->i_uid = ufs_get_inode_uid(ufs_inode);
- inode->i_gid = ufs_get_inode_gid(ufs_inode);
-
- /*
- * Linux i_size can be 32 on some architectures. We will mark
- * big files as read only and let user access first 32 bits.
- */
- inode->u.ufs_i.i_size = SWAB64(ufs_inode->ui_size);
- inode->i_size = (off_t) inode->u.ufs_i.i_size;
- if (sizeof(off_t) == 4 && (inode->u.ufs_i.i_size >> 32))
- inode->i_size = (__u32)-1;
-
- inode->i_atime = SWAB32(ufs_inode->ui_atime.tv_sec);
- inode->i_ctime = SWAB32(ufs_inode->ui_ctime.tv_sec);
- inode->i_mtime = SWAB32(ufs_inode->ui_mtime.tv_sec);
- inode->i_blocks = SWAB32(ufs_inode->ui_blocks);
+ inode->i_uid = ufs_get_inode_uid(sb, ufs_inode);
+ inode->i_gid = ufs_get_inode_gid(sb, ufs_inode);
+
+ inode->i_size = fs64_to_cpu(sb, ufs_inode->ui_size);
+ inode->i_atime = fs32_to_cpu(sb, ufs_inode->ui_atime.tv_sec);
+ inode->i_ctime = fs32_to_cpu(sb, ufs_inode->ui_ctime.tv_sec);
+ inode->i_mtime = fs32_to_cpu(sb, ufs_inode->ui_mtime.tv_sec);
+ inode->i_blocks = fs32_to_cpu(sb, ufs_inode->ui_blocks);
inode->i_blksize = PAGE_SIZE; /* This is the optimal IO size (for stat) */
inode->i_version = ++event;

- inode->u.ufs_i.i_flags = SWAB32(ufs_inode->ui_flags);
- inode->u.ufs_i.i_gen = SWAB32(ufs_inode->ui_gen);
- inode->u.ufs_i.i_shadow = SWAB32(ufs_inode->ui_u3.ui_sun.ui_shadow);
- inode->u.ufs_i.i_oeftflag = SWAB32(ufs_inode->ui_u3.ui_sun.ui_oeftflag);
+ inode->u.ufs_i.i_flags = fs32_to_cpu(sb, ufs_inode->ui_flags);
+ inode->u.ufs_i.i_gen = fs32_to_cpu(sb, ufs_inode->ui_gen);
+ inode->u.ufs_i.i_shadow = fs32_to_cpu(sb, ufs_inode->ui_u3.ui_sun.ui_shadow);
+ inode->u.ufs_i.i_oeftflag = fs32_to_cpu(sb, ufs_inode->ui_u3.ui_sun.ui_oeftflag);
inode->u.ufs_i.i_lastfrag = (inode->i_size + uspi->s_fsize - 1) >> uspi->s_fshift;

if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
@@ -590,7 +563,7 @@
}
} else
init_special_inode(inode, inode->i_mode,
- SWAB32(ufs_inode->ui_u2.ui_addr.ui_db[0]));
+ fs32_to_cpu(sb, ufs_inode->ui_u2.ui_addr.ui_db[0]));

brelse (bh);

@@ -604,14 +577,13 @@
struct buffer_head * bh;
struct ufs_inode * ufs_inode;
unsigned i;
- unsigned flags, swab;
+ unsigned flags;

UFSD(("ENTER, ino %lu\n", inode->i_ino))

sb = inode->i_sb;
uspi = sb->u.ufs_sb.s_uspi;
flags = sb->u.ufs_sb.s_flags;
- swab = sb->u.ufs_sb.s_swab;

if (inode->i_ino < UFS_ROOTINO ||
inode->i_ino > (uspi->s_ncg * uspi->s_ipg)) {
@@ -626,30 +598,30 @@
}
ufs_inode = (struct ufs_inode *) (bh->b_data + ufs_inotofsbo(inode->i_ino) * sizeof(struct ufs_inode));

- ufs_inode->ui_mode = SWAB16(inode->i_mode);
- ufs_inode->ui_nlink = SWAB16(inode->i_nlink);
+ ufs_inode->ui_mode = cpu_to_fs16(sb, inode->i_mode);
+ ufs_inode->ui_nlink = cpu_to_fs16(sb, inode->i_nlink);

- ufs_set_inode_uid (ufs_inode, inode->i_uid);
- ufs_set_inode_gid (ufs_inode, inode->i_gid);
+ ufs_set_inode_uid(sb, ufs_inode, inode->i_uid);
+ ufs_set_inode_gid(sb, ufs_inode, inode->i_gid);

- ufs_inode->ui_size = SWAB64((u64)inode->i_size);
- ufs_inode->ui_atime.tv_sec = SWAB32(inode->i_atime);
- ufs_inode->ui_atime.tv_usec = SWAB32(0);
- ufs_inode->ui_ctime.tv_sec = SWAB32(inode->i_ctime);
- ufs_inode->ui_ctime.tv_usec = SWAB32(0);
- ufs_inode->ui_mtime.tv_sec = SWAB32(inode->i_mtime);
- ufs_inode->ui_mtime.tv_usec = SWAB32(0);
- ufs_inode->ui_blocks = SWAB32(inode->i_blocks);
- ufs_inode->ui_flags = SWAB32(inode->u.ufs_i.i_flags);
- ufs_inode->ui_gen = SWAB32(inode->u.ufs_i.i_gen);
+ ufs_inode->ui_size = cpu_to_fs64(sb, inode->i_size);
+ ufs_inode->ui_atime.tv_sec = cpu_to_fs32(sb, inode->i_atime);
+ ufs_inode->ui_atime.tv_usec = 0;
+ ufs_inode->ui_ctime.tv_sec = cpu_to_fs32(sb, inode->i_ctime);
+ ufs_inode->ui_ctime.tv_usec = 0;
+ ufs_inode->ui_mtime.tv_sec = cpu_to_fs32(sb, inode->i_mtime);
+ ufs_inode->ui_mtime.tv_usec = 0;
+ ufs_inode->ui_blocks = cpu_to_fs32(sb, inode->i_blocks);
+ ufs_inode->ui_flags = cpu_to_fs32(sb, inode->u.ufs_i.i_flags);
+ ufs_inode->ui_gen = cpu_to_fs32(sb, inode->u.ufs_i.i_gen);

if ((flags & UFS_UID_MASK) == UFS_UID_EFT) {
- ufs_inode->ui_u3.ui_sun.ui_shadow = SWAB32(inode->u.ufs_i.i_shadow);
- ufs_inode->ui_u3.ui_sun.ui_oeftflag = SWAB32(inode->u.ufs_i.i_oeftflag);
+ ufs_inode->ui_u3.ui_sun.ui_shadow = cpu_to_fs32(sb, inode->u.ufs_i.i_shadow);
+ ufs_inode->ui_u3.ui_sun.ui_oeftflag = cpu_to_fs32(sb, inode->u.ufs_i.i_oeftflag);
}

if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
- ufs_inode->ui_u2.ui_addr.ui_db[0] = SWAB32(kdev_t_to_nr(inode->i_rdev));
+ ufs_inode->ui_u2.ui_addr.ui_db[0] = cpu_to_fs32(sb, kdev_t_to_nr(inode->i_rdev));
else if (inode->i_blocks) {
for (i = 0; i < (UFS_NDADDR + UFS_NINDIR); i++)
ufs_inode->ui_u2.ui_addr.ui_db[i] = inode->u.ufs_i.i_u1.i_data[i];
diff -uNr -Xdontdiff ../master/linux-2.4.14-pre3/fs/ufs/super.c linux/fs/ufs/super.c
--- ../master/linux-2.4.14-pre3/fs/ufs/super.c Wed May 16 19:31:27 2001
+++ linux/fs/ufs/super.c Mon Oct 29 16:46:54 2001
@@ -97,44 +97,45 @@
/*
* Print contents of ufs_super_block, useful for debugging
*/
-void ufs_print_super_stuff(struct ufs_super_block_first * usb1,
+void ufs_print_super_stuff(struct super_block *sb,
+ struct ufs_super_block_first * usb1,
struct ufs_super_block_second * usb2,
- struct ufs_super_block_third * usb3, unsigned swab)
+ struct ufs_super_block_third * usb3)
{
printk("ufs_print_super_stuff\n");
printk("size of usb: %u\n", sizeof(struct ufs_super_block));
- printk(" magic: 0x%x\n", SWAB32(usb3->fs_magic));
- printk(" sblkno: %u\n", SWAB32(usb1->fs_sblkno));
- printk(" cblkno: %u\n", SWAB32(usb1->fs_cblkno));
- printk(" iblkno: %u\n", SWAB32(usb1->fs_iblkno));
- printk(" dblkno: %u\n", SWAB32(usb1->fs_dblkno));
- printk(" cgoffset: %u\n", SWAB32(usb1->fs_cgoffset));
- printk(" ~cgmask: 0x%x\n", ~SWAB32(usb1->fs_cgmask));
- printk(" size: %u\n", SWAB32(usb1->fs_size));
- printk(" dsize: %u\n", SWAB32(usb1->fs_dsize));
- printk(" ncg: %u\n", SWAB32(usb1->fs_ncg));
- printk(" bsize: %u\n", SWAB32(usb1->fs_bsize));
- printk(" fsize: %u\n", SWAB32(usb1->fs_fsize));
- printk(" frag: %u\n", SWAB32(usb1->fs_frag));
- printk(" fragshift: %u\n", SWAB32(usb1->fs_fragshift));
- printk(" ~fmask: %u\n", ~SWAB32(usb1->fs_fmask));
- printk(" fshift: %u\n", SWAB32(usb1->fs_fshift));
- printk(" sbsize: %u\n", SWAB32(usb1->fs_sbsize));
- printk(" spc: %u\n", SWAB32(usb1->fs_spc));
- printk(" cpg: %u\n", SWAB32(usb1->fs_cpg));
- printk(" ipg: %u\n", SWAB32(usb1->fs_ipg));
- printk(" fpg: %u\n", SWAB32(usb1->fs_fpg));
- printk(" csaddr: %u\n", SWAB32(usb1->fs_csaddr));
- printk(" cssize: %u\n", SWAB32(usb1->fs_cssize));
- printk(" cgsize: %u\n", SWAB32(usb1->fs_cgsize));
- printk(" fstodb: %u\n", SWAB32(usb1->fs_fsbtodb));
- printk(" contigsumsize: %d\n", SWAB32(usb3->fs_u2.fs_44.fs_contigsumsize));
- printk(" postblformat: %u\n", SWAB32(usb3->fs_postblformat));
- printk(" nrpos: %u\n", SWAB32(usb3->fs_nrpos));
- printk(" ndir %u\n", SWAB32(usb1->fs_cstotal.cs_ndir));
- printk(" nifree %u\n", SWAB32(usb1->fs_cstotal.cs_nifree));
- printk(" nbfree %u\n", SWAB32(usb1->fs_cstotal.cs_nbfree));
- printk(" nffree %u\n", SWAB32(usb1->fs_cstotal.cs_nffree));
+ printk(" magic: 0x%x\n", fs32_to_cpu(sb, usb3->fs_magic));
+ printk(" sblkno: %u\n", fs32_to_cpu(sb, usb1->fs_sblkno));
+ printk(" cblkno: %u\n", fs32_to_cpu(sb, usb1->fs_cblkno));
+ printk(" iblkno: %u\n", fs32_to_cpu(sb, usb1->fs_iblkno));
+ printk(" dblkno: %u\n", fs32_to_cpu(sb, usb1->fs_dblkno));
+ printk(" cgoffset: %u\n", fs32_to_cpu(sb, usb1->fs_cgoffset));
+ printk(" ~cgmask: 0x%x\n", ~fs32_to_cpu(sb, usb1->fs_cgmask));
+ printk(" size: %u\n", fs32_to_cpu(sb, usb1->fs_size));
+ printk(" dsize: %u\n", fs32_to_cpu(sb, usb1->fs_dsize));
+ printk(" ncg: %u\n", fs32_to_cpu(sb, usb1->fs_ncg));
+ printk(" bsize: %u\n", fs32_to_cpu(sb, usb1->fs_bsize));
+ printk(" fsize: %u\n", fs32_to_cpu(sb, usb1->fs_fsize));
+ printk(" frag: %u\n", fs32_to_cpu(sb, usb1->fs_frag));
+ printk(" fragshift: %u\n", fs32_to_cpu(sb, usb1->fs_fragshift));
+ printk(" ~fmask: %u\n", ~fs32_to_cpu(sb, usb1->fs_fmask));
+ printk(" fshift: %u\n", fs32_to_cpu(sb, usb1->fs_fshift));
+ printk(" sbsize: %u\n", fs32_to_cpu(sb, usb1->fs_sbsize));
+ printk(" spc: %u\n", fs32_to_cpu(sb, usb1->fs_spc));
+ printk(" cpg: %u\n", fs32_to_cpu(sb, usb1->fs_cpg));
+ printk(" ipg: %u\n", fs32_to_cpu(sb, usb1->fs_ipg));
+ printk(" fpg: %u\n", fs32_to_cpu(sb, usb1->fs_fpg));
+ printk(" csaddr: %u\n", fs32_to_cpu(sb, usb1->fs_csaddr));
+ printk(" cssize: %u\n", fs32_to_cpu(sb, usb1->fs_cssize));
+ printk(" cgsize: %u\n", fs32_to_cpu(sb, usb1->fs_cgsize));
+ printk(" fstodb: %u\n", fs32_to_cpu(sb, usb1->fs_fsbtodb));
+ printk(" contigsumsize: %d\n", fs32_to_cpu(sb, usb3->fs_u2.fs_44.fs_contigsumsize));
+ printk(" postblformat: %u\n", fs32_to_cpu(sb, usb3->fs_postblformat));
+ printk(" nrpos: %u\n", fs32_to_cpu(sb, usb3->fs_nrpos));
+ printk(" ndir %u\n", fs32_to_cpu(sb, usb1->fs_cstotal.cs_ndir));
+ printk(" nifree %u\n", fs32_to_cpu(sb, usb1->fs_cstotal.cs_nifree));
+ printk(" nbfree %u\n", fs32_to_cpu(sb, usb1->fs_cstotal.cs_nbfree));
+ printk(" nffree %u\n", fs32_to_cpu(sb, usb1->fs_cstotal.cs_nffree));
printk("\n");
}

@@ -142,36 +143,36 @@
/*
* Print contents of ufs_cylinder_group, useful for debugging
*/
-void ufs_print_cylinder_stuff(struct ufs_cylinder_group *cg, unsigned swab)
+void ufs_print_cylinder_stuff(struct super_block *sb, struct ufs_cylinder_group *cg)
{
printk("\nufs_print_cylinder_stuff\n");
printk("size of ucg: %u\n", sizeof(struct ufs_cylinder_group));
- printk(" magic: %x\n", SWAB32(cg->cg_magic));
- printk(" time: %u\n", SWAB32(cg->cg_time));
- printk(" cgx: %u\n", SWAB32(cg->cg_cgx));
- printk(" ncyl: %u\n", SWAB16(cg->cg_ncyl));
- printk(" niblk: %u\n", SWAB16(cg->cg_niblk));
- printk(" ndblk: %u\n", SWAB32(cg->cg_ndblk));
- printk(" cs_ndir: %u\n", SWAB32(cg->cg_cs.cs_ndir));
- printk(" cs_nbfree: %u\n", SWAB32(cg->cg_cs.cs_nbfree));
- printk(" cs_nifree: %u\n", SWAB32(cg->cg_cs.cs_nifree));
- printk(" cs_nffree: %u\n", SWAB32(cg->cg_cs.cs_nffree));
- printk(" rotor: %u\n", SWAB32(cg->cg_rotor));
- printk(" frotor: %u\n", SWAB32(cg->cg_frotor));
- printk(" irotor: %u\n", SWAB32(cg->cg_irotor));
+ printk(" magic: %x\n", fs32_to_cpu(sb, cg->cg_magic));
+ printk(" time: %u\n", fs32_to_cpu(sb, cg->cg_time));
+ printk(" cgx: %u\n", fs32_to_cpu(sb, cg->cg_cgx));
+ printk(" ncyl: %u\n", fs16_to_cpu(sb, cg->cg_ncyl));
+ printk(" niblk: %u\n", fs16_to_cpu(sb, cg->cg_niblk));
+ printk(" ndblk: %u\n", fs32_to_cpu(sb, cg->cg_ndblk));
+ printk(" cs_ndir: %u\n", fs32_to_cpu(sb, cg->cg_cs.cs_ndir));
+ printk(" cs_nbfree: %u\n", fs32_to_cpu(sb, cg->cg_cs.cs_nbfree));
+ printk(" cs_nifree: %u\n", fs32_to_cpu(sb, cg->cg_cs.cs_nifree));
+ printk(" cs_nffree: %u\n", fs32_to_cpu(sb, cg->cg_cs.cs_nffree));
+ printk(" rotor: %u\n", fs32_to_cpu(sb, cg->cg_rotor));
+ printk(" frotor: %u\n", fs32_to_cpu(sb, cg->cg_frotor));
+ printk(" irotor: %u\n", fs32_to_cpu(sb, cg->cg_irotor));
printk(" frsum: %u, %u, %u, %u, %u, %u, %u, %u\n",
- SWAB32(cg->cg_frsum[0]), SWAB32(cg->cg_frsum[1]),
- SWAB32(cg->cg_frsum[2]), SWAB32(cg->cg_frsum[3]),
- SWAB32(cg->cg_frsum[4]), SWAB32(cg->cg_frsum[5]),
- SWAB32(cg->cg_frsum[6]), SWAB32(cg->cg_frsum[7]));
- printk(" btotoff: %u\n", SWAB32(cg->cg_btotoff));
- printk(" boff: %u\n", SWAB32(cg->cg_boff));
- printk(" iuseoff: %u\n", SWAB32(cg->cg_iusedoff));
- printk(" freeoff: %u\n", SWAB32(cg->cg_freeoff));
- printk(" nextfreeoff: %u\n", SWAB32(cg->cg_nextfreeoff));
- printk(" clustersumoff %u\n", SWAB32(cg->cg_u.cg_44.cg_clustersumoff));
- printk(" clusteroff %u\n", SWAB32(cg->cg_u.cg_44.cg_clusteroff));
- printk(" nclusterblks %u\n", SWAB32(cg->cg_u.cg_44.cg_nclusterblks));
+ fs32_to_cpu(sb, cg->cg_frsum[0]), fs32_to_cpu(sb, cg->cg_frsum[1]),
+ fs32_to_cpu(sb, cg->cg_frsum[2]), fs32_to_cpu(sb, cg->cg_frsum[3]),
+ fs32_to_cpu(sb, cg->cg_frsum[4]), fs32_to_cpu(sb, cg->cg_frsum[5]),
+ fs32_to_cpu(sb, cg->cg_frsum[6]), fs32_to_cpu(sb, cg->cg_frsum[7]));
+ printk(" btotoff: %u\n", fs32_to_cpu(sb, cg->cg_btotoff));
+ printk(" boff: %u\n", fs32_to_cpu(sb, cg->cg_boff));
+ printk(" iuseoff: %u\n", fs32_to_cpu(sb, cg->cg_iusedoff));
+ printk(" freeoff: %u\n", fs32_to_cpu(sb, cg->cg_freeoff));
+ printk(" nextfreeoff: %u\n", fs32_to_cpu(sb, cg->cg_nextfreeoff));
+ printk(" clustersumoff %u\n", fs32_to_cpu(sb, cg->cg_u.cg_44.cg_clustersumoff));
+ printk(" clusteroff %u\n", fs32_to_cpu(sb, cg->cg_u.cg_44.cg_clusteroff));
+ printk(" nclusterblks %u\n", fs32_to_cpu(sb, cg->cg_u.cg_44.cg_nclusterblks));
printk("\n");
}
#endif /* UFS_SUPER_DEBUG_MORE */
@@ -320,12 +321,10 @@
struct ufs_buffer_head * ubh;
unsigned char * base, * space;
unsigned size, blks, i;
- unsigned swab;

UFSD(("ENTER\n"))

uspi = sb->u.ufs_sb.s_uspi;
- swab = sb->u.ufs_sb.s_swab;

/*
* Read cs structures from (usually) first data block
@@ -366,10 +365,10 @@
UFSD(("read cg %u\n", i))
if (!(sb->u.ufs_sb.s_ucg[i] = bread (sb->s_dev, ufs_cgcmin(i), sb->s_blocksize)))
goto failed;
- if (!ufs_cg_chkmagic ((struct ufs_cylinder_group *) sb->u.ufs_sb.s_ucg[i]->b_data))
+ if (!ufs_cg_chkmagic (sb, (struct ufs_cylinder_group *) sb->u.ufs_sb.s_ucg[i]->b_data))
goto failed;
#ifdef UFS_SUPER_DEBUG_MORE
- ufs_print_cylinder_stuff((struct ufs_cylinder_group *) sb->u.ufs_sb.s_ucg[i]->b_data, swab);
+ ufs_print_cylinder_stuff(sb, (struct ufs_cylinder_group *) sb->u.ufs_sb.s_ucg[i]->b_data);
#endif
}
for (i = 0; i < UFS_MAX_GROUP_LOADED; i++) {
@@ -444,12 +443,11 @@
struct ufs_super_block_third * usb3;
struct ufs_buffer_head * ubh;
unsigned block_size, super_block_size;
- unsigned flags, swab;
+ unsigned flags;

uspi = NULL;
ubh = NULL;
flags = 0;
- swab = 0;

UFSD(("ENTER\n"))

@@ -614,37 +612,22 @@
/*
* Check ufs magic number
*/
-#if defined(__LITTLE_ENDIAN) || defined(__BIG_ENDIAN) /* sane bytesex */
- switch (usb3->fs_magic) {
+ switch (__constant_le32_to_cpu(usb3->fs_magic)) {
case UFS_MAGIC:
- case UFS_MAGIC_LFN:
+ case UFS_MAGIC_LFN:
case UFS_MAGIC_FEA:
case UFS_MAGIC_4GB:
- swab = UFS_NATIVE_ENDIAN;
- goto magic_found;
- case UFS_CIGAM:
- case UFS_CIGAM_LFN:
- case UFS_CIGAM_FEA:
- case UFS_CIGAM_4GB:
- swab = UFS_SWABBED_ENDIAN;
+ sb->u.ufs_sb.s_bytesex = BYTESEX_LE;
goto magic_found;
}
-#else /* bytesex perversion */
- switch (le32_to_cpup(&usb3->fs_magic)) {
+ switch (__constant_be32_to_cpu(usb3->fs_magic)) {
case UFS_MAGIC:
case UFS_MAGIC_LFN:
case UFS_MAGIC_FEA:
case UFS_MAGIC_4GB:
- swab = UFS_LITTLE_ENDIAN;
- goto magic_found;
- case UFS_CIGAM:
- case UFS_CIGAM_LFN:
- case UFS_CIGAM_FEA:
- case UFS_CIGAM_4GB:
- swab = UFS_BIG_ENDIAN;
+ sb->u.ufs_sb.s_bytesex = BYTESEX_BE;
goto magic_found;
}
-#endif

if ((((sb->u.ufs_sb.s_mount_opt & UFS_MOUNT_UFSTYPE) == UFS_MOUNT_UFSTYPE_NEXTSTEP)
|| ((sb->u.ufs_sb.s_mount_opt & UFS_MOUNT_UFSTYPE) == UFS_MOUNT_UFSTYPE_NEXTSTEP_CD)
@@ -662,11 +645,11 @@
/*
* Check block and fragment sizes
*/
- uspi->s_bsize = SWAB32(usb1->fs_bsize);
- uspi->s_fsize = SWAB32(usb1->fs_fsize);
- uspi->s_sbsize = SWAB32(usb1->fs_sbsize);
- uspi->s_fmask = SWAB32(usb1->fs_fmask);
- uspi->s_fshift = SWAB32(usb1->fs_fshift);
+ uspi->s_bsize = fs32_to_cpu(sb, usb1->fs_bsize);
+ uspi->s_fsize = fs32_to_cpu(sb, usb1->fs_fsize);
+ uspi->s_sbsize = fs32_to_cpu(sb, usb1->fs_sbsize);
+ uspi->s_fmask = fs32_to_cpu(sb, usb1->fs_fmask);
+ uspi->s_fshift = fs32_to_cpu(sb, usb1->fs_fshift);

if (uspi->s_bsize != 4096 && uspi->s_bsize != 8192
&& uspi->s_bsize != 32768) {
@@ -688,7 +671,7 @@
}

#ifdef UFS_SUPER_DEBUG_MORE
- ufs_print_super_stuff (usb1, usb2, usb3, swab);
+ ufs_print_super_stuff(sb, usb1, usb2, usb3);
#endif

/*
@@ -699,7 +682,7 @@
((flags & UFS_ST_MASK) == UFS_ST_OLD) ||
(((flags & UFS_ST_MASK) == UFS_ST_SUN ||
(flags & UFS_ST_MASK) == UFS_ST_SUNx86) &&
- (ufs_get_fs_state(usb1, usb3) == (UFS_FSOK - SWAB32(usb1->fs_time))))) {
+ (ufs_get_fs_state(sb, usb1, usb3) == (UFS_FSOK - fs32_to_cpu(sb, usb1->fs_time))))) {
switch(usb1->fs_clean) {
case UFS_FSCLEAN:
UFSD(("fs is clean\n"))
@@ -732,56 +715,56 @@
/*
* Read ufs_super_block into internal data structures
*/
- sb->s_blocksize = SWAB32(usb1->fs_fsize);
- sb->s_blocksize_bits = SWAB32(usb1->fs_fshift);
+ sb->s_blocksize = fs32_to_cpu(sb, usb1->fs_fsize);
+ sb->s_blocksize_bits = fs32_to_cpu(sb, usb1->fs_fshift);
sb->s_op = &ufs_super_ops;
sb->dq_op = NULL; /***/
- sb->s_magic = SWAB32(usb3->fs_magic);
+ sb->s_magic = fs32_to_cpu(sb, usb3->fs_magic);

- uspi->s_sblkno = SWAB32(usb1->fs_sblkno);
- uspi->s_cblkno = SWAB32(usb1->fs_cblkno);
- uspi->s_iblkno = SWAB32(usb1->fs_iblkno);
- uspi->s_dblkno = SWAB32(usb1->fs_dblkno);
- uspi->s_cgoffset = SWAB32(usb1->fs_cgoffset);
- uspi->s_cgmask = SWAB32(usb1->fs_cgmask);
- uspi->s_size = SWAB32(usb1->fs_size);
- uspi->s_dsize = SWAB32(usb1->fs_dsize);
- uspi->s_ncg = SWAB32(usb1->fs_ncg);
+ uspi->s_sblkno = fs32_to_cpu(sb, usb1->fs_sblkno);
+ uspi->s_cblkno = fs32_to_cpu(sb, usb1->fs_cblkno);
+ uspi->s_iblkno = fs32_to_cpu(sb, usb1->fs_iblkno);
+ uspi->s_dblkno = fs32_to_cpu(sb, usb1->fs_dblkno);
+ uspi->s_cgoffset = fs32_to_cpu(sb, usb1->fs_cgoffset);
+ uspi->s_cgmask = fs32_to_cpu(sb, usb1->fs_cgmask);
+ uspi->s_size = fs32_to_cpu(sb, usb1->fs_size);
+ uspi->s_dsize = fs32_to_cpu(sb, usb1->fs_dsize);
+ uspi->s_ncg = fs32_to_cpu(sb, usb1->fs_ncg);
/* s_bsize already set */
/* s_fsize already set */
- uspi->s_fpb = SWAB32(usb1->fs_frag);
- uspi->s_minfree = SWAB32(usb1->fs_minfree);
- uspi->s_bmask = SWAB32(usb1->fs_bmask);
- uspi->s_fmask = SWAB32(usb1->fs_fmask);
- uspi->s_bshift = SWAB32(usb1->fs_bshift);
- uspi->s_fshift = SWAB32(usb1->fs_fshift);
- uspi->s_fpbshift = SWAB32(usb1->fs_fragshift);
- uspi->s_fsbtodb = SWAB32(usb1->fs_fsbtodb);
+ uspi->s_fpb = fs32_to_cpu(sb, usb1->fs_frag);
+ uspi->s_minfree = fs32_to_cpu(sb, usb1->fs_minfree);
+ uspi->s_bmask = fs32_to_cpu(sb, usb1->fs_bmask);
+ uspi->s_fmask = fs32_to_cpu(sb, usb1->fs_fmask);
+ uspi->s_bshift = fs32_to_cpu(sb, usb1->fs_bshift);
+ uspi->s_fshift = fs32_to_cpu(sb, usb1->fs_fshift);
+ uspi->s_fpbshift = fs32_to_cpu(sb, usb1->fs_fragshift);
+ uspi->s_fsbtodb = fs32_to_cpu(sb, usb1->fs_fsbtodb);
/* s_sbsize already set */
- uspi->s_csmask = SWAB32(usb1->fs_csmask);
- uspi->s_csshift = SWAB32(usb1->fs_csshift);
- uspi->s_nindir = SWAB32(usb1->fs_nindir);
- uspi->s_inopb = SWAB32(usb1->fs_inopb);
- uspi->s_nspf = SWAB32(usb1->fs_nspf);
- uspi->s_npsect = ufs_get_fs_npsect(usb1, usb3);
- uspi->s_interleave = SWAB32(usb1->fs_interleave);
- uspi->s_trackskew = SWAB32(usb1->fs_trackskew);
- uspi->s_csaddr = SWAB32(usb1->fs_csaddr);
- uspi->s_cssize = SWAB32(usb1->fs_cssize);
- uspi->s_cgsize = SWAB32(usb1->fs_cgsize);
- uspi->s_ntrak = SWAB32(usb1->fs_ntrak);
- uspi->s_nsect = SWAB32(usb1->fs_nsect);
- uspi->s_spc = SWAB32(usb1->fs_spc);
- uspi->s_ipg = SWAB32(usb1->fs_ipg);
- uspi->s_fpg = SWAB32(usb1->fs_fpg);
- uspi->s_cpc = SWAB32(usb2->fs_cpc);
- uspi->s_contigsumsize = SWAB32(usb3->fs_u2.fs_44.fs_contigsumsize);
- uspi->s_qbmask = ufs_get_fs_qbmask(usb3);
- uspi->s_qfmask = ufs_get_fs_qfmask(usb3);
- uspi->s_postblformat = SWAB32(usb3->fs_postblformat);
- uspi->s_nrpos = SWAB32(usb3->fs_nrpos);
- uspi->s_postbloff = SWAB32(usb3->fs_postbloff);
- uspi->s_rotbloff = SWAB32(usb3->fs_rotbloff);
+ uspi->s_csmask = fs32_to_cpu(sb, usb1->fs_csmask);
+ uspi->s_csshift = fs32_to_cpu(sb, usb1->fs_csshift);
+ uspi->s_nindir = fs32_to_cpu(sb, usb1->fs_nindir);
+ uspi->s_inopb = fs32_to_cpu(sb, usb1->fs_inopb);
+ uspi->s_nspf = fs32_to_cpu(sb, usb1->fs_nspf);
+ uspi->s_npsect = ufs_get_fs_npsect(sb, usb1, usb3);
+ uspi->s_interleave = fs32_to_cpu(sb, usb1->fs_interleave);
+ uspi->s_trackskew = fs32_to_cpu(sb, usb1->fs_trackskew);
+ uspi->s_csaddr = fs32_to_cpu(sb, usb1->fs_csaddr);
+ uspi->s_cssize = fs32_to_cpu(sb, usb1->fs_cssize);
+ uspi->s_cgsize = fs32_to_cpu(sb, usb1->fs_cgsize);
+ uspi->s_ntrak = fs32_to_cpu(sb, usb1->fs_ntrak);
+ uspi->s_nsect = fs32_to_cpu(sb, usb1->fs_nsect);
+ uspi->s_spc = fs32_to_cpu(sb, usb1->fs_spc);
+ uspi->s_ipg = fs32_to_cpu(sb, usb1->fs_ipg);
+ uspi->s_fpg = fs32_to_cpu(sb, usb1->fs_fpg);
+ uspi->s_cpc = fs32_to_cpu(sb, usb2->fs_cpc);
+ uspi->s_contigsumsize = fs32_to_cpu(sb, usb3->fs_u2.fs_44.fs_contigsumsize);
+ uspi->s_qbmask = ufs_get_fs_qbmask(sb, usb3);
+ uspi->s_qfmask = ufs_get_fs_qfmask(sb, usb3);
+ uspi->s_postblformat = fs32_to_cpu(sb, usb3->fs_postblformat);
+ uspi->s_nrpos = fs32_to_cpu(sb, usb3->fs_nrpos);
+ uspi->s_postbloff = fs32_to_cpu(sb, usb3->fs_postbloff);
+ uspi->s_rotbloff = fs32_to_cpu(sb, usb3->fs_rotbloff);

/*
* Compute another frequently used values
@@ -803,11 +786,9 @@
if ((sb->u.ufs_sb.s_mount_opt & UFS_MOUNT_UFSTYPE) ==
UFS_MOUNT_UFSTYPE_44BSD)
uspi->s_maxsymlinklen =
- SWAB32(usb3->fs_u2.fs_44.fs_maxsymlinklen);
+ fs32_to_cpu(sb, usb3->fs_u2.fs_44.fs_maxsymlinklen);

sb->u.ufs_sb.s_flags = flags;
- sb->u.ufs_sb.s_swab = swab;
-
sb->s_root = d_alloc_root(iget(sb, UFS_ROOTINO));


@@ -832,20 +813,20 @@
struct ufs_sb_private_info * uspi;
struct ufs_super_block_first * usb1;
struct ufs_super_block_third * usb3;
- unsigned flags, swab;
+ unsigned flags;

UFSD(("ENTER\n"))
- swab = sb->u.ufs_sb.s_swab;
flags = sb->u.ufs_sb.s_flags;
uspi = sb->u.ufs_sb.s_uspi;
usb1 = ubh_get_usb_first(USPI_UBH);
usb3 = ubh_get_usb_third(USPI_UBH);

if (!(sb->s_flags & MS_RDONLY)) {
- usb1->fs_time = SWAB32(CURRENT_TIME);
+ usb1->fs_time = cpu_to_fs32(sb, CURRENT_TIME);
if ((flags & UFS_ST_MASK) == UFS_ST_SUN
|| (flags & UFS_ST_MASK) == UFS_ST_SUNx86)
- ufs_set_fs_state(usb1, usb3, UFS_FSOK - SWAB32(usb1->fs_time));
+ ufs_set_fs_state(sb, usb1, usb3,
+ UFS_FSOK - fs32_to_cpu(sb, usb1->fs_time));
ubh_mark_buffer_dirty (USPI_UBH);
}
sb->s_dirt = 0;
@@ -855,12 +836,10 @@
void ufs_put_super (struct super_block * sb)
{
struct ufs_sb_private_info * uspi;
- unsigned swab;

UFSD(("ENTER\n"))

uspi = sb->u.ufs_sb.s_uspi;
- swab = sb->u.ufs_sb.s_swab;

if (!(sb->s_flags & MS_RDONLY))
ufs_put_cylinder_structures (sb);
@@ -877,11 +856,10 @@
struct ufs_super_block_first * usb1;
struct ufs_super_block_third * usb3;
unsigned new_mount_opt, ufstype;
- unsigned flags, swab;
+ unsigned flags;

uspi = sb->u.ufs_sb.s_uspi;
flags = sb->u.ufs_sb.s_flags;
- swab = sb->u.ufs_sb.s_swab;
usb1 = ubh_get_usb_first(USPI_UBH);
usb3 = ubh_get_usb_third(USPI_UBH);

@@ -912,10 +890,11 @@
*/
if (*mount_flags & MS_RDONLY) {
ufs_put_cylinder_structures(sb);
- usb1->fs_time = SWAB32(CURRENT_TIME);
+ usb1->fs_time = cpu_to_fs32(sb, CURRENT_TIME);
if ((flags & UFS_ST_MASK) == UFS_ST_SUN
|| (flags & UFS_ST_MASK) == UFS_ST_SUNx86)
- ufs_set_fs_state(usb1, usb3, UFS_FSOK - SWAB32(usb1->fs_time));
+ ufs_set_fs_state(sb, usb1, usb3,
+ UFS_FSOK - fs32_to_cpu(sb, usb1->fs_time));
ubh_mark_buffer_dirty (USPI_UBH);
sb->s_dirt = 0;
sb->s_flags |= MS_RDONLY;
@@ -950,21 +929,19 @@
{
struct ufs_sb_private_info * uspi;
struct ufs_super_block_first * usb1;
- unsigned swab;

- swab = sb->u.ufs_sb.s_swab;
uspi = sb->u.ufs_sb.s_uspi;
usb1 = ubh_get_usb_first (USPI_UBH);

buf->f_type = UFS_MAGIC;
buf->f_bsize = sb->s_blocksize;
buf->f_blocks = uspi->s_dsize;
- buf->f_bfree = ufs_blkstofrags(SWAB32(usb1->fs_cstotal.cs_nbfree)) +
- SWAB32(usb1->fs_cstotal.cs_nffree);
+ buf->f_bfree = ufs_blkstofrags(fs32_to_cpu(sb, usb1->fs_cstotal.cs_nbfree)) +
+ fs32_to_cpu(sb, usb1->fs_cstotal.cs_nffree);
buf->f_bavail = (buf->f_bfree > ((buf->f_blocks / 100) * uspi->s_minfree))
? (buf->f_bfree - ((buf->f_blocks / 100) * uspi->s_minfree)) : 0;
buf->f_files = uspi->s_ncg * uspi->s_ipg;
- buf->f_ffree = SWAB32(usb1->fs_cstotal.cs_nifree);
+ buf->f_ffree = fs32_to_cpu(sb, usb1->fs_cstotal.cs_nifree);
buf->f_namelen = UFS_MAXNAMLEN;
return 0;
}
diff -uNr -Xdontdiff ../master/linux-2.4.14-pre3/fs/ufs/swab.h linux/fs/ufs/swab.h
--- ../master/linux-2.4.14-pre3/fs/ufs/swab.h Mon Dec 11 22:26:44 2000
+++ linux/fs/ufs/swab.h Mon Oct 29 16:46:54 2001
@@ -3,6 +3,7 @@
*
* Copyright (C) 1997, 1998 Francois-Rene Rideau <fare@tunes.org>
* Copyright (C) 1998 Jakub Jelinek <jj@ultra.linux.cz>
+ * Copyright (C) 2001 Christoph Hellwig <hch@caldera.de>
*/

#ifndef _UFS_SWAB_H
@@ -14,124 +15,119 @@
* in case there are ufs implementations that have strange bytesexes,
* you'll need to modify code here as well as in ufs_super.c and ufs_fs.h
* to support them.
- *
- * WE ALSO ASSUME A REMOTELY SANE ARCHITECTURE BYTESEX.
- * We are not ready to confront insane bytesexual perversions where
- * conversion to/from little/big-endian is not an involution.
- * That is, we require that XeYZ_to_cpu(x) == cpu_to_XeYZ(x)
- *
- * NOTE that swab macros depend on a variable (or macro) swab being in
- * scope and properly initialized (usually from sb->u.ufs_sb.s_swab).
- * Its meaning depends on whether the architecture is sane-endian or not.
- * For sane architectures, it's a flag taking values UFS_NATIVE_ENDIAN (0)
- * or UFS_SWABBED_ENDIAN (1), indicating whether to swab or not.
- * For pervert architectures, it's either UFS_LITTLE_ENDIAN or
- * UFS_BIG_ENDIAN whose meaning you'll have to guess.
- *
- * It is important to keep these conventions in synch with ufs_fs.h
- * and super.c. Failure to do so (initializing swab to 0 both for
- * NATIVE_ENDIAN and LITTLE_ENDIAN) led to nasty crashes on big endian
- * machines reading little endian UFSes. Search for "swab =" in super.c.
- *
- * I also suspect the whole UFS code to trust the on-disk structures
- * much too much, which might lead to losing badly when mounting
- * inconsistent partitions as UFS filesystems. fsck required (but of
- * course, no fsck.ufs has yet to be ported from BSD to Linux as of 199808).
- */
-
-#include <linux/ufs_fs.h>
-#include <asm/byteorder.h>
-
-/*
- * These are only valid inside ufs routines,
- * after swab has been initialized to sb->u.ufs_sb.s_swab
*/
-#define SWAB16(x) ufs_swab16(swab,x)
-#define SWAB32(x) ufs_swab32(swab,x)
-#define SWAB64(x) ufs_swab64(swab,x)

-/*
- * We often use swabing, when we want to increment/decrement some value,
- * so these macros might become handy and increase readability. (Daniel)
- */
-#define INC_SWAB16(x) ((x)=ufs_swab16_add(swab,x,1))
-#define INC_SWAB32(x) ((x)=ufs_swab32_add(swab,x,1))
-#define INC_SWAB64(x) ((x)=ufs_swab64_add(swab,x,1))
-#define DEC_SWAB16(x) ((x)=ufs_swab16_add(swab,x,-1))
-#define DEC_SWAB32(x) ((x)=ufs_swab32_add(swab,x,-1))
-#define DEC_SWAB64(x) ((x)=ufs_swab64_add(swab,x,-1))
-#define ADD_SWAB16(x,y) ((x)=ufs_swab16_add(swab,x,y))
-#define ADD_SWAB32(x,y) ((x)=ufs_swab32_add(swab,x,y))
-#define ADD_SWAB64(x,y) ((x)=ufs_swab64_add(swab,x,y))
-#define SUB_SWAB16(x,y) ((x)=ufs_swab16_add(swab,x,-(y)))
-#define SUB_SWAB32(x,y) ((x)=ufs_swab32_add(swab,x,-(y)))
-#define SUB_SWAB64(x,y) ((x)=ufs_swab64_add(swab,x,-(y)))
+enum {
+ BYTESEX_LE,
+ BYTESEX_BE
+};

-#if defined(__LITTLE_ENDIAN) || defined(__BIG_ENDIAN) /* sane bytesex */
-extern __inline__ __const__ __u16 ufs_swab16(unsigned swab, __u16 x) {
- if (swab)
- return swab16(x);
+static __inline u64
+fs64_to_cpu(struct super_block *sbp, u64 n)
+{
+ if (sbp->u.ufs_sb.s_bytesex == BYTESEX_LE)
+ return le64_to_cpu(n);
else
- return x;
+ return be64_to_cpu(n);
}
-extern __inline__ __const__ __u32 ufs_swab32(unsigned swab, __u32 x) {
- if (swab)
- return swab32(x);
+
+static __inline u64
+cpu_to_fs64(struct super_block *sbp, u64 n)
+{
+ if (sbp->u.ufs_sb.s_bytesex == BYTESEX_LE)
+ return cpu_to_le64(n);
else
- return x;
+ return cpu_to_be64(n);
}
-extern __inline__ __const__ __u64 ufs_swab64(unsigned swab, __u64 x) {
- if (swab)
- return swab64(x);
+
+static __inline u32
+fs64_add(struct super_block *sbp, u32 *n, int d)
+{
+ if (sbp->u.ufs_sb.s_bytesex == BYTESEX_LE)
+ return *n = cpu_to_le64(le64_to_cpu(*n)+d);
else
- return x;
+ return *n = cpu_to_be64(be64_to_cpu(*n)+d);
}
-extern __inline__ __const__ __u16 ufs_swab16_add(unsigned swab, __u16 x, __u16 y) {
- if (swab)
- return swab16(swab16(x)+y);
+
+static __inline u32
+fs64_sub(struct super_block *sbp, u32 *n, int d)
+{
+ if (sbp->u.ufs_sb.s_bytesex == BYTESEX_LE)
+ return *n = cpu_to_le64(le64_to_cpu(*n)-d);
else
- return x + y;
+ return *n = cpu_to_be64(be64_to_cpu(*n)-d);
}
-extern __inline__ __const__ __u32 ufs_swab32_add(unsigned swab, __u32 x, __u32 y) {
- if (swab)
- return swab32(swab32(x)+y);
+
+static __inline u32
+fs32_to_cpu(struct super_block *sbp, u32 n)
+{
+ if (sbp->u.ufs_sb.s_bytesex == BYTESEX_LE)
+ return le32_to_cpu(n);
else
- return x + y;
+ return be32_to_cpu(n);
}
-extern __inline__ __const__ __u64 ufs_swab64_add(unsigned swab, __u64 x, __u64 y) {
- if (swab)
- return swab64(swab64(x)+y);
+
+static __inline u32
+cpu_to_fs32(struct super_block *sbp, u32 n)
+{
+ if (sbp->u.ufs_sb.s_bytesex == BYTESEX_LE)
+ return cpu_to_le32(n);
else
- return x + y;
+ return cpu_to_be32(n);
}
-#else /* bytesexual perversion -- BEWARE! Read note at top of file! */
-extern __inline__ __const__ __u16 ufs_swab16(unsigned swab, __u16 x) {
- if (swab == UFS_LITTLE_ENDIAN)
- return le16_to_cpu(x);
+
+static __inline u32
+fs32_add(struct super_block *sbp, u32 *n, int d)
+{
+ if (sbp->u.ufs_sb.s_bytesex == BYTESEX_LE)
+ return *n = cpu_to_le32(le32_to_cpu(*n)+d);
else
- return be16_to_cpu(x);
+ return *n = cpu_to_be32(be32_to_cpu(*n)+d);
}
-extern __inline__ __const__ __u32 ufs_swab32(unsigned swab, __u32 x) {
- if (swab == UFS_LITTLE_ENDIAN)
- return le32_to_cpu(x);
+
+static __inline u32
+fs32_sub(struct super_block *sbp, u32 *n, int d)
+{
+ if (sbp->u.ufs_sb.s_bytesex == BYTESEX_LE)
+ return *n = cpu_to_le32(le32_to_cpu(*n)-d);
else
- return be32_to_cpu(x);
+ return *n = cpu_to_be32(be32_to_cpu(*n)-d);
}
-extern __inline__ __const__ __u64 ufs_swab64(unsigned swab, __u64 x) {
- if (swab == UFS_LITTLE_ENDIAN)
- return le64_to_cpu(x);
+
+static __inline u16
+fs16_to_cpu(struct super_block *sbp, u16 n)
+{
+ if (sbp->u.ufs_sb.s_bytesex == BYTESEX_LE)
+ return le16_to_cpu(n);
else
- return be64_to_cpu(x);
+ return be16_to_cpu(n);
}
-extern __inline__ __const__ __u16 ufs_swab16_add(unsigned swab, __u16 x, __u16 y) {
- return ufs_swab16(swab, ufs_swab16(swab, x) + y);
+
+static __inline u16
+cpu_to_fs16(struct super_block *sbp, u16 n)
+{
+ if (sbp->u.ufs_sb.s_bytesex == BYTESEX_LE)
+ return cpu_to_le16(n);
+ else
+ return cpu_to_be16(n);
}
-extern __inline__ __const__ __u32 ufs_swab32_add(unsigned swab, __u32 x, __u32 y) {
- return ufs_swab32(swab, ufs_swab32(swab, x) + y);
+
+static __inline u16
+fs16_add(struct super_block *sbp, u16 *n, int d)
+{
+ if (sbp->u.ufs_sb.s_bytesex == BYTESEX_LE)
+ return *n = cpu_to_le16(le16_to_cpu(*n)+d);
+ else
+ return *n = cpu_to_be16(be16_to_cpu(*n)+d);
}
-extern __inline__ __const__ __u64 ufs_swab64_add(unsigned swab, __u64 x, __u64 y) {
- return ufs_swab64(swab, ufs_swab64(swab, x) + y);
+
+static __inline u16
+fs16_sub(struct super_block *sbp, u16 *n, int d)
+{
+ if (sbp->u.ufs_sb.s_bytesex == BYTESEX_LE)
+ return *n = cpu_to_le16(le16_to_cpu(*n)-d);
+ else
+ return *n = cpu_to_be16(be16_to_cpu(*n)-d);
}
-#endif /* byte sexuality */

#endif /* _UFS_SWAB_H */
diff -uNr -Xdontdiff ../master/linux-2.4.14-pre3/fs/ufs/truncate.c linux/fs/ufs/truncate.c
--- ../master/linux-2.4.14-pre3/fs/ufs/truncate.c Sun Sep 23 21:21:01 2001
+++ linux/fs/ufs/truncate.c Mon Oct 29 16:46:54 2001
@@ -75,12 +75,10 @@
unsigned frag_to_free, free_count;
unsigned i, j, tmp;
int retry;
- unsigned swab;

UFSD(("ENTER\n"))

sb = inode->i_sb;
- swab = sb->u.ufs_sb.s_swab;
uspi = sb->u.ufs_sb.s_uspi;

frag_to_free = 0;
@@ -110,14 +108,14 @@
* Free first free fragments
*/
p = inode->u.ufs_i.i_u1.i_data + ufs_fragstoblks (frag1);
- tmp = SWAB32(*p);
+ tmp = fs32_to_cpu(sb, *p);
if (!tmp )
ufs_panic (sb, "ufs_trunc_direct", "internal error");
frag1 = ufs_fragnum (frag1);
frag2 = ufs_fragnum (frag2);
for (j = frag1; j < frag2; j++) {
bh = get_hash_table (sb->s_dev, tmp + j, uspi->s_fsize);
- if ((bh && DATA_BUFFER_USED(bh)) || tmp != SWAB32(*p)) {
+ if ((bh && DATA_BUFFER_USED(bh)) || tmp != fs32_to_cpu(sb, *p)) {
retry = 1;
brelse (bh);
goto next1;
@@ -135,19 +133,19 @@
*/
for (i = block1 ; i < block2; i++) {
p = inode->u.ufs_i.i_u1.i_data + i;
- tmp = SWAB32(*p);
+ tmp = fs32_to_cpu(sb, *p);
if (!tmp)
continue;
for (j = 0; j < uspi->s_fpb; j++) {
bh = get_hash_table (sb->s_dev, tmp + j, uspi->s_fsize);
- if ((bh && DATA_BUFFER_USED(bh)) || tmp != SWAB32(*p)) {
+ if ((bh && DATA_BUFFER_USED(bh)) || tmp != fs32_to_cpu(sb, *p)) {
retry = 1;
brelse (bh);
goto next2;
}
bforget (bh);
}
- *p = SWAB32(0);
+ *p = 0;
inode->i_blocks -= uspi->s_nspb;
mark_inode_dirty(inode);
if (free_count == 0) {
@@ -173,20 +171,20 @@
* Free last free fragments
*/
p = inode->u.ufs_i.i_u1.i_data + ufs_fragstoblks (frag3);
- tmp = SWAB32(*p);
+ tmp = fs32_to_cpu(sb, *p);
if (!tmp )
ufs_panic(sb, "ufs_truncate_direct", "internal error");
frag4 = ufs_fragnum (frag4);
for (j = 0; j < frag4; j++) {
bh = get_hash_table (sb->s_dev, tmp + j, uspi->s_fsize);
- if ((bh && DATA_BUFFER_USED(bh)) || tmp != SWAB32(*p)) {
+ if ((bh && DATA_BUFFER_USED(bh)) || tmp != fs32_to_cpu(sb, *p)) {
retry = 1;
brelse (bh);
goto next1;
}
bforget (bh);
}
- *p = SWAB32(0);
+ *p = 0;
inode->i_blocks -= frag4 << uspi->s_nspfshift;
mark_inode_dirty(inode);
ufs_free_fragments (inode, tmp, frag4);
@@ -207,47 +205,45 @@
unsigned indirect_block, i, j, tmp;
unsigned frag_to_free, free_count;
int retry;
- unsigned swab;

UFSD(("ENTER\n"))

sb = inode->i_sb;
- swab = sb->u.ufs_sb.s_swab;
uspi = sb->u.ufs_sb.s_uspi;

frag_to_free = 0;
free_count = 0;
retry = 0;

- tmp = SWAB32(*p);
+ tmp = fs32_to_cpu(sb, *p);
if (!tmp)
return 0;
ind_ubh = ubh_bread (sb->s_dev, tmp, uspi->s_bsize);
- if (tmp != SWAB32(*p)) {
+ if (tmp != fs32_to_cpu(sb, *p)) {
ubh_brelse (ind_ubh);
return 1;
}
if (!ind_ubh) {
- *p = SWAB32(0);
+ *p = 0;
return 0;
}

indirect_block = (DIRECT_BLOCK > offset) ? (DIRECT_BLOCK - offset) : 0;
for (i = indirect_block; i < uspi->s_apb; i++) {
ind = ubh_get_addr32 (ind_ubh, i);
- tmp = SWAB32(*ind);
+ tmp = fs32_to_cpu(sb, *ind);
if (!tmp)
continue;
for (j = 0; j < uspi->s_fpb; j++) {
bh = get_hash_table (sb->s_dev, tmp + j, uspi->s_fsize);
- if ((bh && DATA_BUFFER_USED(bh)) || tmp != SWAB32(*ind)) {
+ if ((bh && DATA_BUFFER_USED(bh)) || tmp != fs32_to_cpu(sb, *ind)) {
retry = 1;
brelse (bh);
goto next;
}
bforget (bh);
}
- *ind = SWAB32(0);
+ *ind = 0;
ubh_mark_buffer_dirty(ind_ubh);
if (free_count == 0) {
frag_to_free = tmp;
@@ -268,15 +264,15 @@
ufs_free_blocks (inode, frag_to_free, free_count);
}
for (i = 0; i < uspi->s_apb; i++)
- if (SWAB32(*ubh_get_addr32(ind_ubh,i)))
+ if (*ubh_get_addr32(ind_ubh,i))
break;
if (i >= uspi->s_apb) {
if (ubh_max_bcount(ind_ubh) != 1) {
retry = 1;
}
else {
- tmp = SWAB32(*p);
- *p = SWAB32(0);
+ tmp = fs32_to_cpu(sb, *p);
+ *p = 0;
inode->i_blocks -= uspi->s_nspb;
mark_inode_dirty(inode);
ufs_free_blocks (inode, tmp, uspi->s_fpb);
@@ -303,34 +299,32 @@
unsigned i, tmp, dindirect_block;
u32 * dind;
int retry = 0;
- unsigned swab;

UFSD(("ENTER\n"))

sb = inode->i_sb;
- swab = sb->u.ufs_sb.s_swab;
uspi = sb->u.ufs_sb.s_uspi;

dindirect_block = (DIRECT_BLOCK > offset)
? ((DIRECT_BLOCK - offset) >> uspi->s_apbshift) : 0;
retry = 0;

- tmp = SWAB32(*p);
+ tmp = fs32_to_cpu(sb, *p);
if (!tmp)
return 0;
dind_bh = ubh_bread (inode->i_dev, tmp, uspi->s_bsize);
- if (tmp != SWAB32(*p)) {
+ if (tmp != fs32_to_cpu(sb, *p)) {
ubh_brelse (dind_bh);
return 1;
}
if (!dind_bh) {
- *p = SWAB32(0);
+ *p = 0;
return 0;
}

for (i = dindirect_block ; i < uspi->s_apb ; i++) {
dind = ubh_get_addr32 (dind_bh, i);
- tmp = SWAB32(*dind);
+ tmp = fs32_to_cpu(sb, *dind);
if (!tmp)
continue;
retry |= ufs_trunc_indirect (inode, offset + (i << uspi->s_apbshift), dind);
@@ -338,14 +332,14 @@
}

for (i = 0; i < uspi->s_apb; i++)
- if (SWAB32(*ubh_get_addr32 (dind_bh, i)))
+ if (*ubh_get_addr32 (dind_bh, i))
break;
if (i >= uspi->s_apb) {
if (ubh_max_bcount(dind_bh) != 1)
retry = 1;
else {
- tmp = SWAB32(*p);
- *p = SWAB32(0);
+ tmp = fs32_to_cpu(sb, *p);
+ *p = 0;
inode->i_blocks -= uspi->s_nspb;
mark_inode_dirty(inode);
ufs_free_blocks (inode, tmp, uspi->s_fpb);
@@ -372,27 +366,25 @@
unsigned tindirect_block, tmp, i;
u32 * tind, * p;
int retry;
- unsigned swab;

UFSD(("ENTER\n"))

sb = inode->i_sb;
- swab = sb->u.ufs_sb.s_swab;
uspi = sb->u.ufs_sb.s_uspi;
retry = 0;

tindirect_block = (DIRECT_BLOCK > (UFS_NDADDR + uspi->s_apb + uspi->s_2apb))
? ((DIRECT_BLOCK - UFS_NDADDR - uspi->s_apb - uspi->s_2apb) >> uspi->s_2apbshift) : 0;
p = inode->u.ufs_i.i_u1.i_data + UFS_TIND_BLOCK;
- if (!(tmp = SWAB32(*p)))
+ if (!(tmp = fs32_to_cpu(sb, *p)))
return 0;
tind_bh = ubh_bread (sb->s_dev, tmp, uspi->s_bsize);
- if (tmp != SWAB32(*p)) {
+ if (tmp != fs32_to_cpu(sb, *p)) {
ubh_brelse (tind_bh);
return 1;
}
if (!tind_bh) {
- *p = SWAB32(0);
+ *p = 0;
return 0;
}

@@ -403,14 +395,14 @@
ubh_mark_buffer_dirty(tind_bh);
}
for (i = 0; i < uspi->s_apb; i++)
- if (SWAB32(*ubh_get_addr32 (tind_bh, i)))
+ if (*ubh_get_addr32 (tind_bh, i))
break;
if (i >= uspi->s_apb) {
if (ubh_max_bcount(tind_bh) != 1)
retry = 1;
else {
- tmp = SWAB32(*p);
- *p = SWAB32(0);
+ tmp = fs32_to_cpu(sb, *p);
+ *p = 0;
inode->i_blocks -= uspi->s_nspb;
mark_inode_dirty(inode);
ufs_free_blocks (inode, tmp, uspi->s_fpb);
diff -uNr -Xdontdiff ../master/linux-2.4.14-pre3/fs/ufs/util.h linux/fs/ufs/util.h
--- ../master/linux-2.4.14-pre3/fs/ufs/util.h Sun Sep 23 21:21:01 2001
+++ linux/fs/ufs/util.h Mon Oct 29 17:13:47 2001
@@ -26,180 +26,203 @@
/*
* macros used for accesing structures
*/
-#define ufs_get_fs_state(usb1,usb3) _ufs_get_fs_state_(usb1,usb3,flags,swab)
-static inline __s32 _ufs_get_fs_state_(struct ufs_super_block_first * usb1,
- struct ufs_super_block_third * usb3, unsigned flags, unsigned swab)
-{
- switch (flags & UFS_ST_MASK) {
- case UFS_ST_SUN:
- return SWAB32((usb3)->fs_u2.fs_sun.fs_state);
- case UFS_ST_SUNx86:
- return SWAB32((usb1)->fs_u1.fs_sunx86.fs_state);
- case UFS_ST_44BSD:
- default:
- return SWAB32((usb3)->fs_u2.fs_44.fs_state);
+static inline s32
+ufs_get_fs_state(struct super_block *sb, struct ufs_super_block_first *usb1,
+ struct ufs_super_block_third *usb3)
+{
+ switch (sb->u.ufs_sb.s_flags & UFS_ST_MASK) {
+ case UFS_ST_SUN:
+ return fs32_to_cpu(sb, usb3->fs_u2.fs_sun.fs_state);
+ case UFS_ST_SUNx86:
+ return fs32_to_cpu(sb, usb1->fs_u1.fs_sunx86.fs_state);
+ case UFS_ST_44BSD:
+ default:
+ return fs32_to_cpu(sb, usb3->fs_u2.fs_44.fs_state);
}
}

-#define ufs_set_fs_state(usb1,usb3,value) _ufs_set_fs_state_(usb1,usb3,value,flags,swab)
-static inline void _ufs_set_fs_state_(struct ufs_super_block_first * usb1,
- struct ufs_super_block_third * usb3, __s32 value, unsigned flags, unsigned swab)
-{
- switch (flags & UFS_ST_MASK) {
- case UFS_ST_SUN:
- (usb3)->fs_u2.fs_sun.fs_state = SWAB32(value);
- break;
- case UFS_ST_SUNx86:
- (usb1)->fs_u1.fs_sunx86.fs_state = SWAB32(value);
- break;
- case UFS_ST_44BSD:
- (usb3)->fs_u2.fs_44.fs_state = SWAB32(value);
- break;
+static inline void
+ufs_set_fs_state(struct super_block *sb, struct ufs_super_block_first *usb1,
+ struct ufs_super_block_third *usb3, s32 value)
+{
+ switch (sb->u.ufs_sb.s_flags & UFS_ST_MASK) {
+ case UFS_ST_SUN:
+ usb3->fs_u2.fs_sun.fs_state = cpu_to_fs32(sb, value);
+ break;
+ case UFS_ST_SUNx86:
+ usb1->fs_u1.fs_sunx86.fs_state = cpu_to_fs32(sb, value);
+ break;
+ case UFS_ST_44BSD:
+ usb3->fs_u2.fs_44.fs_state = cpu_to_fs32(sb, value);
+ break;
}
}

-#define ufs_get_fs_npsect(usb1,usb3) _ufs_get_fs_npsect_(usb1,usb3,flags,swab)
-static inline __u32 _ufs_get_fs_npsect_(struct ufs_super_block_first * usb1,
- struct ufs_super_block_third * usb3, unsigned flags, unsigned swab)
+static inline u32
+ufs_get_fs_npsect(struct super_block *sb, struct ufs_super_block_first *usb1,
+ struct ufs_super_block_third *usb3)
{
- if ((flags & UFS_ST_MASK) == UFS_ST_SUNx86)
- return SWAB32((usb3)->fs_u2.fs_sunx86.fs_npsect);
+ if ((sb->u.ufs_sb.s_flags & UFS_ST_MASK) == UFS_ST_SUNx86)
+ return fs32_to_cpu(sb, usb3->fs_u2.fs_sunx86.fs_npsect);
else
- return SWAB32((usb1)->fs_u1.fs_sun.fs_npsect);
+ return fs32_to_cpu(sb, usb1->fs_u1.fs_sun.fs_npsect);
}

-#define ufs_get_fs_qbmask(usb3) _ufs_get_fs_qbmask_(usb3,flags,swab)
-static inline __u64 _ufs_get_fs_qbmask_(struct ufs_super_block_third * usb3,
- unsigned flags, unsigned swab)
-{
- __u64 tmp;
- switch (flags & UFS_ST_MASK) {
- case UFS_ST_SUN:
- ((u32 *)&tmp)[0] = usb3->fs_u2.fs_sun.fs_qbmask[0];
- ((u32 *)&tmp)[1] = usb3->fs_u2.fs_sun.fs_qbmask[1];
- break;
- case UFS_ST_SUNx86:
- ((u32 *)&tmp)[0] = usb3->fs_u2.fs_sunx86.fs_qbmask[0];
- ((u32 *)&tmp)[1] = usb3->fs_u2.fs_sunx86.fs_qbmask[1];
- break;
- case UFS_ST_44BSD:
- ((u32 *)&tmp)[0] = usb3->fs_u2.fs_44.fs_qbmask[0];
- ((u32 *)&tmp)[1] = usb3->fs_u2.fs_44.fs_qbmask[1];
- break;
- }
- return SWAB64(tmp);
-}
+static inline u64
+ufs_get_fs_qbmask(struct super_block *sb, struct ufs_super_block_third *usb3)
+{
+ u64 tmp;

-#define ufs_get_fs_qfmask(usb3) _ufs_get_fs_qfmask_(usb3,flags,swab)
-static inline __u64 _ufs_get_fs_qfmask_(struct ufs_super_block_third * usb3,
- unsigned flags, unsigned swab)
-{
- __u64 tmp;
- switch (flags & UFS_ST_MASK) {
- case UFS_ST_SUN:
- ((u32 *)&tmp)[0] = usb3->fs_u2.fs_sun.fs_qfmask[0];
- ((u32 *)&tmp)[1] = usb3->fs_u2.fs_sun.fs_qfmask[1];
- break;
- case UFS_ST_SUNx86:
- ((u32 *)&tmp)[0] = usb3->fs_u2.fs_sunx86.fs_qfmask[0];
- ((u32 *)&tmp)[1] = usb3->fs_u2.fs_sunx86.fs_qfmask[1];
- break;
- case UFS_ST_44BSD:
- ((u32 *)&tmp)[0] = usb3->fs_u2.fs_44.fs_qfmask[0];
- ((u32 *)&tmp)[1] = usb3->fs_u2.fs_44.fs_qfmask[1];
- break;
+ switch (sb->u.ufs_sb.s_flags & UFS_ST_MASK) {
+ case UFS_ST_SUN:
+ ((u32 *)&tmp)[0] = usb3->fs_u2.fs_sun.fs_qbmask[0];
+ ((u32 *)&tmp)[1] = usb3->fs_u2.fs_sun.fs_qbmask[1];
+ break;
+ case UFS_ST_SUNx86:
+ ((u32 *)&tmp)[0] = usb3->fs_u2.fs_sunx86.fs_qbmask[0];
+ ((u32 *)&tmp)[1] = usb3->fs_u2.fs_sunx86.fs_qbmask[1];
+ break;
+ case UFS_ST_44BSD:
+ ((u32 *)&tmp)[0] = usb3->fs_u2.fs_44.fs_qbmask[0];
+ ((u32 *)&tmp)[1] = usb3->fs_u2.fs_44.fs_qbmask[1];
+ break;
}
- return SWAB64(tmp);
-}

-#define ufs_get_de_namlen(de) \
- (((flags & UFS_DE_MASK) == UFS_DE_OLD) \
- ? SWAB16(de->d_u.d_namlen) \
- : de->d_u.d_44.d_namlen)
-
-#define ufs_set_de_namlen(de,value) \
- (((flags & UFS_DE_MASK) == UFS_DE_OLD) \
- ? (de->d_u.d_namlen = SWAB16(value)) \
- : (de->d_u.d_44.d_namlen = value))
-
-#define ufs_set_de_type(de,mode) _ufs_set_de_type_(de,mode,flags,swab)
-static inline void _ufs_set_de_type_(struct ufs_dir_entry * de, int mode,
- unsigned flags, unsigned swab)
-{
- if ((flags & UFS_DE_MASK) == UFS_DE_44BSD) {
- switch (mode & S_IFMT) {
- case S_IFSOCK: de->d_u.d_44.d_type = DT_SOCK; break;
- case S_IFLNK: de->d_u.d_44.d_type = DT_LNK; break;
- case S_IFREG: de->d_u.d_44.d_type = DT_REG; break;
- case S_IFBLK: de->d_u.d_44.d_type = DT_BLK; break;
- case S_IFDIR: de->d_u.d_44.d_type = DT_DIR; break;
- case S_IFCHR: de->d_u.d_44.d_type = DT_CHR; break;
- case S_IFIFO: de->d_u.d_44.d_type = DT_FIFO; break;
- default: de->d_u.d_44.d_type = DT_UNKNOWN;
- }
- }
+ return fs64_to_cpu(sb, tmp);
}

-#define ufs_get_inode_uid(inode) _ufs_get_inode_uid_(inode,flags,swab)
-static inline __u32 _ufs_get_inode_uid_(struct ufs_inode * inode,
- unsigned flags, unsigned swab)
-{
- switch (flags & UFS_UID_MASK) {
- case UFS_UID_EFT:
- return SWAB32(inode->ui_u3.ui_sun.ui_uid);
- case UFS_UID_44BSD:
- return SWAB32(inode->ui_u3.ui_44.ui_uid);
- default:
- return SWAB16(inode->ui_u1.oldids.ui_suid);
+static inline u64
+ufs_get_fs_qfmask(struct super_block *sb, struct ufs_super_block_third *usb3)
+{
+ u64 tmp;
+
+ switch (sb->u.ufs_sb.s_flags & UFS_ST_MASK) {
+ case UFS_ST_SUN:
+ ((u32 *)&tmp)[0] = usb3->fs_u2.fs_sun.fs_qfmask[0];
+ ((u32 *)&tmp)[1] = usb3->fs_u2.fs_sun.fs_qfmask[1];
+ break;
+ case UFS_ST_SUNx86:
+ ((u32 *)&tmp)[0] = usb3->fs_u2.fs_sunx86.fs_qfmask[0];
+ ((u32 *)&tmp)[1] = usb3->fs_u2.fs_sunx86.fs_qfmask[1];
+ break;
+ case UFS_ST_44BSD:
+ ((u32 *)&tmp)[0] = usb3->fs_u2.fs_44.fs_qfmask[0];
+ ((u32 *)&tmp)[1] = usb3->fs_u2.fs_44.fs_qfmask[1];
+ break;
}
+
+ return fs64_to_cpu(sb, tmp);
}

-#define ufs_set_inode_uid(inode,value) _ufs_set_inode_uid_(inode,value,flags,swab)
-static inline void _ufs_set_inode_uid_(struct ufs_inode * inode, __u32 value,
- unsigned flags, unsigned swab)
-{
- inode->ui_u1.oldids.ui_suid = SWAB16(value);
- switch (flags & UFS_UID_MASK) {
- case UFS_UID_EFT:
- inode->ui_u3.ui_sun.ui_uid = SWAB32(value);
- break;
- case UFS_UID_44BSD:
- inode->ui_u3.ui_44.ui_uid = SWAB32(value);
- break;
- }
+static inline u16
+ufs_get_de_namlen(struct super_block *sb, struct ufs_dir_entry *de)
+{
+ if ((sb->u.ufs_sb.s_flags & UFS_DE_MASK) == UFS_DE_OLD)
+ return fs16_to_cpu(sb, de->d_u.d_namlen);
+ else
+ return de->d_u.d_44.d_namlen; /* XXX this seems wrong */
}

-#define ufs_get_inode_gid(inode) _ufs_get_inode_gid_(inode,flags,swab)
-static inline __u32 _ufs_get_inode_gid_(struct ufs_inode * inode,
- unsigned flags, unsigned swab)
-{
- switch (flags & UFS_UID_MASK) {
- case UFS_UID_EFT:
- return SWAB32(inode->ui_u3.ui_sun.ui_gid);
- case UFS_UID_44BSD:
- return SWAB32(inode->ui_u3.ui_44.ui_gid);
- default:
- return SWAB16(inode->ui_u1.oldids.ui_sgid);
- }
+static inline void
+ufs_set_de_namlen(struct super_block *sb, struct ufs_dir_entry *de, u16 value)
+{
+ if ((sb->u.ufs_sb.s_flags & UFS_DE_MASK) == UFS_DE_OLD)
+ de->d_u.d_namlen = cpu_to_fs16(sb, value);
+ else
+ de->d_u.d_44.d_namlen = value; /* XXX this seems wrong */
}

-#define ufs_set_inode_gid(inode,value) _ufs_set_inode_gid_(inode,value,flags,swab)
-static inline void _ufs_set_inode_gid_(struct ufs_inode * inode, __u32 value,
- unsigned flags, unsigned swab)
-{
- inode->ui_u1.oldids.ui_sgid = SWAB16(value);
- switch (flags & UFS_UID_MASK) {
- case UFS_UID_EFT:
- inode->ui_u3.ui_sun.ui_gid = SWAB32(value);
- break;
- case UFS_UID_44BSD:
- inode->ui_u3.ui_44.ui_gid = SWAB32(value);
- break;
+static inline void
+ufs_set_de_type(struct super_block *sb, struct ufs_dir_entry *de, int mode)
+{
+ if ((sb->u.ufs_sb.s_flags & UFS_DE_MASK) != UFS_DE_44BSD)
+ return;
+
+ /*
+ * TODO turn this into a table lookup
+ */
+ switch (mode & S_IFMT) {
+ case S_IFSOCK:
+ de->d_u.d_44.d_type = DT_SOCK;
+ break;
+ case S_IFLNK:
+ de->d_u.d_44.d_type = DT_LNK;
+ break;
+ case S_IFREG:
+ de->d_u.d_44.d_type = DT_REG;
+ break;
+ case S_IFBLK:
+ de->d_u.d_44.d_type = DT_BLK;
+ break;
+ case S_IFDIR:
+ de->d_u.d_44.d_type = DT_DIR;
+ break;
+ case S_IFCHR:
+ de->d_u.d_44.d_type = DT_CHR;
+ break;
+ case S_IFIFO:
+ de->d_u.d_44.d_type = DT_FIFO;
+ break;
+ default:
+ de->d_u.d_44.d_type = DT_UNKNOWN;
+ }
+}
+
+static inline u32
+ufs_get_inode_uid(struct super_block *sb, struct ufs_inode *inode)
+{
+ switch (sb->u.ufs_sb.s_flags & UFS_UID_MASK) {
+ case UFS_UID_EFT:
+ return fs32_to_cpu(sb, inode->ui_u3.ui_sun.ui_uid);
+ case UFS_UID_44BSD:
+ return fs32_to_cpu(sb, inode->ui_u3.ui_44.ui_uid);
+ default:
+ return fs16_to_cpu(sb, inode->ui_u1.oldids.ui_suid);
+ }
+}
+
+static inline void
+ufs_set_inode_uid(struct super_block *sb, struct ufs_inode *inode, u32 value)
+{
+ switch (sb->u.ufs_sb.s_flags & UFS_UID_MASK) {
+ case UFS_UID_EFT:
+ inode->ui_u3.ui_sun.ui_uid = cpu_to_fs32(sb, value);
+ break;
+ case UFS_UID_44BSD:
+ inode->ui_u3.ui_44.ui_uid = cpu_to_fs32(sb, value);
+ break;
+ }
+ inode->ui_u1.oldids.ui_suid = cpu_to_fs16(sb, value);
+}
+
+static inline u32
+ufs_get_inode_gid(struct super_block *sb, struct ufs_inode *inode)
+{
+ switch (sb->u.ufs_sb.s_flags & UFS_UID_MASK) {
+ case UFS_UID_EFT:
+ return fs32_to_cpu(sb, inode->ui_u3.ui_sun.ui_gid);
+ case UFS_UID_44BSD:
+ return fs32_to_cpu(sb, inode->ui_u3.ui_44.ui_gid);
+ default:
+ return fs16_to_cpu(sb, inode->ui_u1.oldids.ui_sgid);
+ }
+}
+
+static inline void
+ufs_set_inode_gid(struct super_block *sb, struct ufs_inode *inode, u32 value)
+{
+ switch (sb->u.ufs_sb.s_flags & UFS_UID_MASK) {
+ case UFS_UID_EFT:
+ inode->ui_u3.ui_sun.ui_gid = cpu_to_fs32(sb, value);
+ break;
+ case UFS_UID_44BSD:
+ inode->ui_u3.ui_44.ui_gid = cpu_to_fs32(sb, value);
+ break;
}
+ inode->ui_u1.oldids.ui_sgid = cpu_to_fs16(sb, value);
}


-
/*
* These functions manipulate ufs buffers
*/
@@ -284,8 +307,8 @@
* percentage to hold in reserve.
*/
#define ufs_freespace(usb, percentreserved) \
- (ufs_blkstofrags(SWAB32((usb)->fs_cstotal.cs_nbfree)) + \
- SWAB32((usb)->fs_cstotal.cs_nffree) - (uspi->s_dsize * (percentreserved) / 100))
+ (ufs_blkstofrags(fs32_to_cpu(sb, (usb)->fs_cstotal.cs_nbfree)) + \
+ fs32_to_cpu(sb, (usb)->fs_cstotal.cs_nffree) - (uspi->s_dsize * (percentreserved) / 100))

/*
* Macros to access cylinder group array structures
@@ -456,9 +479,7 @@
{
struct ufs_sb_private_info * uspi;
unsigned fragsize, pos;
- unsigned swab;

- swab = sb->u.ufs_sb.s_swab;
uspi = sb->u.ufs_sb.s_uspi;

fragsize = 0;
@@ -467,12 +488,12 @@
fragsize++;
}
else if (fragsize > 0) {
- ADD_SWAB32(fraglist[fragsize], cnt);
+ fs32_add(sb, &fraglist[fragsize], cnt);
fragsize = 0;
}
}
if (fragsize > 0 && fragsize < uspi->s_fpb)
- ADD_SWAB32(fraglist[fragsize], cnt);
+ fs32_add(sb, &fraglist[fragsize], cnt);
}

#define ubh_scanc(ubh,begin,size,table,mask) _ubh_scanc_(uspi,ubh,begin,size,table,mask)
diff -uNr -Xdontdiff ../master/linux-2.4.14-pre3/include/linux/ufs_fs.h linux/include/linux/ufs_fs.h
--- ../master/linux-2.4.14-pre3/include/linux/ufs_fs.h Thu Oct 25 19:05:48 2001
+++ linux/include/linux/ufs_fs.h Mon Oct 29 16:48:57 2001
@@ -96,17 +96,6 @@
#define UFS_FSBAD ((char)0xff)

/* From here to next blank line, s_flags for ufs_sb_info */
-/* endianness */
-#define UFS_BYTESEX 0x00000001 /* mask; leave room to 0xF */
-#if defined(__LITTLE_ENDIAN) || defined(__BIG_ENDIAN)
-/* these are for sane architectures */
-#define UFS_NATIVE_ENDIAN 0x00000000
-#define UFS_SWABBED_ENDIAN 0x00000001
-#else
-/* these are for pervert architectures */
-#define UFS_LITTLE_ENDIAN 0x00000000
-#define UFS_BIG_ENDIAN 0x00000001
-#endif
/* directory entry encoding */
#define UFS_DE_MASK 0x00000010 /* mask for the following */
#define UFS_DE_OLD 0x00000000
@@ -417,7 +406,8 @@
* super block lock fs->fs_lock.
*/
#define CG_MAGIC 0x090255
-#define ufs_cg_chkmagic(ucg) (SWAB32((ucg)->cg_magic) == CG_MAGIC)
+#define ufs_cg_chkmagic(sb, ucg) \
+ (fs32_to_cpu((sb), (ucg)->cg_magic) == CG_MAGIC)

/*
* size of this structure is 172 B
diff -uNr -Xdontdiff ../master/linux-2.4.14-pre3/include/linux/ufs_fs_i.h linux/include/linux/ufs_fs_i.h
--- ../master/linux-2.4.14-pre3/include/linux/ufs_fs_i.h Tue Jan 11 03:15:58 2000
+++ linux/include/linux/ufs_fs_i.h Mon Oct 29 16:46:54 2001
@@ -18,7 +18,6 @@
__u32 i_data[15];
__u8 i_symlink[4*15];
} i_u1;
- __u64 i_size;
__u32 i_flags;
__u32 i_gen;
__u32 i_shadow;
diff -uNr -Xdontdiff ../master/linux-2.4.14-pre3/include/linux/ufs_fs_sb.h linux/include/linux/ufs_fs_sb.h
--- ../master/linux-2.4.14-pre3/include/linux/ufs_fs_sb.h Fri Jul 20 21:52:18 2001
+++ linux/include/linux/ufs_fs_sb.h Mon Oct 29 17:13:46 2001
@@ -118,7 +118,7 @@
struct ufs_sb_info {
struct ufs_sb_private_info * s_uspi;
struct ufs_csum * s_csp[UFS_MAXCSBUFS];
- unsigned s_swab;
+ unsigned s_bytesex;
unsigned s_flags;
struct buffer_head ** s_ucg;
struct ufs_cg_private_info * s_ucpi[UFS_MAX_GROUP_LOADED];
-
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
Please read the FAQ at http://www.tux.org/lkml/
\
 
 \ /
  Last update: 2005-03-22 13:11    [W:0.111 / U:1.404 seconds]
©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site