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 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
22 #include <linux/locks.h> // for wait_on_buffer
24 #include <linux/buffer_head.h> // for wait_on_buffer
26 #include <linux/unistd.h>
28 #include <asm/system.h>
29 #include <asm/uaccess.h>
32 #include <linux/stat.h>
33 #include <asm/uaccess.h>
34 #include <linux/slab.h>
35 #include <asm/segment.h>
37 #define DEBUG_SUBSYSTEM S_MDS
39 #include <linux/obd_support.h>
40 #include <linux/lustre_lib.h>
41 #include <linux/lustre_mds.h>
42 #include <linux/lustre_lite.h>
44 void mds_pack_inode2fid(struct ll_fid *fid, struct inode *inode)
46 fid->id = HTON__u64(inode->i_ino);
47 fid->generation = HTON__u32(inode->i_generation);
48 fid->f_type = HTON__u32(S_IFMT & inode->i_mode);
52 void mds_pack_inode2body(struct mds_body *b, struct inode *inode)
54 b->valid = OBD_MD_FLID | OBD_MD_FLATIME | OBD_MD_FLMTIME |
55 OBD_MD_FLCTIME | OBD_MD_FLSIZE | OBD_MD_FLUID | OBD_MD_FLGID |
56 OBD_MD_FLTYPE | OBD_MD_FLMODE | OBD_MD_FLNLINK | OBD_MD_FLGENER;
57 b->ino = HTON__u32(inode->i_ino);
58 b->atime = HTON__u32(inode->i_atime);
59 b->mtime = HTON__u32(inode->i_mtime);
60 b->ctime = HTON__u32(inode->i_ctime);
61 b->mode = HTON__u32(inode->i_mode);
62 b->size = HTON__u64(inode->i_size);
63 b->uid = HTON__u32(inode->i_uid);
64 b->gid = HTON__u32(inode->i_gid);
65 b->flags = HTON__u32(inode->i_flags);
66 b->rdev = HTON__u32(b->rdev);
67 b->nlink = HTON__u32(inode->i_nlink);
68 b->generation = HTON__u32(inode->i_generation);
72 void mds_pack_fid(struct ll_fid *fid)
74 fid->id = HTON__u64(fid->id);
75 fid->generation = HTON__u32(fid->generation);
76 fid->f_type = HTON__u32(fid->f_type);
79 static void mds_pack_body(struct mds_body *b)
84 b->fsuid = HTON__u32(current->fsuid);
85 b->fsgid = HTON__u32(current->fsgid);
86 b->capability = HTON__u32(current->cap_effective);
88 mds_pack_fid(&b->fid1);
89 mds_pack_fid(&b->fid2);
90 b->size = HTON__u64(b->size);
91 b->ino = HTON__u32(b->ino);
92 b->valid = HTON__u32(b->valid);
93 b->mode = HTON__u32(b->mode);
94 b->uid = HTON__u32(b->uid);
95 b->gid = HTON__u32(b->gid);
96 b->mtime = HTON__u32(b->mtime);
97 b->ctime = HTON__u32(b->ctime);
98 b->atime = HTON__u32(b->atime);
99 b->flags = HTON__u32(b->flags);
100 b->rdev = HTON__u32(b->rdev);
101 b->nlink = HTON__u32(b->nlink);
102 b->generation = HTON__u32(b->generation);
105 void mds_getattr_pack(struct ptlrpc_request *req, int offset,
107 const char *name, int namelen)
110 b = lustre_msg_buf(req->rq_reqmsg, offset);
112 b->fsuid = HTON__u32(current->fsuid);
113 b->fsgid = HTON__u32(current->fsgid);
114 b->capability = HTON__u32(current->cap_effective);
116 ll_inode2fid(&b->fid1, inode);
119 tmp = lustre_msg_buf(req->rq_reqmsg, offset + 1);
120 LOGL0(name, namelen, tmp);
124 void mds_readdir_pack(struct ptlrpc_request *req, __u64 offset,
125 obd_id ino, int type)
129 b = lustre_msg_buf(req->rq_reqmsg, 0);
130 b->fsuid = HTON__u32(current->fsuid);
131 b->fsgid = HTON__u32(current->fsgid);
132 b->capability = HTON__u32(current->cap_effective);
133 b->fid1.id = HTON__u64(ino);
134 b->fid1.f_type = HTON__u32(type);
135 b->size = HTON__u64(offset);
139 void mds_pack_req_body(struct ptlrpc_request *req)
141 struct mds_body *b = lustre_msg_buf(req->rq_reqmsg, 0);
145 void mds_pack_rep_body(struct ptlrpc_request *req)
147 struct mds_body *b = lustre_msg_buf(req->rq_repmsg, 0);
152 /* packing of MDS records */
153 void mds_create_pack(struct ptlrpc_request *req, int offset, struct inode *dir,
154 __u32 mode, __u64 rdev, __u32 uid, __u32 gid, __u64 time,
155 const char *name, int namelen,
156 const void *data, int datalen)
158 struct mds_rec_create *rec;
160 rec = lustre_msg_buf(req->rq_reqmsg, offset);
162 /* XXX do something about time, uid, gid */
163 rec->cr_opcode = HTON__u32(REINT_CREATE);
164 rec->cr_fsuid = HTON__u32(current->fsuid);
165 rec->cr_fsgid = HTON__u32(current->fsgid);
166 rec->cr_cap = HTON__u32(current->cap_effective);
167 ll_inode2fid(&rec->cr_fid, dir);
168 memset(&rec->cr_replayfid, 0, sizeof(rec->cr_replayfid));
169 rec->cr_mode = HTON__u32(mode);
170 rec->cr_rdev = HTON__u64(rdev);
171 rec->cr_uid = HTON__u32(uid);
172 rec->cr_gid = HTON__u32(gid);
173 rec->cr_time = HTON__u64(time);
175 tmp = lustre_msg_buf(req->rq_reqmsg, offset + 1);
176 LOGL0(name, namelen, tmp);
179 tmp = lustre_msg_buf(req->rq_reqmsg, offset + 2);
180 LOGL0(data, datalen, tmp);
184 void mds_setattr_pack(struct ptlrpc_request *req, int offset,
185 struct inode *inode, struct iattr *iattr,
186 const char *name, int namelen)
188 struct mds_rec_setattr *rec;
189 rec = lustre_msg_buf(req->rq_reqmsg, offset);
191 rec->sa_opcode = HTON__u32(REINT_SETATTR);
192 rec->sa_fsuid = HTON__u32(current->fsuid);
193 rec->sa_fsgid = HTON__u32(current->fsgid);
194 rec->sa_cap = HTON__u32(current->cap_effective);
195 ll_inode2fid(&rec->sa_fid, inode);
196 rec->sa_valid = HTON__u32(iattr->ia_valid);
197 rec->sa_mode = HTON__u32(iattr->ia_mode);
198 rec->sa_uid = HTON__u32(iattr->ia_uid);
199 rec->sa_gid = HTON__u32(iattr->ia_gid);
200 rec->sa_size = HTON__u64(iattr->ia_size);
201 rec->sa_atime = HTON__u64(iattr->ia_atime);
202 rec->sa_mtime = HTON__u64(iattr->ia_mtime);
203 rec->sa_ctime = HTON__u64(iattr->ia_ctime);
204 rec->sa_attr_flags = HTON__u32(iattr->ia_attr_flags);
208 tmp = lustre_msg_buf(req->rq_reqmsg, offset + 1);
209 LOGL0(name, namelen, tmp);
213 void mds_unlink_pack(struct ptlrpc_request *req, int offset,
214 struct inode *inode, struct inode *child, __u32 mode,
215 const char *name, int namelen)
217 struct mds_rec_unlink *rec;
220 rec = lustre_msg_buf(req->rq_reqmsg, offset);
222 rec->ul_opcode = HTON__u32(REINT_UNLINK);
223 rec->ul_fsuid = HTON__u32(current->fsuid);
224 rec->ul_fsgid = HTON__u32(current->fsgid);
225 rec->ul_cap = HTON__u32(current->cap_effective);
226 rec->ul_mode = HTON__u32(mode);
227 ll_inode2fid(&rec->ul_fid1, inode);
229 ll_inode2fid(&rec->ul_fid2, child);
231 tmp = lustre_msg_buf(req->rq_reqmsg, offset + 1);
232 LOGL0(name, namelen, tmp);
235 void mds_link_pack(struct ptlrpc_request *req, int offset,
236 struct inode *inode, struct inode *dir,
237 const char *name, int namelen)
239 struct mds_rec_link *rec;
242 rec = lustre_msg_buf(req->rq_reqmsg, offset);
244 rec->lk_opcode = HTON__u32(REINT_LINK);
245 rec->lk_fsuid = HTON__u32(current->fsuid);
246 rec->lk_fsgid = HTON__u32(current->fsgid);
247 rec->lk_cap = HTON__u32(current->cap_effective);
248 ll_inode2fid(&rec->lk_fid1, inode);
249 ll_inode2fid(&rec->lk_fid2, dir);
251 tmp = lustre_msg_buf(req->rq_reqmsg, offset + 1);
252 LOGL0(name, namelen, tmp);
255 void mds_rename_pack(struct ptlrpc_request *req, int offset,
256 struct inode *srcdir, struct inode *tgtdir,
257 const char *old, int oldlen, const char *new, int newlen)
259 struct mds_rec_rename *rec;
262 rec = lustre_msg_buf(req->rq_reqmsg, offset);
264 /* XXX do something about time, uid, gid */
265 rec->rn_opcode = HTON__u32(REINT_RENAME);
266 rec->rn_fsuid = HTON__u32(current->fsuid);
267 rec->rn_fsgid = HTON__u32(current->fsgid);
268 rec->rn_cap = HTON__u32(current->cap_effective);
269 ll_inode2fid(&rec->rn_fid1, srcdir);
270 ll_inode2fid(&rec->rn_fid2, tgtdir);
272 tmp = lustre_msg_buf(req->rq_reqmsg, offset + 1);
273 LOGL0(old, oldlen, tmp);
276 tmp = lustre_msg_buf(req->rq_reqmsg, offset + 2);
277 LOGL0(new, newlen, tmp);
282 void mds_unpack_fid(struct ll_fid *fid)
284 fid->id = NTOH__u64(fid->id);
285 fid->generation = NTOH__u32(fid->generation);
286 fid->f_type = NTOH__u32(fid->f_type);
289 void mds_unpack_body(struct mds_body *b)
294 mds_unpack_fid(&b->fid1);
295 mds_unpack_fid(&b->fid2);
296 b->size = NTOH__u64(b->size);
297 b->valid = NTOH__u32(b->valid);
298 b->fsuid = NTOH__u32(b->fsuid);
299 b->fsgid = NTOH__u32(b->fsgid);
300 b->capability = NTOH__u32(b->capability);
301 b->ino = NTOH__u32(b->ino);
302 b->mode = NTOH__u32(b->mode);
303 b->uid = NTOH__u32(b->uid);
304 b->gid = NTOH__u32(b->gid);
305 b->mtime = NTOH__u32(b->mtime);
306 b->ctime = NTOH__u32(b->ctime);
307 b->atime = NTOH__u32(b->atime);
308 b->flags = NTOH__u32(b->flags);
309 b->rdev = NTOH__u32(b->rdev);
310 b->nlink = NTOH__u32(b->nlink);
311 b->generation = NTOH__u32(b->generation);
314 static int mds_setattr_unpack(struct ptlrpc_request *req, int offset,
315 struct mds_update_record *r)
317 struct iattr *attr = &r->ur_iattr;
318 struct mds_rec_setattr *rec = lustre_msg_buf(req->rq_reqmsg, offset);
321 if (req->rq_reqmsg->bufcount < offset + 1 ||
322 req->rq_reqmsg->buflens[offset] != sizeof(*rec))
325 r->ur_fsuid = NTOH__u32(rec->sa_fsuid);
326 r->ur_fsgid = NTOH__u32(rec->sa_fsgid);
327 r->ur_cap = NTOH__u32(rec->sa_cap);
328 r->ur_fid1 = &rec->sa_fid;
329 attr->ia_valid = NTOH__u32(rec->sa_valid);
330 attr->ia_mode = NTOH__u32(rec->sa_mode);
331 attr->ia_uid = NTOH__u32(rec->sa_uid);
332 attr->ia_gid = NTOH__u32(rec->sa_gid);
333 attr->ia_size = NTOH__u64(rec->sa_size);
334 attr->ia_atime = NTOH__u64(rec->sa_atime);
335 attr->ia_mtime = NTOH__u64(rec->sa_mtime);
336 attr->ia_ctime = NTOH__u64(rec->sa_ctime);
337 attr->ia_attr_flags = NTOH__u32(rec->sa_attr_flags);
339 if (req->rq_reqmsg->bufcount == offset + 2) {
340 r->ur_namelen = req->rq_reqmsg->buflens[offset + 1];
341 r->ur_name = lustre_msg_buf(req->rq_reqmsg, offset + 1);
348 static int mds_create_unpack(struct ptlrpc_request *req, int offset,
349 struct mds_update_record *r)
351 struct mds_rec_create *rec = lustre_msg_buf(req->rq_reqmsg, offset);
354 if (req->rq_reqmsg->bufcount < offset + 2 ||
355 req->rq_reqmsg->buflens[offset] != sizeof(*rec))
358 r->ur_fsuid = NTOH__u32(rec->cr_fsuid);
359 r->ur_fsgid = NTOH__u32(rec->cr_fsgid);
360 r->ur_cap = NTOH__u32(rec->cr_cap);
361 r->ur_fid1 = &rec->cr_fid;
362 r->ur_fid2 = &rec->cr_replayfid;
363 r->ur_mode = NTOH__u32(rec->cr_mode);
364 r->ur_rdev = NTOH__u64(rec->cr_rdev);
365 r->ur_uid = NTOH__u32(rec->cr_uid);
366 r->ur_gid = NTOH__u32(rec->cr_gid);
367 r->ur_time = NTOH__u64(rec->cr_time);
369 r->ur_name = lustre_msg_buf(req->rq_reqmsg, offset + 1);
370 r->ur_namelen = req->rq_reqmsg->buflens[offset + 1];
372 if (req->rq_reqmsg->bufcount == offset + 3) {
373 r->ur_tgt = lustre_msg_buf(req->rq_reqmsg, offset + 2);
374 r->ur_tgtlen = req->rq_reqmsg->buflens[offset + 2];
382 static int mds_link_unpack(struct ptlrpc_request *req, int offset,
383 struct mds_update_record *r)
385 struct mds_rec_link *rec = lustre_msg_buf(req->rq_reqmsg, offset);
388 if (req->rq_reqmsg->bufcount != offset + 2 ||
389 req->rq_reqmsg->buflens[offset] != sizeof(*rec))
392 r->ur_fsuid = NTOH__u32(rec->lk_fsuid);
393 r->ur_fsgid = NTOH__u32(rec->lk_fsgid);
394 r->ur_cap = NTOH__u32(rec->lk_cap);
395 r->ur_fid1 = &rec->lk_fid1;
396 r->ur_fid2 = &rec->lk_fid2;
398 r->ur_name = lustre_msg_buf(req->rq_reqmsg, offset + 1);
399 r->ur_namelen = req->rq_reqmsg->buflens[offset + 1];
403 static int mds_unlink_unpack(struct ptlrpc_request *req, int offset,
404 struct mds_update_record *r)
406 struct mds_rec_unlink *rec = lustre_msg_buf(req->rq_reqmsg, offset);
409 if (req->rq_reqmsg->bufcount != offset + 2 ||
410 req->rq_reqmsg->buflens[offset] != sizeof(*rec))
413 r->ur_fsuid = NTOH__u32(rec->ul_fsuid);
414 r->ur_fsgid = NTOH__u32(rec->ul_fsgid);
415 r->ur_cap = NTOH__u32(rec->ul_cap);
416 r->ur_mode = NTOH__u32(rec->ul_mode);
417 r->ur_fid1 = &rec->ul_fid1;
418 r->ur_fid2 = &rec->ul_fid2;
420 r->ur_name = lustre_msg_buf(req->rq_reqmsg, offset + 1);
421 r->ur_namelen = req->rq_reqmsg->buflens[offset + 1];
425 static int mds_rename_unpack(struct ptlrpc_request *req, int offset,
426 struct mds_update_record *r)
428 struct mds_rec_rename *rec = lustre_msg_buf(req->rq_reqmsg, offset);
431 if (req->rq_reqmsg->bufcount != offset + 3 ||
432 req->rq_reqmsg->buflens[offset] != sizeof(*rec))
435 r->ur_fsuid = NTOH__u32(rec->rn_fsuid);
436 r->ur_fsgid = NTOH__u32(rec->rn_fsgid);
437 r->ur_cap = NTOH__u32(rec->rn_cap);
438 r->ur_fid1 = &rec->rn_fid1;
439 r->ur_fid2 = &rec->rn_fid2;
441 r->ur_name = lustre_msg_buf(req->rq_reqmsg, offset + 1);
442 r->ur_namelen = req->rq_reqmsg->buflens[offset + 1];
444 r->ur_tgt = lustre_msg_buf(req->rq_reqmsg, offset + 2);
445 r->ur_tgtlen = req->rq_reqmsg->buflens[offset + 2];
449 typedef int (*update_unpacker)(struct ptlrpc_request *req, int offset,
450 struct mds_update_record *r);
452 static update_unpacker mds_unpackers[REINT_MAX + 1] = {
453 [REINT_SETATTR] mds_setattr_unpack,
454 [REINT_CREATE] mds_create_unpack,
455 [REINT_LINK] mds_link_unpack,
456 [REINT_UNLINK] mds_unlink_unpack,
457 [REINT_RENAME] mds_rename_unpack,
460 int mds_update_unpack(struct ptlrpc_request *req, int offset,
461 struct mds_update_record *rec)
463 __u32 *opcode = lustre_msg_buf(req->rq_reqmsg, offset);
467 if (!opcode || req->rq_reqmsg->buflens[offset] < sizeof(*opcode))
470 realop = rec->ur_opcode = NTOH__u32(*opcode);
471 realop &= REINT_OPCODE_MASK;
473 if (realop < 0 || realop > REINT_MAX)
476 rc = mds_unpackers[realop](req, offset, rec);