lustre/lib/mds_updates.c

   1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
   2  * vim:expandtab:shiftwidth=8:tabstop=8:
   3  *
   4  * Lustre Lite Update Records
   5  *
   6  *  Copyright (c) 2002, 2003 Cluster File Systems, Inc.
   7  *
   8  *   This file is part of Lustre, http://www.lustre.org.
   9  *
  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.
  13  *
  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.
  18  *
  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.
  22  */
  23
  24 #include <linux/config.h>
  25 #include <linux/module.h>
  26 #include <linux/kernel.h>
  27 #include <linux/mm.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
  33 #else
  34 #include <linux/buffer_head.h>   // for wait_on_buffer
  35 #endif
  36 #include <linux/unistd.h>
  37
  38 #include <asm/system.h>
  39 #include <asm/uaccess.h>
  40
  41 #include <linux/fs.h>
  42 #include <linux/stat.h>
  43 #include <asm/uaccess.h>
  44 #include <linux/slab.h>
  45 #include <asm/segment.h>
  46
  47 #define DEBUG_SUBSYSTEM S_MDS
  48
  49 #include <linux/obd_support.h>
  50 #include <linux/lustre_lib.h>
  51 #include <linux/lustre_mds.h>
  52 #include <linux/lustre_lite.h>
  53
  54 void mds_pack_inode2fid(struct ll_fid *fid, struct inode *inode)
  55 {
  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);
  59 }
  60
  61
  62 void mds_pack_inode2body(struct mds_body *b, struct inode *inode)
  63 {
  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);
  82 }
  83
  84
  85 void mds_pack_fid(struct ll_fid *fid)
  86 {
  87         fid->id = HTON__u64(fid->id);
  88         fid->generation = HTON__u32(fid->generation);
  89         fid->f_type = HTON__u32(fid->f_type);
  90 }
  91
  92 static void mds_pack_body(struct mds_body *b)
  93 {
  94         if (b == NULL)
  95                 LBUG();
  96
  97         b->fsuid = HTON__u32(current->fsuid);
  98         b->fsgid = HTON__u32(current->fsgid);
  99         b->capability = HTON__u32(current->cap_effective);
 100
 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);
 117 }
 118
 119 void mds_getattr_pack(struct ptlrpc_request *req, int valid, int offset,
 120                       int flags,
 121                       struct inode *inode, const char *name, int namelen)
 122 {
 123         struct mds_body *b;
 124         b = lustre_msg_buf(req->rq_reqmsg, offset);
 125
 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);
 133         else
 134                 b->suppgid = HTON__u32(-1);
 135
 136         ll_inode2fid(&b->fid1, inode);
 137         if (name) {
 138                 char *tmp;
 139                 tmp = lustre_msg_buf(req->rq_reqmsg, offset + 1);
 140                 LOGL0(name, namelen, tmp);
 141         }
 142 }
 143
 144 void mds_readdir_pack(struct ptlrpc_request *req, __u64 offset,
 145                       obd_id ino, int type, __u64 xid)
 146 {
 147         struct mds_body *b;
 148
 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);
 158 }
 159
 160
 161 void mds_pack_req_body(struct ptlrpc_request *req)
 162 {
 163         struct mds_body *b = lustre_msg_buf(req->rq_reqmsg, 0);
 164         mds_pack_body(b);
 165 }
 166
 167 void mds_pack_rep_body(struct ptlrpc_request *req)
 168 {
 169         struct mds_body *b = lustre_msg_buf(req->rq_repmsg, 0);
 170         mds_pack_body(b);
 171 }
 172
 173
 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)
 179 {
 180         struct mds_rec_create *rec;
 181         char *tmp;
 182         rec = lustre_msg_buf(req->rq_reqmsg, offset);
 183
 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);
 195
 196         tmp = lustre_msg_buf(req->rq_reqmsg, offset + 1);
 197         LOGL0(name, namelen, tmp);
 198
 199         if (data) {
 200                 tmp = lustre_msg_buf(req->rq_reqmsg, offset + 2);
 201                 LOGL0(data, datalen, tmp);
 202         }
 203 }
 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,
 207                      __u32 flags,
 208                      const char *name, int namelen,
 209                      const void *data, int datalen)
 210 {
 211         struct mds_rec_create *rec;
 212         char *tmp;
 213         rec = lustre_msg_buf(req->rq_reqmsg, offset);
 214
 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);
 230         else
 231                 rec->cr_suppgid = HTON__u32(-1);
 232
 233         tmp = lustre_msg_buf(req->rq_reqmsg, offset + 1);
 234         LOGL0(name, namelen, tmp);
 235
 236         if (data) {
 237                 tmp = lustre_msg_buf(req->rq_reqmsg, offset + 2);
 238                 LOGL0(data, datalen, tmp);
 239         }
 240 }
 241
 242 void mds_setattr_pack(struct ptlrpc_request *req,
 243                       struct inode *inode, struct iattr *iattr,
 244                       void *ea, int ealen)
 245 {
 246         struct mds_rec_setattr *rec = lustre_msg_buf(req->rq_reqmsg, 0);
 247
 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);
 253
 254         if (iattr) {
 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);
 264
 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);
 270                 else
 271                         rec->sa_suppgid = HTON__u32(-1);
 272         }
 273
 274         if (ealen)
 275                 memcpy(lustre_msg_buf(req->rq_reqmsg, 1), ea, ealen);
 276 }
 277
 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)
 281 {
 282         struct mds_rec_unlink *rec;
 283         char *tmp;
 284
 285         rec = lustre_msg_buf(req->rq_reqmsg, offset);
 286
 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);
 294         else
 295                 rec->ul_suppgid = HTON__u32(-1);
 296         ll_inode2fid(&rec->ul_fid1, inode);
 297         if (child)
 298                 ll_inode2fid(&rec->ul_fid2, child);
 299
 300         tmp = lustre_msg_buf(req->rq_reqmsg, offset + 1);
 301         LOGL0(name, namelen, tmp);
 302 }
 303
 304 void mds_link_pack(struct ptlrpc_request *req, int offset,
 305                    struct inode *inode, struct inode *dir,
 306                    const char *name, int namelen)
 307 {
 308         struct mds_rec_link *rec;
 309         char *tmp;
 310
 311         rec = lustre_msg_buf(req->rq_reqmsg, offset);
 312
 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);
 319         else
 320                 rec->lk_suppgid = HTON__u32(-1);
 321         ll_inode2fid(&rec->lk_fid1, inode);
 322         ll_inode2fid(&rec->lk_fid2, dir);
 323
 324         tmp = lustre_msg_buf(req->rq_reqmsg, offset + 1);
 325         LOGL0(name, namelen, tmp);
 326 }
 327
 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)
 331 {
 332         struct mds_rec_rename *rec;
 333         char *tmp;
 334
 335         rec = lustre_msg_buf(req->rq_reqmsg, offset);
 336
 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);
 344
 345         tmp = lustre_msg_buf(req->rq_reqmsg, offset + 1);
 346         LOGL0(old, oldlen, tmp);
 347
 348         if (new) {
 349                 tmp = lustre_msg_buf(req->rq_reqmsg, offset + 2);
 350                 LOGL0(new, newlen, tmp);
 351         }
 352 }
 353
 354 /* unpacking */
 355 void mds_unpack_fid(struct ll_fid *fid)
 356 {
 357         fid->id = NTOH__u64(fid->id);
 358         fid->generation = NTOH__u32(fid->generation);
 359         fid->f_type = NTOH__u32(fid->f_type);
 360 }
 361
 362 void mds_unpack_body(struct mds_body *b)
 363 {
 364         if (b == NULL)
 365                 LBUG();
 366
 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);
 387 }
 388
 389 static int mds_setattr_unpack(struct ptlrpc_request *req, int offset,
 390                               struct mds_update_record *r)
 391 {
 392         struct iattr *attr = &r->ur_iattr;
 393         struct mds_rec_setattr *rec = lustre_msg_buf(req->rq_reqmsg, offset);
 394         ENTRY;
 395
 396         if (req->rq_reqmsg->bufcount < offset + 1 ||
 397             req->rq_reqmsg->buflens[offset] != sizeof(*rec))
 398                 RETURN(-EFAULT);
 399
 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);
 414
 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);
 418         } else {
 419                 r->ur_namelen = 0;
 420         }
 421
 422         RETURN(0);
 423 }
 424
 425 static int mds_create_unpack(struct ptlrpc_request *req, int offset,
 426                              struct mds_update_record *r)
 427 {
 428         struct mds_rec_create *rec = lustre_msg_buf(req->rq_reqmsg, offset);
 429         ENTRY;
 430
 431         if (req->rq_reqmsg->bufcount < offset + 2 ||
 432             req->rq_reqmsg->buflens[offset] != sizeof(*rec))
 433                 RETURN(-EFAULT);
 434
 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);
 447
 448         r->ur_name = lustre_msg_buf(req->rq_reqmsg, offset + 1);
 449         r->ur_namelen = req->rq_reqmsg->buflens[offset + 1];
 450
 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];
 454         } else {
 455                 r->ur_tgt = NULL;
 456                 r->ur_tgtlen = 0;
 457         }
 458         RETURN(0);
 459 }
 460
 461 static int mds_link_unpack(struct ptlrpc_request *req, int offset,
 462                            struct mds_update_record *r)
 463 {
 464         struct mds_rec_link *rec = lustre_msg_buf(req->rq_reqmsg, offset);
 465         ENTRY;
 466
 467         if (req->rq_reqmsg->bufcount != offset + 2 ||
 468             req->rq_reqmsg->buflens[offset] != sizeof(*rec))
 469                 RETURN(-EFAULT);
 470
 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;
 477
 478         r->ur_name = lustre_msg_buf(req->rq_reqmsg, offset + 1);
 479         r->ur_namelen = req->rq_reqmsg->buflens[offset + 1];
 480         RETURN(0);
 481 }
 482
 483 static int mds_unlink_unpack(struct ptlrpc_request *req, int offset,
 484                              struct mds_update_record *r)
 485 {
 486         struct mds_rec_unlink *rec = lustre_msg_buf(req->rq_reqmsg, offset);
 487         ENTRY;
 488
 489         if (req->rq_reqmsg->bufcount != offset + 2 ||
 490             req->rq_reqmsg->buflens[offset] != sizeof(*rec))
 491                 RETURN(-EFAULT);
 492
 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;
 500
 501         r->ur_name = lustre_msg_buf(req->rq_reqmsg, offset + 1);
 502         r->ur_namelen = req->rq_reqmsg->buflens[offset + 1];
 503         RETURN(0);
 504 }
 505
 506 static int mds_rename_unpack(struct ptlrpc_request *req, int offset,
 507                              struct mds_update_record *r)
 508 {
 509         struct mds_rec_rename *rec = lustre_msg_buf(req->rq_reqmsg, offset);
 510         ENTRY;
 511
 512         if (req->rq_reqmsg->bufcount != offset + 3 ||
 513             req->rq_reqmsg->buflens[offset] != sizeof(*rec))
 514                 RETURN(-EFAULT);
 515
 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;
 521
 522         r->ur_name = lustre_msg_buf(req->rq_reqmsg, offset + 1);
 523         r->ur_namelen = req->rq_reqmsg->buflens[offset + 1];
 524
 525         r->ur_tgt = lustre_msg_buf(req->rq_reqmsg, offset + 2);
 526         r->ur_tgtlen = req->rq_reqmsg->buflens[offset + 2];
 527         RETURN(0);
 528 }
 529
 530 typedef int (*update_unpacker)(struct ptlrpc_request *req, int offset,
 531                                struct mds_update_record *r);
 532
 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,
 540 };
 541
 542 int mds_update_unpack(struct ptlrpc_request *req, int offset,
 543                       struct mds_update_record *rec)
 544 {
 545         __u32 *opcode = lustre_msg_buf(req->rq_reqmsg, offset);
 546         int rc, realop;
 547         ENTRY;
 548
 549         if (!opcode || req->rq_reqmsg->buflens[offset] < sizeof(*opcode))
 550                 RETURN(-EFAULT);
 551
 552         realop = rec->ur_opcode = NTOH__u32(*opcode);
 553         realop &= REINT_OPCODE_MASK;
 554
 555         if (realop < 0 || realop > REINT_MAX) {
 556                 LBUG();
 557                 RETURN(-EFAULT);
 558         }
 559
 560         rc = mds_unpackers[realop](req, offset, rec);
 561         RETURN(rc);
 562 }