← Back to branch summary

~ubuntu-branches/ubuntu/utopic/linux-ti-omap/utopic

« back to all changes in this revision

Viewing changes to fs/dlm/util.c

  • Committer: Bazaar Package Importer
  • Author(s): Amit Kucheria, Amit Kucheria
  • Date: 2010-03-10 02:28:15 UTC
  • Revision ID: james.westby@ubuntu.com-20100310022815-7sd3gwvn5kenaq33
Tags: 2.6.33-500.1
[ Amit Kucheria ]

* Initial release of a 2.6.33-based OMAP kernel
* UBUNTU: [Upstream] Fix omap 1-wire driver compilation
* UBUNTU: ubuntu: AppArmor -- update to mainline 2010-03-04

Show diffs side-by-side

added added

removed removed

Lines of Context:
fs/dlm/util.c
 
1
/******************************************************************************
 
2
*******************************************************************************
 
3
**
 
4
**  Copyright (C) 2005-2008 Red Hat, Inc.  All rights reserved.
 
5
**
 
6
**  This copyrighted material is made available to anyone wishing to use,
 
7
**  modify, copy, or redistribute it subject to the terms and conditions
 
8
**  of the GNU General Public License v.2.
 
9
**
 
10
*******************************************************************************
 
11
******************************************************************************/
 
12
 
 
13
#include "dlm_internal.h"
 
14
#include "rcom.h"
 
15
#include "util.h"
 
16
 
 
17
#define DLM_ERRNO_EDEADLK               35
 
18
#define DLM_ERRNO_EBADR                 53
 
19
#define DLM_ERRNO_EBADSLT               57
 
20
#define DLM_ERRNO_EPROTO                71
 
21
#define DLM_ERRNO_EOPNOTSUPP            95
 
22
#define DLM_ERRNO_ETIMEDOUT            110
 
23
#define DLM_ERRNO_EINPROGRESS          115
 
24
 
 
25
static void header_out(struct dlm_header *hd)
 
26
{
 
27
        hd->h_version           = cpu_to_le32(hd->h_version);
 
28
        hd->h_lockspace         = cpu_to_le32(hd->h_lockspace);
 
29
        hd->h_nodeid            = cpu_to_le32(hd->h_nodeid);
 
30
        hd->h_length            = cpu_to_le16(hd->h_length);
 
31
}
 
32
 
 
33
static void header_in(struct dlm_header *hd)
 
34
{
 
35
        hd->h_version           = le32_to_cpu(hd->h_version);
 
36
        hd->h_lockspace         = le32_to_cpu(hd->h_lockspace);
 
37
        hd->h_nodeid            = le32_to_cpu(hd->h_nodeid);
 
38
        hd->h_length            = le16_to_cpu(hd->h_length);
 
39
}
 
40
 
 
41
/* higher errno values are inconsistent across architectures, so select
 
42
   one set of values for on the wire */
 
43
 
 
44
static int to_dlm_errno(int err)
 
45
{
 
46
        switch (err) {
 
47
        case -EDEADLK:
 
48
                return -DLM_ERRNO_EDEADLK;
 
49
        case -EBADR:
 
50
                return -DLM_ERRNO_EBADR;
 
51
        case -EBADSLT:
 
52
                return -DLM_ERRNO_EBADSLT;
 
53
        case -EPROTO:
 
54
                return -DLM_ERRNO_EPROTO;
 
55
        case -EOPNOTSUPP:
 
56
                return -DLM_ERRNO_EOPNOTSUPP;
 
57
        case -ETIMEDOUT:
 
58
                return -DLM_ERRNO_ETIMEDOUT;
 
59
        case -EINPROGRESS:
 
60
                return -DLM_ERRNO_EINPROGRESS;
 
61
        }
 
62
        return err;
 
63
}
 
64
 
 
65
static int from_dlm_errno(int err)
 
66
{
 
67
        switch (err) {
 
68
        case -DLM_ERRNO_EDEADLK:
 
69
                return -EDEADLK;
 
70
        case -DLM_ERRNO_EBADR:
 
71
                return -EBADR;
 
72
        case -DLM_ERRNO_EBADSLT:
 
73
                return -EBADSLT;
 
74
        case -DLM_ERRNO_EPROTO:
 
75
                return -EPROTO;
 
76
        case -DLM_ERRNO_EOPNOTSUPP:
 
77
                return -EOPNOTSUPP;
 
78
        case -DLM_ERRNO_ETIMEDOUT:
 
79
                return -ETIMEDOUT;
 
80
        case -DLM_ERRNO_EINPROGRESS:
 
81
                return -EINPROGRESS;
 
82
        }
 
83
        return err;
 
84
}
 
85
 
 
86
void dlm_message_out(struct dlm_message *ms)
 
87
{
 
88
        header_out(&ms->m_header);
 
89
 
 
90
        ms->m_type              = cpu_to_le32(ms->m_type);
 
91
        ms->m_nodeid            = cpu_to_le32(ms->m_nodeid);
 
92
        ms->m_pid               = cpu_to_le32(ms->m_pid);
 
93
        ms->m_lkid              = cpu_to_le32(ms->m_lkid);
 
94
        ms->m_remid             = cpu_to_le32(ms->m_remid);
 
95
        ms->m_parent_lkid       = cpu_to_le32(ms->m_parent_lkid);
 
96
        ms->m_parent_remid      = cpu_to_le32(ms->m_parent_remid);
 
97
        ms->m_exflags           = cpu_to_le32(ms->m_exflags);
 
98
        ms->m_sbflags           = cpu_to_le32(ms->m_sbflags);
 
99
        ms->m_flags             = cpu_to_le32(ms->m_flags);
 
100
        ms->m_lvbseq            = cpu_to_le32(ms->m_lvbseq);
 
101
        ms->m_hash              = cpu_to_le32(ms->m_hash);
 
102
        ms->m_status            = cpu_to_le32(ms->m_status);
 
103
        ms->m_grmode            = cpu_to_le32(ms->m_grmode);
 
104
        ms->m_rqmode            = cpu_to_le32(ms->m_rqmode);
 
105
        ms->m_bastmode          = cpu_to_le32(ms->m_bastmode);
 
106
        ms->m_asts              = cpu_to_le32(ms->m_asts);
 
107
        ms->m_result            = cpu_to_le32(to_dlm_errno(ms->m_result));
 
108
}
 
109
 
 
110
void dlm_message_in(struct dlm_message *ms)
 
111
{
 
112
        header_in(&ms->m_header);
 
113
 
 
114
        ms->m_type              = le32_to_cpu(ms->m_type);
 
115
        ms->m_nodeid            = le32_to_cpu(ms->m_nodeid);
 
116
        ms->m_pid               = le32_to_cpu(ms->m_pid);
 
117
        ms->m_lkid              = le32_to_cpu(ms->m_lkid);
 
118
        ms->m_remid             = le32_to_cpu(ms->m_remid);
 
119
        ms->m_parent_lkid       = le32_to_cpu(ms->m_parent_lkid);
 
120
        ms->m_parent_remid      = le32_to_cpu(ms->m_parent_remid);
 
121
        ms->m_exflags           = le32_to_cpu(ms->m_exflags);
 
122
        ms->m_sbflags           = le32_to_cpu(ms->m_sbflags);
 
123
        ms->m_flags             = le32_to_cpu(ms->m_flags);
 
124
        ms->m_lvbseq            = le32_to_cpu(ms->m_lvbseq);
 
125
        ms->m_hash              = le32_to_cpu(ms->m_hash);
 
126
        ms->m_status            = le32_to_cpu(ms->m_status);
 
127
        ms->m_grmode            = le32_to_cpu(ms->m_grmode);
 
128
        ms->m_rqmode            = le32_to_cpu(ms->m_rqmode);
 
129
        ms->m_bastmode          = le32_to_cpu(ms->m_bastmode);
 
130
        ms->m_asts              = le32_to_cpu(ms->m_asts);
 
131
        ms->m_result            = from_dlm_errno(le32_to_cpu(ms->m_result));
 
132
}
 
133
 
 
134
void dlm_rcom_out(struct dlm_rcom *rc)
 
135
{
 
136
        header_out(&rc->rc_header);
 
137
 
 
138
        rc->rc_type             = cpu_to_le32(rc->rc_type);
 
139
        rc->rc_result           = cpu_to_le32(rc->rc_result);
 
140
        rc->rc_id               = cpu_to_le64(rc->rc_id);
 
141
        rc->rc_seq              = cpu_to_le64(rc->rc_seq);
 
142
        rc->rc_seq_reply        = cpu_to_le64(rc->rc_seq_reply);
 
143
}
 
144
 
 
145
void dlm_rcom_in(struct dlm_rcom *rc)
 
146
{
 
147
        header_in(&rc->rc_header);
 
148
 
 
149
        rc->rc_type             = le32_to_cpu(rc->rc_type);
 
150
        rc->rc_result           = le32_to_cpu(rc->rc_result);
 
151
        rc->rc_id               = le64_to_cpu(rc->rc_id);
 
152
        rc->rc_seq              = le64_to_cpu(rc->rc_seq);
 
153
        rc->rc_seq_reply        = le64_to_cpu(rc->rc_seq_reply);
 
154
}