1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
2 * vim:expandtab:shiftwidth=8:tabstop=8:
4 * Lustre Lite Update Records
6 * Copyright (c) 2002, 2003 Cluster File Systems, Inc.
8 * This file is part of Lustre, http://www.lustre.org.
10 * Lustre is free software; you can redistribute it and/or
11 * modify it under the terms of version 2 of the GNU General Public
12 * License as published by the Free Software Foundation.
14 * Lustre is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
19 * You should have received a copy of the GNU General Public License
20 * along with Lustre; if not, write to the Free Software
21 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24 #include <linux/config.h>
25 #include <linux/module.h>
26 #include <linux/kernel.h>
28 #include <linux/string.h>
29 #include <linux/stat.h>
30 #include <linux/errno.h>
31 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
32 #include <linux/locks.h> // for wait_on_buffer
34 #include <linux/buffer_head.h> // for wait_on_buffer
36 #include <linux/unistd.h>
38 #include <asm/system.h>
39 #include <asm/uaccess.h>
42 #include <linux/stat.h>
43 #include <asm/uaccess.h>
44 #include <linux/slab.h>
45 #include <asm/segment.h>
47 #define DEBUG_SUBSYSTEM S_MDS
49 #include <linux/obd_support.h>
50 #include <linux/lustre_lib.h>
51 #include <linux/lustre_mds.h>
52 #include <linux/lustre_lite.h>
54 void mds_pack_inode2fid(struct ll_fid *fid, struct inode *inode)
56 fid->id = HTON__u64(inode->i_ino);
57 fid->generation = HTON__u32(inode->i_generation);
58 fid->f_type = HTON__u32(S_IFMT & inode->i_mode);
62 void mds_pack_inode2body(struct mds_body *b, struct inode *inode)
64 b->valid = OBD_MD_FLID | OBD_MD_FLATIME | OBD_MD_FLMTIME |
65 OBD_MD_FLCTIME | OBD_MD_FLSIZE | OBD_MD_FLBLOCKS |
66 OBD_MD_FLUID | OBD_MD_FLGID | OBD_MD_FLTYPE | OBD_MD_FLMODE |
67 OBD_MD_FLNLINK | OBD_MD_FLGENER;
68 b->ino = HTON__u32(inode->i_ino);
69 b->atime = HTON__u32(inode->i_atime);
70 b->mtime = HTON__u32(inode->i_mtime);
71 b->ctime = HTON__u32(inode->i_ctime);
72 b->mode = HTON__u32(inode->i_mode);
73 b->size = HTON__u64(inode->i_size);
74 b->blocks = HTON__u64(inode->i_blocks);
75 b->uid = HTON__u32(inode->i_uid);
76 b->gid = HTON__u32(inode->i_gid);
77 b->flags = HTON__u32(inode->i_flags);
78 b->rdev = HTON__u32(b->rdev);
79 b->nlink = HTON__u32(inode->i_nlink);
80 b->generation = HTON__u32(inode->i_generation);
81 b->suppgid = HTON__u32(-1);
85 void mds_pack_fid(struct ll_fid *fid)
87 fid->id = HTON__u64(fid->id);
88 fid->generation = HTON__u32(fid->generation);
89 fid->f_type = HTON__u32(fid->f_type);
92 static void mds_pack_body(struct mds_body *b)
97 b->fsuid = HTON__u32(current->fsuid);
98 b->fsgid = HTON__u32(current->fsgid);
99 b->capability = HTON__u32(current->cap_effective);
101 mds_pack_fid(&b->fid1);
102 mds_pack_fid(&b->fid2);
103 b->size = HTON__u64(b->size);
104 b->ino = HTON__u32(b->ino);
105 b->valid = HTON__u32(b->valid);
106 b->mode = HTON__u32(b->mode);
107 b->uid = HTON__u32(b->uid);
108 b->gid = HTON__u32(b->gid);
109 b->mtime = HTON__u32(b->mtime);
110 b->ctime = HTON__u32(b->ctime);
111 b->atime = HTON__u32(b->atime);
112 b->flags = HTON__u32(b->flags);
113 b->rdev = HTON__u32(b->rdev);
114 b->nlink = HTON__u32(b->nlink);
115 b->generation = HTON__u32(b->generation);
116 b->suppgid = HTON__u32(b->suppgid);
119 void mds_getattr_pack(struct ptlrpc_request *req, int valid, int offset,
121 struct inode *inode, const char *name, int namelen)
124 b = lustre_msg_buf(req->rq_reqmsg, offset);
126 b->fsuid = HTON__u32(current->fsuid);
127 b->fsgid = HTON__u32(current->fsgid);
128 b->capability = HTON__u32(current->cap_effective);
129 b->valid = HTON__u32(valid);
130 b->flags = HTON__u32(flags);
131 if (in_group_p(inode->i_gid))
132 b->suppgid = HTON__u32(inode->i_gid);
134 b->suppgid = HTON__u32(-1);
136 ll_inode2fid(&b->fid1, inode);
139 tmp = lustre_msg_buf(req->rq_reqmsg, offset + 1);
140 LOGL0(name, namelen, tmp);
144 void mds_readdir_pack(struct ptlrpc_request *req, __u64 offset,
145 obd_id ino, int type, __u64 xid)
149 b = lustre_msg_buf(req->rq_reqmsg, 0);
150 b->fsuid = HTON__u32(current->fsuid);
151 b->fsgid = HTON__u32(current->fsgid);
152 b->capability = HTON__u32(current->cap_effective);
153 b->fid1.id = HTON__u64(ino);
154 b->fid1.f_type = HTON__u32(type);
155 b->size = HTON__u64(offset);
156 b->suppgid = HTON__u32(-1);
157 b->blocks = HTON__u64(xid);
161 void mds_pack_req_body(struct ptlrpc_request *req)
163 struct mds_body *b = lustre_msg_buf(req->rq_reqmsg, 0);
167 void mds_pack_rep_body(struct ptlrpc_request *req)
169 struct mds_body *b = lustre_msg_buf(req->rq_repmsg, 0);
174 /* packing of MDS records */
175 void mds_create_pack(struct ptlrpc_request *req, int offset, struct inode *dir,
176 __u32 mode, __u64 rdev, __u32 uid, __u32 gid, __u64 time,
177 const char *name, int namelen,
178 const void *data, int datalen)
180 struct mds_rec_create *rec;
182 rec = lustre_msg_buf(req->rq_reqmsg, offset);
184 rec->cr_opcode = HTON__u32(REINT_CREATE);
185 rec->cr_fsuid = HTON__u32(current->fsuid);
186 rec->cr_fsgid = HTON__u32(current->fsgid);
187 rec->cr_cap = HTON__u32(current->cap_effective);
188 ll_inode2fid(&rec->cr_fid, dir);
189 memset(&rec->cr_replayfid, 0, sizeof(rec->cr_replayfid));
190 rec->cr_mode = HTON__u32(mode);
191 rec->cr_rdev = HTON__u64(rdev);
192 rec->cr_uid = HTON__u32(uid);
193 rec->cr_gid = HTON__u32(gid);
194 rec->cr_time = HTON__u64(time);
196 tmp = lustre_msg_buf(req->rq_reqmsg, offset + 1);
197 LOGL0(name, namelen, tmp);
200 tmp = lustre_msg_buf(req->rq_reqmsg, offset + 2);
201 LOGL0(data, datalen, tmp);
204 /* packing of MDS records */
205 void mds_open_pack(struct ptlrpc_request *req, int offset, struct inode *dir,
206 __u32 mode, __u64 rdev, __u32 uid, __u32 gid, __u64 time,
208 const char *name, int namelen,
209 const void *data, int datalen)
211 struct mds_rec_create *rec;
213 rec = lustre_msg_buf(req->rq_reqmsg, offset);
215 /* XXX do something about time, uid, gid */
216 rec->cr_opcode = HTON__u32(REINT_OPEN);
217 rec->cr_fsuid = HTON__u32(current->fsuid);
218 rec->cr_fsgid = HTON__u32(current->fsgid);
219 rec->cr_cap = HTON__u32(current->cap_effective);
220 ll_inode2fid(&rec->cr_fid, dir);
221 memset(&rec->cr_replayfid, 0, sizeof(rec->cr_replayfid));
222 rec->cr_mode = HTON__u32(mode);
223 rec->cr_flags = HTON__u32(flags);
224 rec->cr_rdev = HTON__u64(rdev);
225 rec->cr_uid = HTON__u32(uid);
226 rec->cr_gid = HTON__u32(gid);
227 rec->cr_time = HTON__u64(time);
228 if (in_group_p(dir->i_gid))
229 rec->cr_suppgid = HTON__u32(dir->i_gid);
231 rec->cr_suppgid = HTON__u32(-1);
233 tmp = lustre_msg_buf(req->rq_reqmsg, offset + 1);
234 LOGL0(name, namelen, tmp);
237 tmp = lustre_msg_buf(req->rq_reqmsg, offset + 2);
238 LOGL0(data, datalen, tmp);
242 void mds_setattr_pack(struct ptlrpc_request *req,
243 struct inode *inode, struct iattr *iattr,
246 struct mds_rec_setattr *rec = lustre_msg_buf(req->rq_reqmsg, 0);
248 rec->sa_opcode = HTON__u32(REINT_SETATTR);
249 rec->sa_fsuid = HTON__u32(current->fsuid);
250 rec->sa_fsgid = HTON__u32(current->fsgid);
251 rec->sa_cap = HTON__u32(current->cap_effective);
252 ll_inode2fid(&rec->sa_fid, inode);
255 rec->sa_valid = HTON__u32(iattr->ia_valid);
256 rec->sa_mode = HTON__u32(iattr->ia_mode);
257 rec->sa_uid = HTON__u32(iattr->ia_uid);
258 rec->sa_gid = HTON__u32(iattr->ia_gid);
259 rec->sa_size = HTON__u64(iattr->ia_size);
260 rec->sa_atime = HTON__u64(iattr->ia_atime);
261 rec->sa_mtime = HTON__u64(iattr->ia_mtime);
262 rec->sa_ctime = HTON__u64(iattr->ia_ctime);
263 rec->sa_attr_flags = HTON__u32(iattr->ia_attr_flags);
265 if ((iattr->ia_valid & ATTR_GID) && in_group_p(iattr->ia_gid))
266 rec->sa_suppgid = HTON__u32(iattr->ia_gid);
267 else if ((iattr->ia_valid & ATTR_MODE) &&
268 in_group_p(inode->i_gid))
269 rec->sa_suppgid = HTON__u32(inode->i_gid);
271 rec->sa_suppgid = HTON__u32(-1);
275 memcpy(lustre_msg_buf(req->rq_reqmsg, 1), ea, ealen);
278 void mds_unlink_pack(struct ptlrpc_request *req, int offset,
279 struct inode *inode, struct inode *child, __u32 mode,
280 const char *name, int namelen)
282 struct mds_rec_unlink *rec;
285 rec = lustre_msg_buf(req->rq_reqmsg, offset);
287 rec->ul_opcode = HTON__u32(REINT_UNLINK);
288 rec->ul_fsuid = HTON__u32(current->fsuid);
289 rec->ul_fsgid = HTON__u32(current->fsgid);
290 rec->ul_cap = HTON__u32(current->cap_effective);
291 rec->ul_mode = HTON__u32(mode);
292 if (in_group_p(inode->i_gid))
293 rec->ul_suppgid = HTON__u32(inode->i_gid);
295 rec->ul_suppgid = HTON__u32(-1);
296 ll_inode2fid(&rec->ul_fid1, inode);
298 ll_inode2fid(&rec->ul_fid2, child);
300 tmp = lustre_msg_buf(req->rq_reqmsg, offset + 1);
301 LOGL0(name, namelen, tmp);
304 void mds_link_pack(struct ptlrpc_request *req, int offset,
305 struct inode *inode, struct inode *dir,
306 const char *name, int namelen)
308 struct mds_rec_link *rec;
311 rec = lustre_msg_buf(req->rq_reqmsg, offset);
313 rec->lk_opcode = HTON__u32(REINT_LINK);
314 rec->lk_fsuid = HTON__u32(current->fsuid);
315 rec->lk_fsgid = HTON__u32(current->fsgid);
316 rec->lk_cap = HTON__u32(current->cap_effective);
317 if (in_group_p(dir->i_gid))
318 rec->lk_suppgid = HTON__u32(dir->i_gid);
320 rec->lk_suppgid = HTON__u32(-1);
321 ll_inode2fid(&rec->lk_fid1, inode);
322 ll_inode2fid(&rec->lk_fid2, dir);
324 tmp = lustre_msg_buf(req->rq_reqmsg, offset + 1);
325 LOGL0(name, namelen, tmp);
328 void mds_rename_pack(struct ptlrpc_request *req, int offset,
329 struct inode *srcdir, struct inode *tgtdir,
330 const char *old, int oldlen, const char *new, int newlen)
332 struct mds_rec_rename *rec;
335 rec = lustre_msg_buf(req->rq_reqmsg, offset);
337 /* XXX do something about time, uid, gid */
338 rec->rn_opcode = HTON__u32(REINT_RENAME);
339 rec->rn_fsuid = HTON__u32(current->fsuid);
340 rec->rn_fsgid = HTON__u32(current->fsgid);
341 rec->rn_cap = HTON__u32(current->cap_effective);
342 ll_inode2fid(&rec->rn_fid1, srcdir);
343 ll_inode2fid(&rec->rn_fid2, tgtdir);
345 tmp = lustre_msg_buf(req->rq_reqmsg, offset + 1);
346 LOGL0(old, oldlen, tmp);
349 tmp = lustre_msg_buf(req->rq_reqmsg, offset + 2);
350 LOGL0(new, newlen, tmp);
355 void mds_unpack_fid(struct ll_fid *fid)
357 fid->id = NTOH__u64(fid->id);
358 fid->generation = NTOH__u32(fid->generation);
359 fid->f_type = NTOH__u32(fid->f_type);
362 void mds_unpack_body(struct mds_body *b)
367 mds_unpack_fid(&b->fid1);
368 mds_unpack_fid(&b->fid2);
369 b->size = NTOH__u64(b->size);
370 b->blocks = NTOH__u64(b->blocks);
371 b->valid = NTOH__u32(b->valid);
372 b->fsuid = NTOH__u32(b->fsuid);
373 b->fsgid = NTOH__u32(b->fsgid);
374 b->capability = NTOH__u32(b->capability);
375 b->ino = NTOH__u32(b->ino);
376 b->mode = NTOH__u32(b->mode);
377 b->uid = NTOH__u32(b->uid);
378 b->gid = NTOH__u32(b->gid);
379 b->mtime = NTOH__u32(b->mtime);
380 b->ctime = NTOH__u32(b->ctime);
381 b->atime = NTOH__u32(b->atime);
382 b->flags = NTOH__u32(b->flags);
383 b->rdev = NTOH__u32(b->rdev);
384 b->nlink = NTOH__u32(b->nlink);
385 b->generation = NTOH__u32(b->generation);
386 b->suppgid = NTOH__u32(b->suppgid);
389 static int mds_setattr_unpack(struct ptlrpc_request *req, int offset,
390 struct mds_update_record *r)
392 struct iattr *attr = &r->ur_iattr;
393 struct mds_rec_setattr *rec = lustre_msg_buf(req->rq_reqmsg, offset);
396 if (req->rq_reqmsg->bufcount < offset + 1 ||
397 req->rq_reqmsg->buflens[offset] != sizeof(*rec))
400 r->ur_fsuid = NTOH__u32(rec->sa_fsuid);
401 r->ur_fsgid = NTOH__u32(rec->sa_fsgid);
402 r->ur_cap = NTOH__u32(rec->sa_cap);
403 r->ur_suppgid = NTOH__u32(rec->sa_suppgid);
404 r->ur_fid1 = &rec->sa_fid;
405 attr->ia_valid = NTOH__u32(rec->sa_valid);
406 attr->ia_mode = NTOH__u32(rec->sa_mode);
407 attr->ia_uid = NTOH__u32(rec->sa_uid);
408 attr->ia_gid = NTOH__u32(rec->sa_gid);
409 attr->ia_size = NTOH__u64(rec->sa_size);
410 attr->ia_atime = NTOH__u64(rec->sa_atime);
411 attr->ia_mtime = NTOH__u64(rec->sa_mtime);
412 attr->ia_ctime = NTOH__u64(rec->sa_ctime);
413 attr->ia_attr_flags = NTOH__u32(rec->sa_attr_flags);
415 if (req->rq_reqmsg->bufcount == offset + 2) {
416 r->ur_namelen = req->rq_reqmsg->buflens[offset + 1];
417 r->ur_name = lustre_msg_buf(req->rq_reqmsg, offset + 1);
425 static int mds_create_unpack(struct ptlrpc_request *req, int offset,
426 struct mds_update_record *r)
428 struct mds_rec_create *rec = lustre_msg_buf(req->rq_reqmsg, offset);
431 if (req->rq_reqmsg->bufcount < offset + 2 ||
432 req->rq_reqmsg->buflens[offset] != sizeof(*rec))
435 r->ur_fsuid = NTOH__u32(rec->cr_fsuid);
436 r->ur_fsgid = NTOH__u32(rec->cr_fsgid);
437 r->ur_cap = NTOH__u32(rec->cr_cap);
438 r->ur_fid1 = &rec->cr_fid;
439 r->ur_fid2 = &rec->cr_replayfid;
440 r->ur_mode = NTOH__u32(rec->cr_mode);
441 r->ur_rdev = NTOH__u64(rec->cr_rdev);
442 r->ur_uid = NTOH__u32(rec->cr_uid);
443 r->ur_gid = NTOH__u32(rec->cr_gid);
444 r->ur_time = NTOH__u64(rec->cr_time);
445 r->ur_flags = NTOH__u32(rec->cr_flags);
446 r->ur_suppgid = NTOH__u32(rec->cr_suppgid);
448 r->ur_name = lustre_msg_buf(req->rq_reqmsg, offset + 1);
449 r->ur_namelen = req->rq_reqmsg->buflens[offset + 1];
451 if (req->rq_reqmsg->bufcount == offset + 3) {
452 r->ur_tgt = lustre_msg_buf(req->rq_reqmsg, offset + 2);
453 r->ur_tgtlen = req->rq_reqmsg->buflens[offset + 2];
461 static int mds_link_unpack(struct ptlrpc_request *req, int offset,
462 struct mds_update_record *r)
464 struct mds_rec_link *rec = lustre_msg_buf(req->rq_reqmsg, offset);
467 if (req->rq_reqmsg->bufcount != offset + 2 ||
468 req->rq_reqmsg->buflens[offset] != sizeof(*rec))
471 r->ur_fsuid = NTOH__u32(rec->lk_fsuid);
472 r->ur_fsgid = NTOH__u32(rec->lk_fsgid);
473 r->ur_cap = NTOH__u32(rec->lk_cap);
474 r->ur_suppgid = NTOH__u32(rec->lk_suppgid);
475 r->ur_fid1 = &rec->lk_fid1;
476 r->ur_fid2 = &rec->lk_fid2;
478 r->ur_name = lustre_msg_buf(req->rq_reqmsg, offset + 1);
479 r->ur_namelen = req->rq_reqmsg->buflens[offset + 1];
483 static int mds_unlink_unpack(struct ptlrpc_request *req, int offset,
484 struct mds_update_record *r)
486 struct mds_rec_unlink *rec = lustre_msg_buf(req->rq_reqmsg, offset);
489 if (req->rq_reqmsg->bufcount != offset + 2 ||
490 req->rq_reqmsg->buflens[offset] != sizeof(*rec))
493 r->ur_fsuid = NTOH__u32(rec->ul_fsuid);
494 r->ur_fsgid = NTOH__u32(rec->ul_fsgid);
495 r->ur_cap = NTOH__u32(rec->ul_cap);
496 r->ur_mode = NTOH__u32(rec->ul_mode);
497 r->ur_suppgid = NTOH__u32(rec->ul_suppgid);
498 r->ur_fid1 = &rec->ul_fid1;
499 r->ur_fid2 = &rec->ul_fid2;
501 r->ur_name = lustre_msg_buf(req->rq_reqmsg, offset + 1);
502 r->ur_namelen = req->rq_reqmsg->buflens[offset + 1];
506 static int mds_rename_unpack(struct ptlrpc_request *req, int offset,
507 struct mds_update_record *r)
509 struct mds_rec_rename *rec = lustre_msg_buf(req->rq_reqmsg, offset);
512 if (req->rq_reqmsg->bufcount != offset + 3 ||
513 req->rq_reqmsg->buflens[offset] != sizeof(*rec))
516 r->ur_fsuid = NTOH__u32(rec->rn_fsuid);
517 r->ur_fsgid = NTOH__u32(rec->rn_fsgid);
518 r->ur_cap = NTOH__u32(rec->rn_cap);
519 r->ur_fid1 = &rec->rn_fid1;
520 r->ur_fid2 = &rec->rn_fid2;
522 r->ur_name = lustre_msg_buf(req->rq_reqmsg, offset + 1);
523 r->ur_namelen = req->rq_reqmsg->buflens[offset + 1];
525 r->ur_tgt = lustre_msg_buf(req->rq_reqmsg, offset + 2);
526 r->ur_tgtlen = req->rq_reqmsg->buflens[offset + 2];
530 typedef int (*update_unpacker)(struct ptlrpc_request *req, int offset,
531 struct mds_update_record *r);
533 static update_unpacker mds_unpackers[REINT_MAX + 1] = {
534 [REINT_SETATTR] mds_setattr_unpack,
535 [REINT_CREATE] mds_create_unpack,
536 [REINT_LINK] mds_link_unpack,
537 [REINT_UNLINK] mds_unlink_unpack,
538 [REINT_RENAME] mds_rename_unpack,
539 [REINT_OPEN] mds_create_unpack,
542 int mds_update_unpack(struct ptlrpc_request *req, int offset,
543 struct mds_update_record *rec)
545 __u32 *opcode = lustre_msg_buf(req->rq_reqmsg, offset);
549 if (!opcode || req->rq_reqmsg->buflens[offset] < sizeof(*opcode))
552 realop = rec->ur_opcode = NTOH__u32(*opcode);
553 realop &= REINT_OPCODE_MASK;
555 if (realop < 0 || realop > REINT_MAX) {
560 rc = mds_unpackers[realop](req, offset, rec);