[PATCH] jbd endianness annotations

Signed-off-by: Al Viro <viro@parcelfarce.linux.org.uk>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>

diff --git a/fs/jbd/commit.c b/fs/jbd/commit.c
index a7eef5cebaa30850dd51fe48868549882bbcdb5e..f8a1dea566113ce8d7d067cf27c2b85916e08c55 100644 (file)
--- a/fs/jbd/commit.c
+++ b/fs/jbd/commit.c
@@ -405,9 +405,9 @@ write_out_data:
                        jbd_debug(4, "JBD: got buffer %llu (%p)\n",
                                (unsigned long long)bh->b_blocknr, bh->b_data);
                        header = (journal_header_t *)&bh->b_data[0];
-                       header->h_magic     = htonl(JFS_MAGIC_NUMBER);
-                       header->h_blocktype = htonl(JFS_DESCRIPTOR_BLOCK);
-                       header->h_sequence  = htonl(commit_transaction->t_tid);
+                       header->h_magic     = cpu_to_be32(JFS_MAGIC_NUMBER);
+                       header->h_blocktype = cpu_to_be32(JFS_DESCRIPTOR_BLOCK);
+                       header->h_sequence  = cpu_to_be32(commit_transaction->t_tid);
 
                        tagp = &bh->b_data[sizeof(journal_header_t)];
                        space_left = bh->b_size - sizeof(journal_header_t);
@@ -473,8 +473,8 @@ write_out_data:
                        tag_flag |= JFS_FLAG_SAME_UUID;
 
                tag = (journal_block_tag_t *) tagp;
-               tag->t_blocknr = htonl(jh2bh(jh)->b_blocknr);
-               tag->t_flags = htonl(tag_flag);
+               tag->t_blocknr = cpu_to_be32(jh2bh(jh)->b_blocknr);
+               tag->t_flags = cpu_to_be32(tag_flag);
                tagp += sizeof(journal_block_tag_t);
                space_left -= sizeof(journal_block_tag_t);
 
@@ -498,7 +498,7 @@ write_out_data:
                            submitting the IOs.  "tag" still points to
                            the last tag we set up. */
 
-                       tag->t_flags |= htonl(JFS_FLAG_LAST_TAG);
+                       tag->t_flags |= cpu_to_be32(JFS_FLAG_LAST_TAG);
 
 start_journal_io:
                        for (i = 0; i < bufs; i++) {
@@ -631,9 +631,9 @@ wait_for_iobuf:
        for (i = 0; i < jh2bh(descriptor)->b_size; i += 512) {
                journal_header_t *tmp =
                        (journal_header_t*)jh2bh(descriptor)->b_data;
-               tmp->h_magic = htonl(JFS_MAGIC_NUMBER);
-               tmp->h_blocktype = htonl(JFS_COMMIT_BLOCK);
-               tmp->h_sequence = htonl(commit_transaction->t_tid);
+               tmp->h_magic = cpu_to_be32(JFS_MAGIC_NUMBER);
+               tmp->h_blocktype = cpu_to_be32(JFS_COMMIT_BLOCK);
+               tmp->h_sequence = cpu_to_be32(commit_transaction->t_tid);
        }
 
        JBUFFER_TRACE(descriptor, "write commit block");

diff --git a/fs/jbd/journal.c b/fs/jbd/journal.c
index 33fd505cfe21114972dee84e76ef589e4b9f9c3f..cb9d794cc58823c7da43ebee60e522df474a23b4 100644 (file)
--- a/fs/jbd/journal.c
+++ b/fs/jbd/journal.c
@@ -326,8 +326,8 @@ repeat:
        /*
         * Check for escaping
         */
-       if (*((unsigned int *)(mapped_data + new_offset)) ==
-                               htonl(JFS_MAGIC_NUMBER)) {
+       if (*((__be32 *)(mapped_data + new_offset)) ==
+                               cpu_to_be32(JFS_MAGIC_NUMBER)) {
                need_copy_out = 1;
                do_escape = 1;
        }
@@ -809,8 +809,8 @@ static int journal_reset(journal_t *journal)
        journal_superblock_t *sb = journal->j_superblock;
        unsigned int first, last;
 
-       first = ntohl(sb->s_first);
-       last = ntohl(sb->s_maxlen);
+       first = be32_to_cpu(sb->s_first);
+       last = be32_to_cpu(sb->s_maxlen);
 
        journal->j_first = first;
        journal->j_last = last;
@@ -887,12 +887,12 @@ int journal_create(journal_t *journal)
        /* OK, fill in the initial static fields in the new superblock */
        sb = journal->j_superblock;
 
-       sb->s_header.h_magic     = htonl(JFS_MAGIC_NUMBER);
-       sb->s_header.h_blocktype = htonl(JFS_SUPERBLOCK_V2);
+       sb->s_header.h_magic     = cpu_to_be32(JFS_MAGIC_NUMBER);
+       sb->s_header.h_blocktype = cpu_to_be32(JFS_SUPERBLOCK_V2);
 
-       sb->s_blocksize = htonl(journal->j_blocksize);
-       sb->s_maxlen    = htonl(journal->j_maxlen);
-       sb->s_first     = htonl(1);
+       sb->s_blocksize = cpu_to_be32(journal->j_blocksize);
+       sb->s_maxlen    = cpu_to_be32(journal->j_maxlen);
+       sb->s_first     = cpu_to_be32(1);
 
        journal->j_transaction_sequence = 1;
 
@@ -935,9 +935,9 @@ void journal_update_superblock(journal_t *journal, int wait)
        jbd_debug(1,"JBD: updating superblock (start %ld, seq %d, errno %d)\n",
                  journal->j_tail, journal->j_tail_sequence, journal->j_errno);
 
-       sb->s_sequence = htonl(journal->j_tail_sequence);
-       sb->s_start    = htonl(journal->j_tail);
-       sb->s_errno    = htonl(journal->j_errno);
+       sb->s_sequence = cpu_to_be32(journal->j_tail_sequence);
+       sb->s_start    = cpu_to_be32(journal->j_tail);
+       sb->s_errno    = cpu_to_be32(journal->j_errno);
        spin_unlock(&journal->j_state_lock);
 
        BUFFER_TRACE(bh, "marking dirty");
@@ -988,13 +988,13 @@ static int journal_get_superblock(journal_t *journal)
 
        err = -EINVAL;
 
-       if (sb->s_header.h_magic != htonl(JFS_MAGIC_NUMBER) ||
-           sb->s_blocksize != htonl(journal->j_blocksize)) {
+       if (sb->s_header.h_magic != cpu_to_be32(JFS_MAGIC_NUMBER) ||
+           sb->s_blocksize != cpu_to_be32(journal->j_blocksize)) {
                printk(KERN_WARNING "JBD: no valid journal superblock found\n");
                goto out;
        }
 
-       switch(ntohl(sb->s_header.h_blocktype)) {
+       switch(be32_to_cpu(sb->s_header.h_blocktype)) {
        case JFS_SUPERBLOCK_V1:
                journal->j_format_version = 1;
                break;
@@ -1006,9 +1006,9 @@ static int journal_get_superblock(journal_t *journal)
                goto out;
        }
 
-       if (ntohl(sb->s_maxlen) < journal->j_maxlen)
-               journal->j_maxlen = ntohl(sb->s_maxlen);
-       else if (ntohl(sb->s_maxlen) > journal->j_maxlen) {
+       if (be32_to_cpu(sb->s_maxlen) < journal->j_maxlen)
+               journal->j_maxlen = be32_to_cpu(sb->s_maxlen);
+       else if (be32_to_cpu(sb->s_maxlen) > journal->j_maxlen) {
                printk (KERN_WARNING "JBD: journal file too short\n");
                goto out;
        }
@@ -1036,11 +1036,11 @@ static int load_superblock(journal_t *journal)
 
        sb = journal->j_superblock;
 
-       journal->j_tail_sequence = ntohl(sb->s_sequence);
-       journal->j_tail = ntohl(sb->s_start);
-       journal->j_first = ntohl(sb->s_first);
-       journal->j_last = ntohl(sb->s_maxlen);
-       journal->j_errno = ntohl(sb->s_errno);
+       journal->j_tail_sequence = be32_to_cpu(sb->s_sequence);
+       journal->j_tail = be32_to_cpu(sb->s_start);
+       journal->j_first = be32_to_cpu(sb->s_first);
+       journal->j_last = be32_to_cpu(sb->s_maxlen);
+       journal->j_errno = be32_to_cpu(sb->s_errno);
 
        return 0;
 }
@@ -1253,7 +1253,7 @@ int journal_update_format (journal_t *journal)
 
        sb = journal->j_superblock;
 
-       switch (ntohl(sb->s_header.h_blocktype)) {
+       switch (be32_to_cpu(sb->s_header.h_blocktype)) {
        case JFS_SUPERBLOCK_V2:
                return 0;
        case JFS_SUPERBLOCK_V1:
@@ -1275,7 +1275,7 @@ static int journal_convert_superblock_v1(journal_t *journal,
 
        /* Pre-initialise new fields to zero */
        offset = ((char *) &(sb->s_feature_compat)) - ((char *) sb);
-       blocksize = ntohl(sb->s_blocksize);
+       blocksize = be32_to_cpu(sb->s_blocksize);
        memset(&sb->s_feature_compat, 0, blocksize-offset);
 
        sb->s_nr_users = cpu_to_be32(1);

diff --git a/fs/jbd/recovery.c b/fs/jbd/recovery.c
index 8f1971290560857608a7dd75a102818e0dc894c2..4a3d494a35743583162fd8d9c00d8cf810698eeb 100644 (file)
--- a/fs/jbd/recovery.c
+++ b/fs/jbd/recovery.c
@@ -191,10 +191,10 @@ static int count_tags(struct buffer_head *bh, int size)
 
                nr++;
                tagp += sizeof(journal_block_tag_t);
-               if (!(tag->t_flags & htonl(JFS_FLAG_SAME_UUID)))
+               if (!(tag->t_flags & cpu_to_be32(JFS_FLAG_SAME_UUID)))
                        tagp += 16;
 
-               if (tag->t_flags & htonl(JFS_FLAG_LAST_TAG))
+               if (tag->t_flags & cpu_to_be32(JFS_FLAG_LAST_TAG))
                        break;
        }
 
@@ -239,8 +239,8 @@ int journal_recover(journal_t *journal)
 
        if (!sb->s_start) {
                jbd_debug(1, "No recovery required, last transaction %d\n",
-                         ntohl(sb->s_sequence));
-               journal->j_transaction_sequence = ntohl(sb->s_sequence) + 1;
+                         be32_to_cpu(sb->s_sequence));
+               journal->j_transaction_sequence = be32_to_cpu(sb->s_sequence) + 1;
                return 0;
        }
 
@@ -295,7 +295,7 @@ int journal_skip_recovery(journal_t *journal)
                ++journal->j_transaction_sequence;
        } else {
 #ifdef CONFIG_JBD_DEBUG
-               int dropped = info.end_transaction - ntohl(sb->s_sequence);
+               int dropped = info.end_transaction - be32_to_cpu(sb->s_sequence);
 #endif
                jbd_debug(0, 
                          "JBD: ignoring %d transaction%s from the journal.\n",
@@ -331,8 +331,8 @@ static int do_one_pass(journal_t *journal,
         */
 
        sb = journal->j_superblock;
-       next_commit_ID = ntohl(sb->s_sequence);
-       next_log_block = ntohl(sb->s_start);
+       next_commit_ID = be32_to_cpu(sb->s_sequence);
+       next_log_block = be32_to_cpu(sb->s_start);
 
        first_commit_ID = next_commit_ID;
        if (pass == PASS_SCAN)
@@ -385,13 +385,13 @@ static int do_one_pass(journal_t *journal,
 
                tmp = (journal_header_t *)bh->b_data;
 
-               if (tmp->h_magic != htonl(JFS_MAGIC_NUMBER)) {
+               if (tmp->h_magic != cpu_to_be32(JFS_MAGIC_NUMBER)) {
                        brelse(bh);
                        break;
                }
 
-               blocktype = ntohl(tmp->h_blocktype);
-               sequence = ntohl(tmp->h_sequence);
+               blocktype = be32_to_cpu(tmp->h_blocktype);
+               sequence = be32_to_cpu(tmp->h_sequence);
                jbd_debug(3, "Found magic %d, sequence %d\n", 
                          blocktype, sequence);
 
@@ -427,7 +427,7 @@ static int do_one_pass(journal_t *journal,
                                unsigned long io_block;
 
                                tag = (journal_block_tag_t *) tagp;
-                               flags = ntohl(tag->t_flags);
+                               flags = be32_to_cpu(tag->t_flags);
 
                                io_block = next_log_block++;
                                wrap(journal, next_log_block);
@@ -444,7 +444,7 @@ static int do_one_pass(journal_t *journal,
                                        unsigned long blocknr;
 
                                        J_ASSERT(obh != NULL);
-                                       blocknr = ntohl(tag->t_blocknr);
+                                       blocknr = be32_to_cpu(tag->t_blocknr);
 
                                        /* If the block has been
                                         * revoked, then we're all done
@@ -476,8 +476,8 @@ static int do_one_pass(journal_t *journal,
                                        memcpy(nbh->b_data, obh->b_data,
                                                        journal->j_blocksize);
                                        if (flags & JFS_FLAG_ESCAPE) {
-                                               *((unsigned int *)bh->b_data) =
-                                                       htonl(JFS_MAGIC_NUMBER);
+                                               *((__be32 *)bh->b_data) =
+                                               cpu_to_be32(JFS_MAGIC_NUMBER);
                                        }
 
                                        BUFFER_TRACE(nbh, "marking dirty");
@@ -572,13 +572,13 @@ static int scan_revoke_records(journal_t *journal, struct buffer_head *bh,
 
        header = (journal_revoke_header_t *) bh->b_data;
        offset = sizeof(journal_revoke_header_t);
-       max = ntohl(header->r_count);
+       max = be32_to_cpu(header->r_count);
 
        while (offset < max) {
                unsigned long blocknr;
                int err;
 
-               blocknr = ntohl(* ((unsigned int *) (bh->b_data+offset)));
+               blocknr = be32_to_cpu(* ((__be32 *) (bh->b_data+offset)));
                offset += 4;
                err = journal_set_revoke(journal, blocknr, sequence);
                if (err)

diff --git a/fs/jbd/revoke.c b/fs/jbd/revoke.c
index df95ec122a22be73707694e69535437aed535ce8..0bb60dba76cc7c3348848abd0a0798ad6a4638aa 100644 (file)
--- a/fs/jbd/revoke.c
+++ b/fs/jbd/revoke.c
@@ -566,9 +566,9 @@ static void write_one_revoke_record(journal_t *journal,
                if (!descriptor)
                        return;
                header = (journal_header_t *) &jh2bh(descriptor)->b_data[0];
-               header->h_magic     = htonl(JFS_MAGIC_NUMBER);
-               header->h_blocktype = htonl(JFS_REVOKE_BLOCK);
-               header->h_sequence  = htonl(transaction->t_tid);
+               header->h_magic     = cpu_to_be32(JFS_MAGIC_NUMBER);
+               header->h_blocktype = cpu_to_be32(JFS_REVOKE_BLOCK);
+               header->h_sequence  = cpu_to_be32(transaction->t_tid);
 
                /* Record it so that we can wait for IO completion later */
                JBUFFER_TRACE(descriptor, "file as BJ_LogCtl");
@@ -578,8 +578,8 @@ static void write_one_revoke_record(journal_t *journal,
                *descriptorp = descriptor;
        }
 
-       * ((unsigned int *)(&jh2bh(descriptor)->b_data[offset])) = 
-               htonl(record->blocknr);
+       * ((__be32 *)(&jh2bh(descriptor)->b_data[offset])) = 
+               cpu_to_be32(record->blocknr);
        offset += 4;
        *offsetp = offset;
 }
@@ -604,7 +604,7 @@ static void flush_descriptor(journal_t *journal,
        }
 
        header = (journal_revoke_header_t *) jh2bh(descriptor)->b_data;
-       header->r_count = htonl(offset);
+       header->r_count = cpu_to_be32(offset);
        set_buffer_jwrite(bh);
        BUFFER_TRACE(bh, "write");
        set_buffer_dirty(bh);

diff --git a/include/linux/jbd.h b/include/linux/jbd.h
index 0548bdd7ca81fa01fedebb6bf0c3cc4816cde060..e65b90f1962cdd208f46ce67daa254b23f89488d 100644 (file)
--- a/include/linux/jbd.h
+++ b/include/linux/jbd.h
@@ -137,9 +137,9 @@ typedef struct journal_s    journal_t;      /* Journal control structure */
  */
 typedef struct journal_header_s
 {
-       __u32           h_magic;
-       __u32           h_blocktype;
-       __u32           h_sequence;
+       __be32          h_magic;
+       __be32          h_blocktype;
+       __be32          h_sequence;
 } journal_header_t;
 
 
@@ -148,8 +148,8 @@ typedef struct journal_header_s
  */
 typedef struct journal_block_tag_s
 {
-       __u32           t_blocknr;      /* The on-disk block number */
-       __u32           t_flags;        /* See below */
+       __be32          t_blocknr;      /* The on-disk block number */
+       __be32          t_flags;        /* See below */
 } journal_block_tag_t;
 
 /* 
@@ -159,7 +159,7 @@ typedef struct journal_block_tag_s
 typedef struct journal_revoke_header_s
 {
        journal_header_t r_header;
-       int              r_count;       /* Count of bytes used in the block */
+       __be32           r_count;       /* Count of bytes used in the block */
 } journal_revoke_header_t;
 
 
@@ -180,35 +180,35 @@ typedef struct journal_superblock_s
 
 /* 0x000C */
        /* Static information describing the journal */
-       __u32   s_blocksize;            /* journal device blocksize */
-       __u32   s_maxlen;               /* total blocks in journal file */
-       __u32   s_first;                /* first block of log information */
+       __be32  s_blocksize;            /* journal device blocksize */
+       __be32  s_maxlen;               /* total blocks in journal file */
+       __be32  s_first;                /* first block of log information */
 
 /* 0x0018 */
        /* Dynamic information describing the current state of the log */
-       __u32   s_sequence;             /* first commit ID expected in log */
-       __u32   s_start;                /* blocknr of start of log */
+       __be32  s_sequence;             /* first commit ID expected in log */
+       __be32  s_start;                /* blocknr of start of log */
 
 /* 0x0020 */
        /* Error value, as set by journal_abort(). */
-       __s32   s_errno;
+       __be32  s_errno;
 
 /* 0x0024 */
        /* Remaining fields are only valid in a version-2 superblock */
-       __u32   s_feature_compat;       /* compatible feature set */
-       __u32   s_feature_incompat;     /* incompatible feature set */
-       __u32   s_feature_ro_compat;    /* readonly-compatible feature set */
+       __be32  s_feature_compat;       /* compatible feature set */
+       __be32  s_feature_incompat;     /* incompatible feature set */
+       __be32  s_feature_ro_compat;    /* readonly-compatible feature set */
 /* 0x0030 */
        __u8    s_uuid[16];             /* 128-bit uuid for journal */
 
 /* 0x0040 */
-       __u32   s_nr_users;             /* Nr of filesystems sharing log */
+       __be32  s_nr_users;             /* Nr of filesystems sharing log */
 
-       __u32   s_dynsuper;             /* Blocknr of dynamic superblock copy*/
+       __be32  s_dynsuper;             /* Blocknr of dynamic superblock copy*/
 
 /* 0x0048 */
-       __u32   s_max_transaction;      /* Limit of journal blocks per trans.*/
-       __u32   s_max_trans_data;       /* Limit of data blocks per trans. */
+       __be32  s_max_transaction;      /* Limit of journal blocks per trans.*/
+       __be32  s_max_trans_data;       /* Limit of data blocks per trans. */
 
 /* 0x0050 */
        __u32   s_padding[44];