1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
2 * vim:expandtab:shiftwidth=8:tabstop=8:
4 * Copryright (C) 2002 Cluster File Systems, Inc.
6 * This file is part of Lustre, http://www.sf.net/projects/lustre/
8 * This code is issued under the GNU General Public License.
9 * See the file COPYING in this distribution
11 * Lustre Lite Update Records
14 #include <linux/config.h>
15 #include <linux/module.h>
16 #include <linux/kernel.h>
18 #include <linux/string.h>
19 #include <linux/stat.h>
20 #include <linux/errno.h>
21 #include <linux/locks.h>
22 #include <linux/unistd.h>
24 #include <asm/system.h>
25 #include <asm/uaccess.h>
28 #include <linux/stat.h>
29 #include <asm/uaccess.h>
30 #include <linux/slab.h>
31 #include <asm/segment.h>
33 #define DEBUG_SUBSYSTEM S_MDS
35 #include <linux/obd_support.h>
36 #include <linux/lustre_lib.h>
37 #include <linux/lustre_mds.h>
38 #include <linux/lustre_lite.h>
40 void mds_pack_inode2fid(struct ll_fid *fid, struct inode *inode)
42 fid->id = HTON__u64(inode->i_ino);
43 fid->generation = HTON__u32(inode->i_generation);
44 fid->f_type = HTON__u32(S_IFMT & inode->i_mode);
48 void mds_pack_inode2body(struct mds_body *b, struct inode *inode)
50 b->valid = OBD_MD_FLID | OBD_MD_FLATIME | OBD_MD_FLMTIME |
51 OBD_MD_FLCTIME | OBD_MD_FLSIZE | OBD_MD_FLUID | OBD_MD_FLGID |
52 OBD_MD_FLTYPE | OBD_MD_FLMODE | OBD_MD_FLNLINK | OBD_MD_FLGENER;
53 b->ino = HTON__u32(inode->i_ino);
54 b->atime = HTON__u32(inode->i_atime);
55 b->mtime = HTON__u32(inode->i_mtime);
56 b->ctime = HTON__u32(inode->i_ctime);
57 b->mode = HTON__u32(inode->i_mode);
58 b->size = HTON__u64(inode->i_size);
59 b->uid = HTON__u32(inode->i_uid);
60 b->gid = HTON__u32(inode->i_gid);
61 b->flags = HTON__u32(inode->i_flags);
62 //b->major = HTON__u32(inode->i_major);
63 //b->minor = HTON__u32(inode->i_minor);
64 b->nlink = HTON__u32(inode->i_nlink);
65 b->generation = HTON__u32(inode->i_generation);
69 void mds_pack_fid(struct ll_fid *fid)
71 fid->id = HTON__u64(fid->id);
72 fid->generation = HTON__u32(fid->generation);
73 fid->f_type = HTON__u32(fid->f_type);
76 static void mds_pack_body(struct mds_body *b)
81 b->fsuid = HTON__u32(current->fsuid);
82 b->fsgid = HTON__u32(current->fsgid);
84 mds_pack_fid(&b->fid1);
85 mds_pack_fid(&b->fid2);
86 b->extra = HTON__u64(b->extra);
87 b->size = HTON__u64(b->size);
88 b->valid = HTON__u32(b->valid);
89 b->mode = HTON__u32(b->mode);
90 b->uid = HTON__u32(b->uid);
91 b->gid = HTON__u32(b->gid);
92 b->mtime = HTON__u32(b->mtime);
93 b->ctime = HTON__u32(b->ctime);
94 b->atime = HTON__u32(b->atime);
95 b->flags = HTON__u32(b->flags);
96 b->major = HTON__u32(b->major);
97 b->minor = HTON__u32(b->minor);
98 b->ino = HTON__u32(b->ino);
99 b->nlink = HTON__u32(b->nlink);
100 b->generation = HTON__u32(b->generation);
103 void mds_getattr_pack(struct ptlrpc_request *req, int offset,
105 const char *name, int namelen)
107 struct mds_body *rec;
108 rec = lustre_msg_buf(req->rq_reqmsg, offset);
110 ll_inode2fid(&rec->fid1, inode);
113 tmp = lustre_msg_buf(req->rq_reqmsg, offset + 1);
114 LOGL0(name, namelen, tmp);
119 void mds_pack_req_body(struct ptlrpc_request *req)
121 struct mds_body *b = lustre_msg_buf(req->rq_reqmsg, 0);
125 void mds_pack_rep_body(struct ptlrpc_request *req)
127 struct mds_body *b = lustre_msg_buf(req->rq_repmsg, 0);
132 /* packing of MDS records */
133 void mds_create_pack(struct ptlrpc_request *req, int offset,
134 struct inode *inode, __u32 mode, __u64 rdev, __u32 uid,
135 __u32 gid, __u64 time, const char *name, int namelen,
136 const char *tgt, int tgtlen)
138 struct mds_rec_create *rec;
140 rec = lustre_msg_buf(req->rq_reqmsg, offset);
142 /* XXX do something about time, uid, gid */
143 rec->cr_opcode = HTON__u32(REINT_CREATE);
144 rec->cr_fsuid = HTON__u32(current->fsuid);
145 rec->cr_fsgid = HTON__u32(current->fsgid);
146 ll_inode2fid(&rec->cr_fid, inode);
147 rec->cr_mode = HTON__u32(mode);
148 rec->cr_rdev = HTON__u64(rdev);
149 rec->cr_uid = HTON__u32(uid);
150 rec->cr_gid = HTON__u32(gid);
151 rec->cr_time = HTON__u64(time);
153 tmp = lustre_msg_buf(req->rq_reqmsg, offset + 1);
154 LOGL0(name, namelen, tmp);
157 tmp = lustre_msg_buf(req->rq_reqmsg, offset + 2);
158 LOGL0(tgt, tgtlen, tmp);
162 void mds_setattr_pack(struct ptlrpc_request *req, int offset,
163 struct inode *inode, struct iattr *iattr,
164 const char *name, int namelen)
166 struct mds_rec_setattr *rec;
167 rec = lustre_msg_buf(req->rq_reqmsg, offset);
169 rec->sa_opcode = HTON__u32(REINT_SETATTR);
170 rec->sa_fsuid = HTON__u32(current->fsuid);
171 rec->sa_fsgid = HTON__u32(current->fsgid);
172 ll_inode2fid(&rec->sa_fid, inode);
173 rec->sa_valid = HTON__u32(iattr->ia_valid);
174 rec->sa_mode = HTON__u32(iattr->ia_mode);
175 rec->sa_uid = HTON__u32(iattr->ia_uid);
176 rec->sa_gid = HTON__u32(iattr->ia_gid);
177 rec->sa_size = HTON__u64(iattr->ia_size);
178 rec->sa_atime = HTON__u64(iattr->ia_atime);
179 rec->sa_mtime = HTON__u64(iattr->ia_mtime);
180 rec->sa_ctime = HTON__u64(iattr->ia_ctime);
181 rec->sa_attr_flags = HTON__u32(iattr->ia_attr_flags);
185 tmp = lustre_msg_buf(req->rq_reqmsg, offset + 1);
186 LOGL0(name, namelen, tmp);
190 void mds_unlink_pack(struct ptlrpc_request *req, int offset,
191 struct inode *inode, struct inode *child, __u32 mode,
192 const char *name, int namelen)
194 struct mds_rec_unlink *rec;
197 rec = lustre_msg_buf(req->rq_reqmsg, offset);
199 rec->ul_opcode = HTON__u32(REINT_UNLINK);
200 rec->ul_fsuid = HTON__u32(current->fsuid);
201 rec->ul_fsgid = HTON__u32(current->fsgid);
202 rec->ul_mode = HTON__u32(mode);
203 ll_inode2fid(&rec->ul_fid1, inode);
205 ll_inode2fid(&rec->ul_fid2, child);
207 tmp = lustre_msg_buf(req->rq_reqmsg, offset + 1);
208 LOGL0(name, namelen, tmp);
211 void mds_link_pack(struct ptlrpc_request *req, int offset,
212 struct inode *inode, struct inode *dir,
213 const char *name, int namelen)
215 struct mds_rec_link *rec;
218 rec = lustre_msg_buf(req->rq_reqmsg, offset);
220 rec->lk_opcode = HTON__u32(REINT_LINK);
221 rec->lk_fsuid = HTON__u32(current->fsuid);
222 rec->lk_fsgid = HTON__u32(current->fsgid);
223 ll_inode2fid(&rec->lk_fid1, inode);
224 ll_inode2fid(&rec->lk_fid2, dir);
226 tmp = lustre_msg_buf(req->rq_reqmsg, offset + 1);
227 LOGL0(name, namelen, tmp);
230 void mds_rename_pack(struct ptlrpc_request *req, int offset,
231 struct inode *srcdir, struct inode *tgtdir,
232 const char *old, int oldlen, const char *new, int newlen)
234 struct mds_rec_rename *rec;
237 rec = lustre_msg_buf(req->rq_reqmsg, offset);
239 /* XXX do something about time, uid, gid */
240 rec->rn_opcode = HTON__u32(REINT_RENAME);
241 rec->rn_fsuid = HTON__u32(current->fsuid);
242 rec->rn_fsgid = HTON__u32(current->fsgid);
243 ll_inode2fid(&rec->rn_fid1, srcdir);
244 ll_inode2fid(&rec->rn_fid2, tgtdir);
246 tmp = lustre_msg_buf(req->rq_reqmsg, offset + 1);
247 LOGL0(old, oldlen, tmp);
250 tmp = lustre_msg_buf(req->rq_reqmsg, offset + 2);
251 LOGL0(new, newlen, tmp);
256 void mds_unpack_fid(struct ll_fid *fid)
258 fid->id = NTOH__u64(fid->id);
259 fid->generation = NTOH__u32(fid->generation);
260 fid->f_type = NTOH__u32(fid->f_type);
263 void mds_unpack_body(struct mds_body *b)
268 b->fsuid = NTOH__u32(b->fsuid);
269 b->fsgid = NTOH__u32(b->fsgid);
270 mds_unpack_fid(&b->fid1);
271 mds_unpack_fid(&b->fid2);
272 b->extra = NTOH__u64(b->extra);
273 b->size = NTOH__u64(b->size);
274 b->valid = NTOH__u32(b->valid);
275 b->mode = NTOH__u32(b->mode);
276 b->uid = NTOH__u32(b->uid);
277 b->gid = NTOH__u32(b->gid);
278 b->mtime = NTOH__u32(b->mtime);
279 b->ctime = NTOH__u32(b->ctime);
280 b->atime = NTOH__u32(b->atime);
281 b->flags = NTOH__u32(b->flags);
282 b->major = NTOH__u32(b->major);
283 b->minor = NTOH__u32(b->minor);
284 b->ino = NTOH__u32(b->ino);
285 b->nlink = NTOH__u32(b->nlink);
286 b->generation = NTOH__u32(b->generation);
289 static int mds_setattr_unpack(struct ptlrpc_request *req, int offset,
290 struct mds_update_record *r)
292 struct iattr *attr = &r->ur_iattr;
293 struct mds_rec_setattr *rec = lustre_msg_buf(req->rq_reqmsg, offset);
296 if (req->rq_reqmsg->bufcount < offset + 1 ||
297 req->rq_reqmsg->buflens[offset] != sizeof(*rec))
300 r->ur_fsuid = NTOH__u32(rec->sa_fsuid);
301 r->ur_fsgid = NTOH__u32(rec->sa_fsgid);
302 r->ur_fid1 = &rec->sa_fid;
303 attr->ia_valid = NTOH__u32(rec->sa_valid);
304 attr->ia_mode = NTOH__u32(rec->sa_mode);
305 attr->ia_uid = NTOH__u32(rec->sa_uid);
306 attr->ia_gid = NTOH__u32(rec->sa_gid);
307 attr->ia_size = NTOH__u64(rec->sa_size);
308 attr->ia_atime = NTOH__u64(rec->sa_atime);
309 attr->ia_mtime = NTOH__u64(rec->sa_mtime);
310 attr->ia_ctime = NTOH__u64(rec->sa_ctime);
311 attr->ia_attr_flags = NTOH__u32(rec->sa_attr_flags);
313 if (req->rq_reqmsg->bufcount == offset + 2) {
314 r->ur_namelen = req->rq_reqmsg->buflens[offset + 1];
315 r->ur_name = lustre_msg_buf(req->rq_reqmsg, offset + 1);
322 static int mds_create_unpack(struct ptlrpc_request *req, int offset,
323 struct mds_update_record *r)
325 struct mds_rec_create *rec = lustre_msg_buf(req->rq_reqmsg, offset);
328 if (req->rq_reqmsg->bufcount != offset + 3 ||
329 req->rq_reqmsg->buflens[offset] != sizeof(*rec))
332 r->ur_fsuid = NTOH__u32(rec->cr_fsuid);
333 r->ur_fsgid = NTOH__u32(rec->cr_fsgid);
334 r->ur_fid1 = &rec->cr_fid;
335 r->ur_mode = NTOH__u32(rec->cr_mode);
336 r->ur_rdev = NTOH__u64(rec->cr_rdev);
337 r->ur_uid = NTOH__u32(rec->cr_uid);
338 r->ur_gid = NTOH__u32(rec->cr_gid);
339 r->ur_time = NTOH__u64(rec->cr_time);
341 r->ur_name = lustre_msg_buf(req->rq_reqmsg, offset + 1);
342 r->ur_namelen = req->rq_reqmsg->buflens[offset + 1];
344 r->ur_tgt = lustre_msg_buf(req->rq_reqmsg, offset + 2);
345 r->ur_tgtlen = req->rq_reqmsg->buflens[offset + 2];
349 static int mds_link_unpack(struct ptlrpc_request *req, int offset,
350 struct mds_update_record *r)
352 struct mds_rec_link *rec = lustre_msg_buf(req->rq_reqmsg, offset);
355 if (req->rq_reqmsg->bufcount != offset + 2 ||
356 req->rq_reqmsg->buflens[offset] != sizeof(*rec))
359 r->ur_fsuid = NTOH__u32(rec->lk_fsuid);
360 r->ur_fsgid = NTOH__u32(rec->lk_fsgid);
361 r->ur_fid1 = &rec->lk_fid1;
362 r->ur_fid2 = &rec->lk_fid2;
364 r->ur_name = lustre_msg_buf(req->rq_reqmsg, offset + 1);
365 r->ur_namelen = req->rq_reqmsg->buflens[offset + 1];
369 static int mds_unlink_unpack(struct ptlrpc_request *req, int offset,
370 struct mds_update_record *r)
372 struct mds_rec_unlink *rec = lustre_msg_buf(req->rq_reqmsg, offset);
375 if (req->rq_reqmsg->bufcount != offset + 2 ||
376 req->rq_reqmsg->buflens[offset] != sizeof(*rec))
379 r->ur_fsuid = NTOH__u32(rec->ul_fsuid);
380 r->ur_fsgid = NTOH__u32(rec->ul_fsgid);
381 r->ur_mode = NTOH__u32(rec->ul_mode);
382 r->ur_fid1 = &rec->ul_fid1;
383 r->ur_fid2 = &rec->ul_fid2;
385 r->ur_name = lustre_msg_buf(req->rq_reqmsg, offset + 1);
386 r->ur_namelen = req->rq_reqmsg->buflens[offset + 1];
390 static int mds_rename_unpack(struct ptlrpc_request *req, int offset,
391 struct mds_update_record *r)
393 struct mds_rec_rename *rec = lustre_msg_buf(req->rq_reqmsg, offset);
396 if (req->rq_reqmsg->bufcount != offset + 3 ||
397 req->rq_reqmsg->buflens[offset] != sizeof(*rec))
400 r->ur_fsuid = NTOH__u32(rec->rn_fsuid);
401 r->ur_fsgid = NTOH__u32(rec->rn_fsgid);
402 r->ur_fid1 = &rec->rn_fid1;
403 r->ur_fid2 = &rec->rn_fid2;
405 r->ur_name = lustre_msg_buf(req->rq_reqmsg, offset + 1);
406 r->ur_namelen = req->rq_reqmsg->buflens[offset + 1];
408 r->ur_tgt = lustre_msg_buf(req->rq_reqmsg, offset + 2);
409 r->ur_tgtlen = req->rq_reqmsg->buflens[offset + 2];
413 typedef int (*update_unpacker)(struct ptlrpc_request *req, int offset,
414 struct mds_update_record *r);
416 static update_unpacker mds_unpackers[REINT_MAX + 1] = {
417 [REINT_SETATTR] mds_setattr_unpack,
418 [REINT_CREATE] mds_create_unpack,
419 [REINT_LINK] mds_link_unpack,
420 [REINT_UNLINK] mds_unlink_unpack,
421 [REINT_RENAME] mds_rename_unpack,
422 [REINT_RECREATE] mds_create_unpack,
425 int mds_update_unpack(struct ptlrpc_request *req, int offset,
426 struct mds_update_record *rec)
428 __u32 *opcode = lustre_msg_buf(req->rq_reqmsg, offset);
432 if (!opcode || req->rq_reqmsg->buflens[offset] < sizeof(*opcode))
435 rec->ur_opcode = NTOH__u32(*opcode);
437 if (rec->ur_opcode < 0 || rec->ur_opcode > REINT_MAX)
440 rc = mds_unpackers[rec->ur_opcode](req, offset, rec);