dlm: use fixed errno values in messages
[linux-2.6.git] / fs / dlm / util.c
1 /******************************************************************************
2 *******************************************************************************
3 **
4 **  Copyright (C) 2005 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         struct dlm_header *hd = (struct dlm_header *) ms;
89
90         header_out(hd);
91
92         ms->m_type              = cpu_to_le32(ms->m_type);
93         ms->m_nodeid            = cpu_to_le32(ms->m_nodeid);
94         ms->m_pid               = cpu_to_le32(ms->m_pid);
95         ms->m_lkid              = cpu_to_le32(ms->m_lkid);
96         ms->m_remid             = cpu_to_le32(ms->m_remid);
97         ms->m_parent_lkid       = cpu_to_le32(ms->m_parent_lkid);
98         ms->m_parent_remid      = cpu_to_le32(ms->m_parent_remid);
99         ms->m_exflags           = cpu_to_le32(ms->m_exflags);
100         ms->m_sbflags           = cpu_to_le32(ms->m_sbflags);
101         ms->m_flags             = cpu_to_le32(ms->m_flags);
102         ms->m_lvbseq            = cpu_to_le32(ms->m_lvbseq);
103         ms->m_hash              = cpu_to_le32(ms->m_hash);
104         ms->m_status            = cpu_to_le32(ms->m_status);
105         ms->m_grmode            = cpu_to_le32(ms->m_grmode);
106         ms->m_rqmode            = cpu_to_le32(ms->m_rqmode);
107         ms->m_bastmode          = cpu_to_le32(ms->m_bastmode);
108         ms->m_asts              = cpu_to_le32(ms->m_asts);
109         ms->m_result            = cpu_to_le32(to_dlm_errno(ms->m_result));
110 }
111
112 void dlm_message_in(struct dlm_message *ms)
113 {
114         struct dlm_header *hd = (struct dlm_header *) ms;
115
116         header_in(hd);
117
118         ms->m_type              = le32_to_cpu(ms->m_type);
119         ms->m_nodeid            = le32_to_cpu(ms->m_nodeid);
120         ms->m_pid               = le32_to_cpu(ms->m_pid);
121         ms->m_lkid              = le32_to_cpu(ms->m_lkid);
122         ms->m_remid             = le32_to_cpu(ms->m_remid);
123         ms->m_parent_lkid       = le32_to_cpu(ms->m_parent_lkid);
124         ms->m_parent_remid      = le32_to_cpu(ms->m_parent_remid);
125         ms->m_exflags           = le32_to_cpu(ms->m_exflags);
126         ms->m_sbflags           = le32_to_cpu(ms->m_sbflags);
127         ms->m_flags             = le32_to_cpu(ms->m_flags);
128         ms->m_lvbseq            = le32_to_cpu(ms->m_lvbseq);
129         ms->m_hash              = le32_to_cpu(ms->m_hash);
130         ms->m_status            = le32_to_cpu(ms->m_status);
131         ms->m_grmode            = le32_to_cpu(ms->m_grmode);
132         ms->m_rqmode            = le32_to_cpu(ms->m_rqmode);
133         ms->m_bastmode          = le32_to_cpu(ms->m_bastmode);
134         ms->m_asts              = le32_to_cpu(ms->m_asts);
135         ms->m_result            = from_dlm_errno(le32_to_cpu(ms->m_result));
136 }
137
138 static void rcom_lock_out(struct rcom_lock *rl)
139 {
140         rl->rl_ownpid           = cpu_to_le32(rl->rl_ownpid);
141         rl->rl_lkid             = cpu_to_le32(rl->rl_lkid);
142         rl->rl_remid            = cpu_to_le32(rl->rl_remid);
143         rl->rl_parent_lkid      = cpu_to_le32(rl->rl_parent_lkid);
144         rl->rl_parent_remid     = cpu_to_le32(rl->rl_parent_remid);
145         rl->rl_exflags          = cpu_to_le32(rl->rl_exflags);
146         rl->rl_flags            = cpu_to_le32(rl->rl_flags);
147         rl->rl_lvbseq           = cpu_to_le32(rl->rl_lvbseq);
148         rl->rl_result           = cpu_to_le32(rl->rl_result);
149         rl->rl_wait_type        = cpu_to_le16(rl->rl_wait_type);
150         rl->rl_namelen          = cpu_to_le16(rl->rl_namelen);
151 }
152
153 static void rcom_lock_in(struct rcom_lock *rl)
154 {
155         rl->rl_ownpid           = le32_to_cpu(rl->rl_ownpid);
156         rl->rl_lkid             = le32_to_cpu(rl->rl_lkid);
157         rl->rl_remid            = le32_to_cpu(rl->rl_remid);
158         rl->rl_parent_lkid      = le32_to_cpu(rl->rl_parent_lkid);
159         rl->rl_parent_remid     = le32_to_cpu(rl->rl_parent_remid);
160         rl->rl_exflags          = le32_to_cpu(rl->rl_exflags);
161         rl->rl_flags            = le32_to_cpu(rl->rl_flags);
162         rl->rl_lvbseq           = le32_to_cpu(rl->rl_lvbseq);
163         rl->rl_result           = le32_to_cpu(rl->rl_result);
164         rl->rl_wait_type        = le16_to_cpu(rl->rl_wait_type);
165         rl->rl_namelen          = le16_to_cpu(rl->rl_namelen);
166 }
167
168 static void rcom_config_out(struct rcom_config *rf)
169 {
170         rf->rf_lvblen           = cpu_to_le32(rf->rf_lvblen);
171         rf->rf_lsflags          = cpu_to_le32(rf->rf_lsflags);
172 }
173
174 static void rcom_config_in(struct rcom_config *rf)
175 {
176         rf->rf_lvblen           = le32_to_cpu(rf->rf_lvblen);
177         rf->rf_lsflags          = le32_to_cpu(rf->rf_lsflags);
178 }
179
180 void dlm_rcom_out(struct dlm_rcom *rc)
181 {
182         struct dlm_header *hd = (struct dlm_header *) rc;
183         int type = rc->rc_type;
184
185         header_out(hd);
186
187         rc->rc_type             = cpu_to_le32(rc->rc_type);
188         rc->rc_result           = cpu_to_le32(rc->rc_result);
189         rc->rc_id               = cpu_to_le64(rc->rc_id);
190         rc->rc_seq              = cpu_to_le64(rc->rc_seq);
191         rc->rc_seq_reply        = cpu_to_le64(rc->rc_seq_reply);
192
193         if ((type == DLM_RCOM_LOCK) || (type == DLM_RCOM_LOCK_REPLY))
194                 rcom_lock_out((struct rcom_lock *) rc->rc_buf);
195
196         else if (type == DLM_RCOM_STATUS_REPLY)
197                 rcom_config_out((struct rcom_config *) rc->rc_buf);
198 }
199
200 void dlm_rcom_in(struct dlm_rcom *rc)
201 {
202         struct dlm_header *hd = (struct dlm_header *) rc;
203         int type;
204
205         header_in(hd);
206
207         rc->rc_type             = le32_to_cpu(rc->rc_type);
208         rc->rc_result           = le32_to_cpu(rc->rc_result);
209         rc->rc_id               = le64_to_cpu(rc->rc_id);
210         rc->rc_seq              = le64_to_cpu(rc->rc_seq);
211         rc->rc_seq_reply        = le64_to_cpu(rc->rc_seq_reply);
212
213         type = rc->rc_type;
214
215         if ((type == DLM_RCOM_LOCK) || (type == DLM_RCOM_LOCK_REPLY))
216                 rcom_lock_in((struct rcom_lock *) rc->rc_buf);
217
218         else if (type == DLM_RCOM_STATUS_REPLY)
219                 rcom_config_in((struct rcom_config *) rc->rc_buf);
220 }
221