Whamcloud - gitweb
f13eaa4414295f15e8b7abb6d142c7b413f0c158
[fs/lustre-release.git] / lustre / lib / mds_pack.c
1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
2  * vim:expandtab:shiftwidth=8:tabstop=8:
3  *
4  *  Copyright (C) 2001 Cluster File Systems, Inc. <braam@clusterfs.com>
5  *
6  *   This file is part of Lustre, http://www.lustre.org.
7  *
8  *   Lustre is free software; you can redistribute it and/or
9  *   modify it under the terms of version 2 of the GNU General Public
10  *   License as published by the Free Software Foundation.
11  *
12  *   Lustre is distributed in the hope that it will be useful,
13  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
14  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  *   GNU General Public License for more details.
16  *
17  *   You should have received a copy of the GNU General Public License
18  *   along with Lustre; if not, write to the Free Software
19  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20  *
21  * (Un)packing of MDS and OST request records
22  *
23  */
24
25 #include <linux/module.h>
26 #include <linux/errno.h>
27 #include <linux/kernel.h>
28 #include <linux/major.h>
29 #include <linux/sched.h>
30 #include <linux/lp.h>
31 #include <linux/slab.h>
32 #include <linux/ioport.h>
33 #include <linux/fcntl.h>
34 #include <linux/delay.h>
35 #include <linux/skbuff.h>
36 #include <linux/proc_fs.h>
37 #include <linux/vmalloc.h>
38 #include <linux/fs.h>
39 #include <linux/poll.h>
40 #include <linux/init.h>
41 #include <linux/list.h>
42 #include <asm/io.h>
43 #include <asm/segment.h>
44 #include <asm/system.h>
45 #include <asm/poll.h>
46 #include <asm/uaccess.h>
47
48 #include <linux/obd_support.h>
49 #include <linux/lustre_lib.h>
50 #include <linux/lustre_idl.h>
51 #include <linux/lustre_mds.h>
52
53
54 int mds_pack_req(char *name, int namelen, char *tgt, int tgtlen, 
55                  struct mds_req_hdr **hdr, struct mds_req **req, 
56                  int *len, char **buf)
57 {
58         char *ptr;
59         struct mds_req_packed *preq;
60
61         *len = sizeof(**hdr) + size_round(namelen) + size_round(tgtlen) + 
62                 sizeof(*preq); 
63
64         *buf = kmalloc(*len, GFP_KERNEL);
65         if (!*buf) {
66                 EXIT;
67                 return -ENOMEM;
68         }
69
70         memset(*buf, 0, *len); 
71         *hdr = (struct mds_req_hdr *)(*buf);
72         *req = (struct mds_req *)(*buf + sizeof(**hdr));
73
74         preq = (struct mds_req_packed *)(*buf + sizeof(**hdr));
75         ptr = *buf + sizeof(**hdr) + sizeof(*preq);
76
77         (*hdr)->type =  MDS_TYPE_REQ;
78
79         (*req)->namelen = NTOH__u32(namelen);
80         if (name) { 
81                 preq->name_offset = (__u32)(ptr - (char *)preq);
82                 LOGL(name, namelen, ptr); 
83         } 
84
85         (*req)->tgtlen = NTOH__u32(tgtlen);
86         if (tgt) {
87                 preq->tgt_offset = (__u32)(ptr - (char *)preq);
88                 LOGL(tgt, tgtlen, ptr);
89         }
90         return 0;
91 }
92
93
94 int mds_unpack_req(char *buf, int len, 
95                    struct mds_req_hdr **hdr, struct mds_req **req)
96 {
97         struct mds_req_packed *preq;
98         __u32 off1, off2;
99         char *name, *tgt;
100
101         if (len < sizeof(**hdr) + sizeof(**req)) { 
102                 EXIT;
103                 return -EINVAL;
104         }
105
106         *hdr = (struct mds_req_hdr *) (buf);
107         preq = (struct mds_req_packed *) (buf + sizeof(**hdr));
108         off1 = preq->name_offset;
109         off2 = preq->tgt_offset;
110
111         *req = (struct mds_req *) (buf + sizeof(**hdr));
112         (*req)->namelen = NTOH__u32((*req)->namelen); 
113         (*req)->tgtlen = NTOH__u32((*req)->tgtlen); 
114
115         if (len < sizeof(**hdr) + sizeof(**req) + (*req)->namelen + 
116             (*req)->tgtlen ) { 
117                 EXIT;
118                 return -EINVAL;
119         }
120
121         if ((*req)->namelen) { 
122                 name = buf + sizeof(**hdr) + off1;
123         } else { 
124                 name = NULL;
125         }
126
127         if ((*req)->tgtlen) { 
128                 tgt = buf + sizeof(**hdr) + off2;
129         } else { 
130                 tgt = NULL;
131         }
132         (*req)->name = name;
133         (*req)->tgt = tgt;
134
135         EXIT;
136         return 0;
137 }
138
139 int mds_pack_rep(char *name, int namelen, char *tgt, int tgtlen, 
140                  struct mds_rep_hdr **hdr, struct mds_rep **rep, 
141                  int *len, char **buf)
142 {
143         char *ptr;
144         struct mds_rep_packed *prep;
145
146         *len = sizeof(**hdr) + size_round(namelen) + size_round(tgtlen) + 
147                 sizeof(*prep); 
148
149         *buf = kmalloc(*len, GFP_KERNEL);
150         if (!*buf) {
151                 EXIT;
152                 return -ENOMEM;
153         }
154
155         memset(*buf, 0, *len); 
156         *hdr = (struct mds_rep_hdr *)(*buf);
157         *rep = (struct mds_rep *)(*buf + sizeof(**hdr));
158
159         prep = (struct mds_rep_packed *)(*buf + sizeof(**hdr));
160         ptr = *buf + sizeof(**hdr) + sizeof(*prep);
161
162         (*hdr)->type =  MDS_TYPE_REP;
163
164         (*rep)->namelen = NTOH__u32(namelen);
165         if (name) { 
166                 prep->name_offset = (__u32)(ptr - (char *)prep);
167                 LOGL(name, namelen, ptr); 
168         } 
169
170         (*rep)->tgtlen = NTOH__u32(tgtlen);
171         if (tgt) { 
172                 prep->tgt_offset = (__u32)(ptr - (char *)prep);
173                 LOGL(tgt, tgtlen, ptr);
174         }
175         return 0;
176 }
177
178
179 int mds_unpack_rep(char *buf, int len, 
180                    struct mds_rep_hdr **hdr, struct mds_rep **rep)
181 {
182         struct mds_rep_packed *prep;
183         __u32 off1, off2;
184
185         if (len < sizeof(**hdr) + sizeof(**rep)) { 
186                 EXIT;
187                 return -EINVAL;
188         }
189
190         *hdr = (struct mds_rep_hdr *) (buf);
191         prep = (struct mds_rep_packed *) (buf + sizeof(**hdr));
192         off1 = prep->name_offset;
193         off2 = prep->tgt_offset;
194
195         *rep = (struct mds_rep *) (buf + sizeof(**hdr));
196         (*rep)->namelen = NTOH__u32((*rep)->namelen); 
197         (*rep)->tgtlen = NTOH__u32((*rep)->namelen); 
198
199         if (len < sizeof(**hdr) + sizeof(**rep) + (*rep)->namelen + 
200             (*rep)->tgtlen ) { 
201                 EXIT;
202                 return -EINVAL;
203         }
204
205         if ((*rep)->namelen) { 
206                 (*rep)->name = buf + sizeof(**hdr) + off1;
207         } else { 
208                 (*rep)->name = NULL;
209         }
210
211         if ((*rep)->tgtlen) { 
212                 (*rep)->tgt = buf + sizeof(**hdr) + off2;
213         } else { 
214                 (*rep)->tgt = NULL;
215         }
216         
217
218         EXIT;
219         return 0;
220 }
221
222 #if 0
223 int mds_pack_rep(char *name, int namelen, char *tgt, int tgtlen, 
224                  struct mds_rep_hdr **hdr, struct mds_rep **rep, 
225                  int *len, char **buf)
226 {
227         char *ptr;
228
229         *len = sizeof(**hdr) + size_round(namelen) + size_round(tgtlen) + 
230                 sizeof(**rep); 
231
232         *buf = kmalloc(*len, GFP_KERNEL);
233         if (!*buf) {
234                 EXIT;
235                 return -ENOMEM;
236         }
237
238         memset(*buf, 0, *len); 
239         *hdr = (struct mds_rep_hdr *)(*buf);
240         *rep = (struct mds_rep *)(*buf + sizeof(**hdr));
241         ptr = *buf + sizeof(**hdr) + sizeof(**rep);
242
243         (*rep)->namelen = NTOH__u32(namelen);
244         if (name) { 
245                 LOGL(name, namelen, ptr); 
246         } 
247
248         (*rep)->tgtlen = NTOH__u32(tgtlen);
249         if (tgt) { 
250                 LOGL(tgt, tgtlen, ptr);
251         }
252         return 0;
253 }
254
255
256 int mds_unpack_rep(char *buf, int len, 
257                    struct mds_rep_hdr **hdr, struct mds_rep **rep)
258 {
259         if (len < sizeof(**hdr) + sizeof(**rep)) { 
260                 EXIT;
261                 return -EINVAL;
262         }
263
264         *hdr = (struct mds_rep_hdr *) (buf);
265         *rep = (struct mds_rep *) (buf + sizeof(**hdr));
266         (*rep)->namelen = NTOH__u32((*rep)->namelen); 
267         (*rep)->tgtlen = NTOH__u32((*rep)->namelen); 
268
269         if (len < sizeof(**hdr) + sizeof(**rep) + (*rep)->namelen + 
270             (*rep)->tgtlen ) { 
271                 EXIT;
272                 return -EINVAL;
273         }
274
275         if ((*rep)->namelen) { 
276                 (*rep)->name = buf + sizeof(**hdr) + sizeof(**rep);
277         } else { 
278                 (*rep)->name = NULL;
279         }
280
281         if ((*rep)->tgtlen) { 
282                 (*rep)->tgt = buf + sizeof(**hdr) + sizeof(**rep) + 
283                         size_round((*rep)->namelen);
284         } else { 
285                 (*rep)->tgt = NULL;
286         }
287
288         EXIT;
289         return 0;
290 }
291 #endif