fs/jfs: Switch to use new generic UUID API

There are new types and helpers that are supposed to be used in new code.

As a preparation to get rid of legacy types and API functions do
the conversion here.

Signed-off-by: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
Signed-off-by: Dave Kleikamp <dave.kleikamp@oracle.com>

diff --git a/fs/jfs/jfs_incore.h b/fs/jfs/jfs_incore.h
index 912a3af2393ee8eb107573537c1c8ec8fa2f881d..340eb8e4f7160a943c46316172441175b9061cb1 100644 (file)
--- a/fs/jfs/jfs_incore.h
+++ b/fs/jfs/jfs_incore.h
@@ -23,6 +23,8 @@
 #include <linux/rwsem.h>
 #include <linux/slab.h>
 #include <linux/bitops.h>
+#include <linux/uuid.h>
+
 #include "jfs_types.h"
 #include "jfs_xtree.h"
 #include "jfs_dtree.h"
@@ -178,8 +180,8 @@ struct jfs_sb_info {
        pxd_t           logpxd;         /* pxd describing log   */
        pxd_t           fsckpxd;        /* pxd describing fsck wkspc */
        pxd_t           ait2;           /* pxd describing AIT copy      */
-       char            uuid[16];       /* 128-bit uuid for volume      */
-       char            loguuid[16];    /* 128-bit uuid for log */
+       uuid_t          uuid;           /* 128-bit uuid for volume      */
+       uuid_t          loguuid;        /* 128-bit uuid for log */
        /*
         * commit_state is used for synchronization of the jfs_commit
         * threads.  It is protected by LAZY_LOCK().

diff --git a/fs/jfs/jfs_logmgr.c b/fs/jfs/jfs_logmgr.c
index 6b68df3958924dc7461a00bf4c20828bf40aa0b6..4c77b808020b47b4d2e24c35145d3c08a60fb45a 100644 (file)
--- a/fs/jfs/jfs_logmgr.c
+++ b/fs/jfs/jfs_logmgr.c
@@ -1092,8 +1092,7 @@ int lmLogOpen(struct super_block *sb)
        mutex_lock(&jfs_log_mutex);
        list_for_each_entry(log, &jfs_external_logs, journal_list) {
                if (log->bdev->bd_dev == sbi->logdev) {
-                       if (memcmp(log->uuid, sbi->loguuid,
-                                  sizeof(log->uuid))) {
+                       if (!uuid_equal(&log->uuid, &sbi->loguuid)) {
                                jfs_warn("wrong uuid on JFS journal");
                                mutex_unlock(&jfs_log_mutex);
                                return -EINVAL;
@@ -1130,7 +1129,7 @@ int lmLogOpen(struct super_block *sb)
        }
 
        log->bdev = bdev;
-       memcpy(log->uuid, sbi->loguuid, sizeof(log->uuid));
+       uuid_copy(&log->uuid, &sbi->loguuid);
 
        /*
         * initialize log:
@@ -1336,7 +1335,7 @@ int lmLogInit(struct jfs_log * log)
                        jfs_info("lmLogInit: inline log:0x%p base:0x%Lx size:0x%x",
                                 log, (unsigned long long)log->base, log->size);
                } else {
-                       if (memcmp(logsuper->uuid, log->uuid, 16)) {
+                       if (!uuid_equal(&logsuper->uuid, &log->uuid)) {
                                jfs_warn("wrong uuid on JFS log device");
                                goto errout20;
                        }
@@ -1732,7 +1731,7 @@ static int lmLogFileSystem(struct jfs_log * log, struct jfs_sb_info *sbi,
        int i;
        struct logsuper *logsuper;
        struct lbuf *bpsuper;
-       char *uuid = sbi->uuid;
+       uuid_t *uuid = &sbi->uuid;
 
        /*
         * insert/remove file system device to log active file system list.
@@ -1743,8 +1742,8 @@ static int lmLogFileSystem(struct jfs_log * log, struct jfs_sb_info *sbi,
        logsuper = (struct logsuper *) bpsuper->l_ldata;
        if (activate) {
                for (i = 0; i < MAX_ACTIVE; i++)
-                       if (!memcmp(logsuper->active[i].uuid, NULL_UUID, 16)) {
-                               memcpy(logsuper->active[i].uuid, uuid, 16);
+                       if (uuid_is_null(&logsuper->active[i].uuid)) {
+                               uuid_copy(&logsuper->active[i].uuid, uuid);
                                sbi->aggregate = i;
                                break;
                        }
@@ -1755,8 +1754,9 @@ static int lmLogFileSystem(struct jfs_log * log, struct jfs_sb_info *sbi,
                }
        } else {
                for (i = 0; i < MAX_ACTIVE; i++)
-                       if (!memcmp(logsuper->active[i].uuid, uuid, 16)) {
-                               memcpy(logsuper->active[i].uuid, NULL_UUID, 16);
+                       if (uuid_equal(&logsuper->active[i].uuid, uuid)) {
+                               uuid_copy(&logsuper->active[i].uuid,
+                                         &uuid_null);
                                break;
                        }
                if (i == MAX_ACTIVE) {

diff --git a/fs/jfs/jfs_logmgr.h b/fs/jfs/jfs_logmgr.h
index e38c21598850cfa7d7c7102d3c1db2f8eb4345bb..870fc22360e790528cd3a51f21a32795dfd873a9 100644 (file)
--- a/fs/jfs/jfs_logmgr.h
+++ b/fs/jfs/jfs_logmgr.h
@@ -19,6 +19,8 @@
 #ifndef        _H_JFS_LOGMGR
 #define _H_JFS_LOGMGR
 
+#include <linux/uuid.h>
+
 #include "jfs_filsys.h"
 #include "jfs_lock.h"
 
@@ -73,15 +75,13 @@ struct logsuper {
        __le32 state;           /* 4: state - see below */
 
        __le32 end;             /* 4: addr of last log record set by logredo */
-       char uuid[16];          /* 16: 128-bit journal uuid */
+       uuid_t uuid;            /* 16: 128-bit journal uuid */
        char label[16];         /* 16: journal label */
        struct {
-               char uuid[16];
+               uuid_t uuid;
        } active[MAX_ACTIVE];   /* 2048: active file systems list */
 };
 
-#define NULL_UUID "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
-
 /* log flag: commit option (see jfs_filsys.h) */
 
 /* log state */
@@ -410,7 +410,7 @@ struct jfs_log {
        spinlock_t synclock;    /* 4: synclist lock */
        struct lbuf *wqueue;    /* 4: log pageout queue */
        int count;              /* 4: count */
-       char uuid[16];          /* 16: 128-bit uuid of log device */
+       uuid_t uuid;            /* 16: 128-bit uuid of log device */
 
        int no_integrity;       /* 3: flag to disable journaling to disk */
 };

diff --git a/fs/jfs/jfs_mount.c b/fs/jfs/jfs_mount.c
index d8658607bf46855bf338179551da155d71bccb44..c9c1f16b93df0b01f7702072361530f0bfd9e52b 100644 (file)
--- a/fs/jfs/jfs_mount.c
+++ b/fs/jfs/jfs_mount.c
@@ -389,8 +389,8 @@ static int chkSuper(struct super_block *sb)
                sbi->logpxd = j_sb->s_logpxd;
        else {
                sbi->logdev = new_decode_dev(le32_to_cpu(j_sb->s_logdev));
-               memcpy(sbi->uuid, j_sb->s_uuid, sizeof(sbi->uuid));
-               memcpy(sbi->loguuid, j_sb->s_loguuid, sizeof(sbi->uuid));
+               uuid_copy(&sbi->uuid, &j_sb->s_uuid);
+               uuid_copy(&sbi->loguuid, &j_sb->s_loguuid);
        }
        sbi->fsckpxd = j_sb->s_fsckpxd;
        sbi->ait2 = j_sb->s_ait2;

diff --git a/fs/jfs/jfs_superblock.h b/fs/jfs/jfs_superblock.h
index 302517421a8b59eed9ee4dda888792d01fb6494f..eb03de7fa9251514b00f9dd6739f084f3ac13837 100644 (file)
--- a/fs/jfs/jfs_superblock.h
+++ b/fs/jfs/jfs_superblock.h
@@ -18,6 +18,8 @@
 #ifndef        _H_JFS_SUPERBLOCK
 #define _H_JFS_SUPERBLOCK
 
+#include <linux/uuid.h>
+
 /*
  * make the magic number something a human could read
  */
@@ -98,9 +100,9 @@ struct jfs_superblock {
        __le64 s_xsize;         /* 8: extendfs s_size */
        pxd_t s_xfsckpxd;       /* 8: extendfs fsckpxd */
        pxd_t s_xlogpxd;        /* 8: extendfs logpxd */
-       char s_uuid[16];        /* 16: 128-bit uuid for volume */
+       uuid_t s_uuid;          /* 16: 128-bit uuid for volume */
        char s_label[16];       /* 16: volume label */
-       char s_loguuid[16];     /* 16: 128-bit uuid for log device */
+       uuid_t s_loguuid;       /* 16: 128-bit uuid for log device */
 
 };
 

diff --git a/fs/jfs/super.c b/fs/jfs/super.c
index 65d8fc87ab1145a1ac52ff5909ecd2888b79342e..c15ff56a8516af5a231763ea4054802643b84b86 100644 (file)
--- a/fs/jfs/super.c
+++ b/fs/jfs/super.c
@@ -174,9 +174,11 @@ static int jfs_statfs(struct dentry *dentry, struct kstatfs *buf)
        buf->f_files = maxinodes;
        buf->f_ffree = maxinodes - (atomic_read(&imap->im_numinos) -
                                    atomic_read(&imap->im_numfree));
-       buf->f_fsid.val[0] = (u32)crc32_le(0, sbi->uuid, sizeof(sbi->uuid)/2);
-       buf->f_fsid.val[1] = (u32)crc32_le(0, sbi->uuid + sizeof(sbi->uuid)/2,
-                                       sizeof(sbi->uuid)/2);
+       buf->f_fsid.val[0] = crc32_le(0, (char *)&sbi->uuid,
+                                     sizeof(sbi->uuid)/2);
+       buf->f_fsid.val[1] = crc32_le(0,
+                                     (char *)&sbi->uuid + sizeof(sbi->uuid)/2,
+                                     sizeof(sbi->uuid)/2);
 
        buf->f_namelen = JFS_NAME_MAX;
        return 0;