lkml.org 
[lkml]   [2008]   [Jul]   [16]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
Patch in this message
/
Subject[PATCH] dlm: sparse endian annotations
From
Date
fs/dlm/dir.c:419:14: warning: incorrect type in assignment (different base types)
fs/dlm/dir.c:419:14: expected unsigned short [unsigned] [addressable] [assigned] [usertype] be_namelen
fs/dlm/dir.c:419:14: got restricted __be16 [usertype] <noident>

fs/dlm/util.c:27:17: warning: incorrect type in assignment (different base types)
fs/dlm/util.c:27:17: expected unsigned int [unsigned] [usertype] h_version
fs/dlm/util.c:27:17: got restricted __le32 [usertype] <noident>
..lots more...

fs/dlm/util.c:149:17: warning: cast to restricted __le32
fs/dlm/util.c:150:19: warning: cast to restricted __le32
fs/dlm/util.c:151:15: warning: cast to restricted __le64
fs/dlm/util.c:152:16: warning: cast to restricted __le64
fs/dlm/util.c:153:21: warning: cast to restricted __le64

Signed-off-by: Harvey Harrison <harvey.harrison@gmail.com>
---
fs/dlm/dir.c | 18 ++++----
fs/dlm/util.c | 148 ++++++++++++++++++++++++++++----------------------------
2 files changed, 83 insertions(+), 83 deletions(-)

diff --git a/fs/dlm/dir.c b/fs/dlm/dir.c
index 85defeb..92969f8 100644
--- a/fs/dlm/dir.c
+++ b/fs/dlm/dir.c
@@ -374,7 +374,7 @@ void dlm_copy_master_names(struct dlm_ls *ls, char *inbuf, int inlen,
struct list_head *list;
struct dlm_rsb *r;
int offset = 0, dir_nodeid;
- uint16_t be_namelen;
+ __be16 be_namelen;

down_read(&ls->ls_root_sem);

@@ -410,15 +410,15 @@ void dlm_copy_master_names(struct dlm_ls *ls, char *inbuf, int inlen,

if (offset + sizeof(uint16_t)*2 + r->res_length > outlen) {
/* Write end-of-block record */
- be_namelen = 0;
- memcpy(outbuf + offset, &be_namelen, sizeof(uint16_t));
- offset += sizeof(uint16_t);
+ be_namelen = cpu_to_be16(0);
+ memcpy(outbuf + offset, &be_namelen, sizeof(__be16));
+ offset += sizeof(__be16);
goto out;
}

be_namelen = cpu_to_be16(r->res_length);
- memcpy(outbuf + offset, &be_namelen, sizeof(uint16_t));
- offset += sizeof(uint16_t);
+ memcpy(outbuf + offset, &be_namelen, sizeof(__be16));
+ offset += sizeof(__be16);
memcpy(outbuf + offset, r->res_name, r->res_length);
offset += r->res_length;
}
@@ -430,9 +430,9 @@ void dlm_copy_master_names(struct dlm_ls *ls, char *inbuf, int inlen,

if ((list == &ls->ls_root_list) &&
(offset + sizeof(uint16_t) <= outlen)) {
- be_namelen = 0xFFFF;
- memcpy(outbuf + offset, &be_namelen, sizeof(uint16_t));
- offset += sizeof(uint16_t);
+ be_namelen = cpu_to_be16(0xFFFF);
+ memcpy(outbuf + offset, &be_namelen, sizeof(__be16));
+ offset += sizeof(__be16);
}

out:
diff --git a/fs/dlm/util.c b/fs/dlm/util.c
index e36520a..2341e16 100644
--- a/fs/dlm/util.c
+++ b/fs/dlm/util.c
@@ -24,131 +24,131 @@

static void header_out(struct dlm_header *hd)
{
- hd->h_version = cpu_to_le32(hd->h_version);
- hd->h_lockspace = cpu_to_le32(hd->h_lockspace);
- hd->h_nodeid = cpu_to_le32(hd->h_nodeid);
- hd->h_length = cpu_to_le16(hd->h_length);
+ cpu_to_le32s(&hd->h_version);
+ cpu_to_le32s(&hd->h_lockspace);
+ cpu_to_le32s(&hd->h_nodeid);
+ cpu_to_le16s(&hd->h_length);
}

static void header_in(struct dlm_header *hd)
{
- hd->h_version = le32_to_cpu(hd->h_version);
- hd->h_lockspace = le32_to_cpu(hd->h_lockspace);
- hd->h_nodeid = le32_to_cpu(hd->h_nodeid);
- hd->h_length = le16_to_cpu(hd->h_length);
+ le32_to_cpus(&hd->h_version);
+ le32_to_cpus(&hd->h_lockspace);
+ le32_to_cpus(&hd->h_nodeid);
+ le16_to_cpus(&hd->h_length);
}

/* higher errno values are inconsistent across architectures, so select
one set of values for on the wire */

-static int to_dlm_errno(int err)
+static void to_dlm_errno(int *err)
{
- switch (err) {
+ switch (*err) {
case -EDEADLK:
- return -DLM_ERRNO_EDEADLK;
+ *err = -DLM_ERRNO_EDEADLK;
case -EBADR:
- return -DLM_ERRNO_EBADR;
+ *err = -DLM_ERRNO_EBADR;
case -EBADSLT:
- return -DLM_ERRNO_EBADSLT;
+ *err = -DLM_ERRNO_EBADSLT;
case -EPROTO:
- return -DLM_ERRNO_EPROTO;
+ *err = -DLM_ERRNO_EPROTO;
case -EOPNOTSUPP:
- return -DLM_ERRNO_EOPNOTSUPP;
+ *err = -DLM_ERRNO_EOPNOTSUPP;
case -ETIMEDOUT:
- return -DLM_ERRNO_ETIMEDOUT;
+ *err = -DLM_ERRNO_ETIMEDOUT;
case -EINPROGRESS:
- return -DLM_ERRNO_EINPROGRESS;
+ *err = -DLM_ERRNO_EINPROGRESS;
}
- return err;
+ cpu_to_le32s(err);
}

-static int from_dlm_errno(int err)
+static void from_dlm_errno(int *err)
{
- switch (err) {
+ le32_to_cpus(err);
+ switch (*err) {
case -DLM_ERRNO_EDEADLK:
- return -EDEADLK;
+ *err = -EDEADLK;
case -DLM_ERRNO_EBADR:
- return -EBADR;
+ *err = -EBADR;
case -DLM_ERRNO_EBADSLT:
- return -EBADSLT;
+ *err = -EBADSLT;
case -DLM_ERRNO_EPROTO:
- return -EPROTO;
+ *err = -EPROTO;
case -DLM_ERRNO_EOPNOTSUPP:
- return -EOPNOTSUPP;
+ *err = -EOPNOTSUPP;
case -DLM_ERRNO_ETIMEDOUT:
- return -ETIMEDOUT;
+ *err = -ETIMEDOUT;
case -DLM_ERRNO_EINPROGRESS:
- return -EINPROGRESS;
+ *err = -EINPROGRESS;
}
- return err;
}

void dlm_message_out(struct dlm_message *ms)
{
header_out(&ms->m_header);

- ms->m_type = cpu_to_le32(ms->m_type);
- ms->m_nodeid = cpu_to_le32(ms->m_nodeid);
- ms->m_pid = cpu_to_le32(ms->m_pid);
- ms->m_lkid = cpu_to_le32(ms->m_lkid);
- ms->m_remid = cpu_to_le32(ms->m_remid);
- ms->m_parent_lkid = cpu_to_le32(ms->m_parent_lkid);
- ms->m_parent_remid = cpu_to_le32(ms->m_parent_remid);
- ms->m_exflags = cpu_to_le32(ms->m_exflags);
- ms->m_sbflags = cpu_to_le32(ms->m_sbflags);
- ms->m_flags = cpu_to_le32(ms->m_flags);
- ms->m_lvbseq = cpu_to_le32(ms->m_lvbseq);
- ms->m_hash = cpu_to_le32(ms->m_hash);
- ms->m_status = cpu_to_le32(ms->m_status);
- ms->m_grmode = cpu_to_le32(ms->m_grmode);
- ms->m_rqmode = cpu_to_le32(ms->m_rqmode);
- ms->m_bastmode = cpu_to_le32(ms->m_bastmode);
- ms->m_asts = cpu_to_le32(ms->m_asts);
- ms->m_result = cpu_to_le32(to_dlm_errno(ms->m_result));
+ cpu_to_le32s(&ms->m_type);
+ cpu_to_le32s(&ms->m_nodeid);
+ cpu_to_le32s(&ms->m_pid);
+ cpu_to_le32s(&ms->m_lkid);
+ cpu_to_le32s(&ms->m_remid);
+ cpu_to_le32s(&ms->m_parent_lkid);
+ cpu_to_le32s(&ms->m_parent_remid);
+ cpu_to_le32s(&ms->m_exflags);
+ cpu_to_le32s(&ms->m_sbflags);
+ cpu_to_le32s(&ms->m_flags);
+ cpu_to_le32s(&ms->m_lvbseq);
+ cpu_to_le32s(&ms->m_hash);
+ cpu_to_le32s(&ms->m_status);
+ cpu_to_le32s(&ms->m_grmode);
+ cpu_to_le32s(&ms->m_rqmode);
+ cpu_to_le32s(&ms->m_bastmode);
+ cpu_to_le32s(&ms->m_asts);
+ to_dlm_errno(&ms->m_result);
}

void dlm_message_in(struct dlm_message *ms)
{
header_in(&ms->m_header);

- ms->m_type = le32_to_cpu(ms->m_type);
- ms->m_nodeid = le32_to_cpu(ms->m_nodeid);
- ms->m_pid = le32_to_cpu(ms->m_pid);
- ms->m_lkid = le32_to_cpu(ms->m_lkid);
- ms->m_remid = le32_to_cpu(ms->m_remid);
- ms->m_parent_lkid = le32_to_cpu(ms->m_parent_lkid);
- ms->m_parent_remid = le32_to_cpu(ms->m_parent_remid);
- ms->m_exflags = le32_to_cpu(ms->m_exflags);
- ms->m_sbflags = le32_to_cpu(ms->m_sbflags);
- ms->m_flags = le32_to_cpu(ms->m_flags);
- ms->m_lvbseq = le32_to_cpu(ms->m_lvbseq);
- ms->m_hash = le32_to_cpu(ms->m_hash);
- ms->m_status = le32_to_cpu(ms->m_status);
- ms->m_grmode = le32_to_cpu(ms->m_grmode);
- ms->m_rqmode = le32_to_cpu(ms->m_rqmode);
- ms->m_bastmode = le32_to_cpu(ms->m_bastmode);
- ms->m_asts = le32_to_cpu(ms->m_asts);
- ms->m_result = from_dlm_errno(le32_to_cpu(ms->m_result));
+ le32_to_cpus(&ms->m_type);
+ le32_to_cpus(&ms->m_nodeid);
+ le32_to_cpus(&ms->m_pid);
+ le32_to_cpus(&ms->m_lkid);
+ le32_to_cpus(&ms->m_remid);
+ le32_to_cpus(&ms->m_parent_lkid);
+ le32_to_cpus(&ms->m_parent_remid);
+ le32_to_cpus(&ms->m_exflags);
+ le32_to_cpus(&ms->m_sbflags);
+ le32_to_cpus(&ms->m_flags);
+ le32_to_cpus(&ms->m_lvbseq);
+ le32_to_cpus(&ms->m_hash);
+ le32_to_cpus(&ms->m_status);
+ le32_to_cpus(&ms->m_grmode);
+ le32_to_cpus(&ms->m_rqmode);
+ le32_to_cpus(&ms->m_bastmode);
+ le32_to_cpus(&ms->m_asts);
+ from_dlm_errno(&ms->m_result);
}

void dlm_rcom_out(struct dlm_rcom *rc)
{
header_out(&rc->rc_header);

- rc->rc_type = cpu_to_le32(rc->rc_type);
- rc->rc_result = cpu_to_le32(rc->rc_result);
- rc->rc_id = cpu_to_le64(rc->rc_id);
- rc->rc_seq = cpu_to_le64(rc->rc_seq);
- rc->rc_seq_reply = cpu_to_le64(rc->rc_seq_reply);
+ cpu_to_le32s(&rc->rc_type);
+ cpu_to_le32s(&rc->rc_result);
+ cpu_to_le64s(&rc->rc_id);
+ cpu_to_le64s(&rc->rc_seq);
+ cpu_to_le64s(&rc->rc_seq_reply);
}

void dlm_rcom_in(struct dlm_rcom *rc)
{
header_in(&rc->rc_header);

- rc->rc_type = le32_to_cpu(rc->rc_type);
- rc->rc_result = le32_to_cpu(rc->rc_result);
- rc->rc_id = le64_to_cpu(rc->rc_id);
- rc->rc_seq = le64_to_cpu(rc->rc_seq);
- rc->rc_seq_reply = le64_to_cpu(rc->rc_seq_reply);
+ le32_to_cpus(&rc->rc_type);
+ le32_to_cpus(&rc->rc_result);
+ le64_to_cpus(&rc->rc_id);
+ le64_to_cpus(&rc->rc_seq);
+ le64_to_cpus(&rc->rc_seq_reply);
}
--
1.5.6.3.499.geae9




\
 
 \ /
  Last update: 2008-07-16 22:19    [W:0.065 / U:61.832 seconds]
©2003-2017 Jasper Spaans. hosted at Digital OceanAdvertise on this site