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 #include <linux/version.h>
  32 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
  33 #include <linux/locks.h>   // for wait_on_buffer
  34 #else
  35 #include <linux/buffer_head.h>   // for wait_on_buffer
  36 #endif
  37 #include <linux/unistd.h>
  38
  39 #include <asm/system.h>
  40 #include <asm/uaccess.h>
  41
  42 #include <linux/fs.h>
  43 #include <linux/stat.h>
  44 #include <asm/uaccess.h>
  45 #include <linux/slab.h>
  46 #include <asm/segment.h>
  47
  48 #define DEBUG_SUBSYSTEM S_MDS
  49
  50 #include <linux/obd_support.h>
  51 #include <linux/lustre_lib.h>
  52 #include <linux/lustre_mds.h>
  53 #include <linux/lustre_lite.h>
  54
  55 void mds_pack_inode2fid(struct ll_fid *fid, struct inode *inode)
  56 {
  57         fid->id = HTON__u64(inode->i_ino);
  58         fid->generation = HTON__u32(inode->i_generation);
  59         fid->f_type = HTON__u32(S_IFMT & inode->i_mode);
  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
  69         /* The MDS file size isn't authoritative for regular files, so don't
  70          * even pretend. */
  71         if (S_ISREG(inode->i_mode))
  72                 b->valid &= ~(OBD_MD_FLSIZE | OBD_MD_FLBLOCKS);
  73
  74         b->ino = HTON__u32(inode->i_ino);
  75 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
  76         b->atime = HTON__u32(inode->i_atime);
  77         b->mtime = HTON__u32(inode->i_mtime);
  78         b->ctime = HTON__u32(inode->i_ctime);
  79 #else
  80         b->atime = HTON__u32(inode->i_atime.tv_sec);
  81         b->mtime = HTON__u32(inode->i_mtime.tv_sec);
  82         b->ctime = HTON__u32(inode->i_ctime.tv_sec);
  83 #endif
  84         b->mode = HTON__u32(inode->i_mode);
  85         b->size = HTON__u64(inode->i_size);
  86         b->blocks = HTON__u64(inode->i_blocks);
  87         b->uid = HTON__u32(inode->i_uid);
  88         b->gid = HTON__u32(inode->i_gid);
  89         b->flags = HTON__u32(inode->i_flags);
  90         b->rdev = HTON__u32(b->rdev);
  91         b->nlink = HTON__u32(inode->i_nlink);
  92         b->generation = HTON__u32(inode->i_generation);
  93         b->suppgid = HTON__u32(-1);
  94 }
  95
  96
  97 void mds_pack_fid(struct ll_fid *fid)
  98 {
  99         fid->id = HTON__u64(fid->id);
 100         fid->generation = HTON__u32(fid->generation);
 101         fid->f_type = HTON__u32(fid->f_type);
 102 }
 103
 104 static void mds_pack_body(struct mds_body *b)
 105 {
 106         if (b == NULL)
 107                 LBUG();
 108
 109         b->fsuid = HTON__u32(current->fsuid);
 110         b->fsgid = HTON__u32(current->fsgid);
 111         b->capability = HTON__u32(current->cap_effective);
 112
 113         mds_pack_fid(&b->fid1);
 114         mds_pack_fid(&b->fid2);
 115         b->size = HTON__u64(b->size);
 116         b->ino = HTON__u32(b->ino);
 117         b->valid = HTON__u32(b->valid);
 118         b->mode = HTON__u32(b->mode);
 119         b->uid = HTON__u32(b->uid);
 120         b->gid = HTON__u32(b->gid);
 121         b->mtime = HTON__u32(b->mtime);
 122         b->ctime = HTON__u32(b->ctime);
 123         b->atime = HTON__u32(b->atime);
 124         b->flags = HTON__u32(b->flags);
 125         b->rdev = HTON__u32(b->rdev);
 126         b->nlink = HTON__u32(b->nlink);
 127         b->generation = HTON__u32(b->generation);
 128         b->suppgid = HTON__u32(b->suppgid);
 129 }
 130
 131 void mds_getattr_pack(struct ptlrpc_request *req, int valid, int offset,
 132                       int flags,
 133                       struct inode *inode, const char *name, int namelen)
 134 {
 135         struct mds_body *b;
 136         b = lustre_msg_buf(req->rq_reqmsg, offset);
 137
 138         b->fsuid = HTON__u32(current->fsuid);
 139         b->fsgid = HTON__u32(current->fsgid);
 140         b->capability = HTON__u32(current->cap_effective);
 141         b->valid = HTON__u32(valid);
 142         b->flags = HTON__u32(flags);
 143         if (in_group_p(inode->i_gid))
 144                 b->suppgid = HTON__u32(inode->i_gid);
 145         else
 146                 b->suppgid = HTON__u32(-1);
 147
 148         ll_inode2fid(&b->fid1, inode);
 149         if (name) {
 150                 char *tmp;
 151                 tmp = lustre_msg_buf(req->rq_reqmsg, offset + 1);
 152                 LOGL0(name, namelen, tmp);
 153         }
 154 }
 155
 156 void mds_readdir_pack(struct ptlrpc_request *req, __u64 offset,
 157                       obd_id ino, int type, __u64 xid)
 158 {
 159         struct mds_body *b;
 160
 161         b = lustre_msg_buf(req->rq_reqmsg, 0);
 162         b->fsuid = HTON__u32(current->fsuid);
 163         b->fsgid = HTON__u32(current->fsgid);
 164         b->capability = HTON__u32(current->cap_effective);
 165         b->fid1.id = HTON__u64(ino);
 166         b->fid1.f_type = HTON__u32(type);
 167         b->size = HTON__u64(offset);
 168         b->suppgid = HTON__u32(-1);
 169         b->blocks = HTON__u64(xid);
 170 }
 171
 172
 173 void mds_pack_req_body(struct ptlrpc_request *req)
 174 {
 175         struct mds_body *b = lustre_msg_buf(req->rq_reqmsg, 0);
 176         mds_pack_body(b);
 177 }
 178
 179 void mds_pack_rep_body(struct ptlrpc_request *req)
 180 {
 181         struct mds_body *b = lustre_msg_buf(req->rq_repmsg, 0);
 182         mds_pack_body(b);
 183 }
 184
 185
 186 /* packing of MDS records */
 187 void mds_create_pack(struct ptlrpc_request *req, int offset, struct inode *dir,
 188                      __u32 mode, __u64 rdev, __u32 uid, __u32 gid, __u64 time,
 189                      const char *name, int namelen,
 190                      const void *data, int datalen)
 191 {
 192         struct mds_rec_create *rec;
 193         char *tmp;
 194         rec = lustre_msg_buf(req->rq_reqmsg, offset);
 195
 196         rec->cr_opcode = HTON__u32(REINT_CREATE);
 197         rec->cr_fsuid = HTON__u32(current->fsuid);
 198         rec->cr_fsgid = HTON__u32(current->fsgid);
 199         rec->cr_cap = HTON__u32(current->cap_effective);
 200         ll_inode2fid(&rec->cr_fid, dir);
 201         memset(&rec->cr_replayfid, 0, sizeof(rec->cr_replayfid));
 202         rec->cr_mode = HTON__u32(mode);
 203         rec->cr_rdev = HTON__u64(rdev);
 204         rec->cr_uid = HTON__u32(uid);
 205         rec->cr_gid = HTON__u32(gid);
 206         rec->cr_time = HTON__u64(time);
 207         if (in_group_p(dir->i_gid))
 208                 rec->cr_suppgid = HTON__u32(dir->i_gid);
 209         else
 210                 rec->cr_suppgid = HTON__u32(-1);
 211
 212         tmp = lustre_msg_buf(req->rq_reqmsg, offset + 1);
 213         LOGL0(name, namelen, tmp);
 214
 215         if (data) {
 216                 tmp = lustre_msg_buf(req->rq_reqmsg, offset + 2);
 217                 LOGL0(data, datalen, tmp);
 218         }
 219 }
 220 /* packing of MDS records */
 221 void mds_open_pack(struct ptlrpc_request *req, int offset, struct inode *dir,
 222                      __u32 mode, __u64 rdev, __u32 uid, __u32 gid, __u64 time,
 223                      __u32 flags,
 224                      const char *name, int namelen,
 225                      const void *data, int datalen)
 226 {
 227         struct mds_rec_create *rec;
 228         char *tmp;
 229         rec = lustre_msg_buf(req->rq_reqmsg, offset);
 230
 231         /* XXX do something about time, uid, gid */
 232         rec->cr_opcode = HTON__u32(REINT_OPEN);
 233         rec->cr_fsuid = HTON__u32(current->fsuid);
 234         rec->cr_fsgid = HTON__u32(current->fsgid);
 235         rec->cr_cap = HTON__u32(current->cap_effective);
 236         ll_inode2fid(&rec->cr_fid, dir);
 237         memset(&rec->cr_replayfid, 0, sizeof(rec->cr_replayfid));
 238         rec->cr_mode = HTON__u32(mode);
 239         rec->cr_flags = HTON__u32(flags);
 240         rec->cr_rdev = HTON__u64(rdev);
 241         rec->cr_uid = HTON__u32(uid);
 242         rec->cr_gid = HTON__u32(gid);
 243         rec->cr_time = HTON__u64(time);
 244         if (in_group_p(dir->i_gid))
 245                 rec->cr_suppgid = HTON__u32(dir->i_gid);
 246         else
 247                 rec->cr_suppgid = HTON__u32(-1);
 248
 249         tmp = lustre_msg_buf(req->rq_reqmsg, offset + 1);
 250         LOGL0(name, namelen, tmp);
 251
 252         if (data) {
 253                 tmp = lustre_msg_buf(req->rq_reqmsg, offset + 2);
 254                 LOGL0(data, datalen, tmp);
 255         }
 256 }
 257
 258 void mds_setattr_pack(struct ptlrpc_request *req,
 259                       struct inode *inode, struct iattr *iattr,
 260                       void *ea, int ealen)
 261 {
 262         struct mds_rec_setattr *rec = lustre_msg_buf(req->rq_reqmsg, 0);
 263
 264         rec->sa_opcode = HTON__u32(REINT_SETATTR);
 265         rec->sa_fsuid = HTON__u32(current->fsuid);
 266         rec->sa_fsgid = HTON__u32(current->fsgid);
 267         rec->sa_cap = HTON__u32(current->cap_effective);
 268         ll_inode2fid(&rec->sa_fid, inode);
 269
 270         if (iattr) {
 271                 rec->sa_valid = HTON__u32(iattr->ia_valid);
 272                 rec->sa_mode = HTON__u32(iattr->ia_mode);
 273                 rec->sa_uid = HTON__u32(iattr->ia_uid);
 274                 rec->sa_gid = HTON__u32(iattr->ia_gid);
 275                 rec->sa_size = HTON__u64(iattr->ia_size);
 276 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
 277                 rec->sa_atime = HTON__u64(iattr->ia_atime);
 278                 rec->sa_mtime = HTON__u64(iattr->ia_mtime);
 279                 rec->sa_ctime = HTON__u64(iattr->ia_ctime);
 280 #else
 281                 rec->sa_atime = HTON__u64(iattr->ia_atime.tv_sec);
 282                 rec->sa_mtime = HTON__u64(iattr->ia_mtime.tv_sec);
 283                 rec->sa_ctime = HTON__u64(iattr->ia_ctime.tv_sec);
 284 #endif
 285                 rec->sa_attr_flags = HTON__u32(iattr->ia_attr_flags);
 286
 287                 if ((iattr->ia_valid & ATTR_GID) && in_group_p(iattr->ia_gid))
 288                         rec->sa_suppgid = HTON__u32(iattr->ia_gid);
 289                 else if ((iattr->ia_valid & ATTR_MODE) &&
 290                          in_group_p(inode->i_gid))
 291                         rec->sa_suppgid = HTON__u32(inode->i_gid);
 292                 else
 293                         rec->sa_suppgid = HTON__u32(-1);
 294         }
 295
 296         if (ealen)
 297                 memcpy(lustre_msg_buf(req->rq_reqmsg, 1), ea, ealen);
 298 }
 299
 300 void mds_unlink_pack(struct ptlrpc_request *req, int offset,
 301                      struct inode *inode, struct inode *child, __u32 mode,
 302                      const char *name, int namelen)
 303 {
 304         struct mds_rec_unlink *rec;
 305         char *tmp;
 306
 307         rec = lustre_msg_buf(req->rq_reqmsg, offset);
 308
 309         rec->ul_opcode = HTON__u32(REINT_UNLINK);
 310         rec->ul_fsuid = HTON__u32(current->fsuid);
 311         rec->ul_fsgid = HTON__u32(current->fsgid);
 312         rec->ul_cap = HTON__u32(current->cap_effective);
 313         rec->ul_mode = HTON__u32(mode);
 314         if (in_group_p(inode->i_gid))
 315                 rec->ul_suppgid = HTON__u32(inode->i_gid);
 316         else
 317                 rec->ul_suppgid = HTON__u32(-1);
 318         ll_inode2fid(&rec->ul_fid1, inode);
 319         if (child)
 320                 ll_inode2fid(&rec->ul_fid2, child);
 321
 322         tmp = lustre_msg_buf(req->rq_reqmsg, offset + 1);
 323         LOGL0(name, namelen, tmp);
 324 }
 325
 326 void mds_link_pack(struct ptlrpc_request *req, int offset,
 327                    struct inode *inode, struct inode *dir,
 328                    const char *name, int namelen)
 329 {
 330         struct mds_rec_link *rec;
 331         char *tmp;
 332
 333         rec = lustre_msg_buf(req->rq_reqmsg, offset);
 334
 335         rec->lk_opcode = HTON__u32(REINT_LINK);
 336         rec->lk_fsuid = HTON__u32(current->fsuid);
 337         rec->lk_fsgid = HTON__u32(current->fsgid);
 338         rec->lk_cap = HTON__u32(current->cap_effective);
 339         if (in_group_p(dir->i_gid))
 340                 rec->lk_suppgid = HTON__u32(dir->i_gid);
 341         else
 342                 rec->lk_suppgid = HTON__u32(-1);
 343         ll_inode2fid(&rec->lk_fid1, inode);
 344         ll_inode2fid(&rec->lk_fid2, dir);
 345
 346         tmp = lustre_msg_buf(req->rq_reqmsg, offset + 1);
 347         LOGL0(name, namelen, tmp);
 348 }
 349
 350 void mds_rename_pack(struct ptlrpc_request *req, int offset,
 351                      struct inode *srcdir, struct inode *tgtdir,
 352                      const char *old, int oldlen, const char *new, int newlen)
 353 {
 354         struct mds_rec_rename *rec;
 355         char *tmp;
 356
 357         rec = lustre_msg_buf(req->rq_reqmsg, offset);
 358
 359         /* XXX do something about time, uid, gid */
 360         rec->rn_opcode = HTON__u32(REINT_RENAME);
 361         rec->rn_fsuid = HTON__u32(current->fsuid);
 362         rec->rn_fsgid = HTON__u32(current->fsgid);
 363         rec->rn_cap = HTON__u32(current->cap_effective);
 364         if (in_group_p(srcdir->i_gid))
 365                 rec->rn_suppgid1 = HTON__u32(srcdir->i_gid);
 366         else
 367                 rec->rn_suppgid1 = HTON__u32(-1);
 368         if (in_group_p(tgtdir->i_gid))
 369                 rec->rn_suppgid2 = HTON__u32(tgtdir->i_gid);
 370         else
 371                 rec->rn_suppgid2 = HTON__u32(-1);
 372         ll_inode2fid(&rec->rn_fid1, srcdir);
 373         ll_inode2fid(&rec->rn_fid2, tgtdir);
 374
 375         tmp = lustre_msg_buf(req->rq_reqmsg, offset + 1);
 376         LOGL0(old, oldlen, tmp);
 377
 378         if (new) {
 379                 tmp = lustre_msg_buf(req->rq_reqmsg, offset + 2);
 380                 LOGL0(new, newlen, tmp);
 381         }
 382 }
 383
 384 /* unpacking */
 385 void mds_unpack_fid(struct ll_fid *fid)
 386 {
 387         fid->id = NTOH__u64(fid->id);
 388         fid->generation = NTOH__u32(fid->generation);
 389         fid->f_type = NTOH__u32(fid->f_type);
 390 }
 391
 392 void mds_unpack_body(struct mds_body *b)
 393 {
 394         if (b == NULL)
 395                 LBUG();
 396
 397         mds_unpack_fid(&b->fid1);
 398         mds_unpack_fid(&b->fid2);
 399         b->size = NTOH__u64(b->size);
 400         b->blocks = NTOH__u64(b->blocks);
 401         b->valid = NTOH__u32(b->valid);
 402         b->fsuid = NTOH__u32(b->fsuid);
 403         b->fsgid = NTOH__u32(b->fsgid);
 404         b->capability = NTOH__u32(b->capability);
 405         b->ino = NTOH__u32(b->ino);
 406         b->mode = NTOH__u32(b->mode);
 407         b->uid = NTOH__u32(b->uid);
 408         b->gid = NTOH__u32(b->gid);
 409         b->mtime = NTOH__u32(b->mtime);
 410         b->ctime = NTOH__u32(b->ctime);
 411         b->atime = NTOH__u32(b->atime);
 412         b->flags = NTOH__u32(b->flags);
 413         b->rdev = NTOH__u32(b->rdev);
 414         b->nlink = NTOH__u32(b->nlink);
 415         b->generation = NTOH__u32(b->generation);
 416         b->suppgid = NTOH__u32(b->suppgid);
 417 }
 418
 419 static int mds_setattr_unpack(struct ptlrpc_request *req, int offset,
 420                               struct mds_update_record *r)
 421 {
 422         struct iattr *attr = &r->ur_iattr;
 423         struct mds_rec_setattr *rec = lustre_msg_buf(req->rq_reqmsg, offset);
 424         ENTRY;
 425
 426         if (req->rq_reqmsg->bufcount < offset + 1 ||
 427             req->rq_reqmsg->buflens[offset] != sizeof(*rec))
 428                 RETURN(-EFAULT);
 429
 430         r->ur_fsuid = NTOH__u32(rec->sa_fsuid);
 431         r->ur_fsgid = NTOH__u32(rec->sa_fsgid);
 432         r->ur_cap = NTOH__u32(rec->sa_cap);
 433         r->ur_suppgid1 = NTOH__u32(rec->sa_suppgid);
 434         r->ur_suppgid2 = NTOH__u32(-1);
 435         r->ur_fid1 = &rec->sa_fid;
 436         attr->ia_valid = NTOH__u32(rec->sa_valid);
 437         attr->ia_mode = NTOH__u32(rec->sa_mode);
 438         attr->ia_uid = NTOH__u32(rec->sa_uid);
 439         attr->ia_gid = NTOH__u32(rec->sa_gid);
 440         attr->ia_size = NTOH__u64(rec->sa_size);
 441 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
 442         attr->ia_atime = NTOH__u64(rec->sa_atime);
 443         attr->ia_mtime = NTOH__u64(rec->sa_mtime);
 444         attr->ia_ctime = NTOH__u64(rec->sa_ctime);
 445 #else
 446         attr->ia_atime.tv_sec = NTOH__u64(rec->sa_atime);
 447         attr->ia_mtime.tv_sec = NTOH__u64(rec->sa_mtime);
 448         attr->ia_ctime.tv_sec = NTOH__u64(rec->sa_ctime);
 449 #endif
 450         attr->ia_attr_flags = NTOH__u32(rec->sa_attr_flags);
 451
 452         if (req->rq_reqmsg->bufcount == offset + 2) {
 453                 r->ur_namelen = req->rq_reqmsg->buflens[offset + 1];
 454                 r->ur_name = lustre_msg_buf(req->rq_reqmsg, offset + 1);
 455         } else {
 456                 r->ur_namelen = 0;
 457         }
 458
 459         RETURN(0);
 460 }
 461
 462 static int mds_create_unpack(struct ptlrpc_request *req, int offset,
 463                              struct mds_update_record *r)
 464 {
 465         struct mds_rec_create *rec = lustre_msg_buf(req->rq_reqmsg, offset);
 466         ENTRY;
 467
 468         if (req->rq_reqmsg->bufcount < offset + 2 ||
 469             req->rq_reqmsg->buflens[offset] != sizeof(*rec))
 470                 RETURN(-EFAULT);
 471
 472         r->ur_fsuid = NTOH__u32(rec->cr_fsuid);
 473         r->ur_fsgid = NTOH__u32(rec->cr_fsgid);
 474         r->ur_cap = NTOH__u32(rec->cr_cap);
 475         r->ur_fid1 = &rec->cr_fid;
 476         r->ur_fid2 = &rec->cr_replayfid;
 477         r->ur_mode = NTOH__u32(rec->cr_mode);
 478         r->ur_rdev = NTOH__u64(rec->cr_rdev);
 479         r->ur_uid = NTOH__u32(rec->cr_uid);
 480         r->ur_gid = NTOH__u32(rec->cr_gid);
 481         r->ur_time = NTOH__u64(rec->cr_time);
 482         r->ur_flags = NTOH__u32(rec->cr_flags);
 483         r->ur_suppgid1 = NTOH__u32(rec->cr_suppgid);
 484         r->ur_suppgid2 = NTOH__u32(-1);
 485
 486         r->ur_name = lustre_msg_buf(req->rq_reqmsg, offset + 1);
 487         r->ur_namelen = req->rq_reqmsg->buflens[offset + 1];
 488
 489         if (req->rq_reqmsg->bufcount == offset + 3) {
 490                 r->ur_tgt = lustre_msg_buf(req->rq_reqmsg, offset + 2);
 491                 r->ur_tgtlen = req->rq_reqmsg->buflens[offset + 2];
 492         } else {
 493                 r->ur_tgt = NULL;
 494                 r->ur_tgtlen = 0;
 495         }
 496         RETURN(0);
 497 }
 498
 499 static int mds_link_unpack(struct ptlrpc_request *req, int offset,
 500                            struct mds_update_record *r)
 501 {
 502         struct mds_rec_link *rec = lustre_msg_buf(req->rq_reqmsg, offset);
 503         ENTRY;
 504
 505         if (req->rq_reqmsg->bufcount != offset + 2 ||
 506             req->rq_reqmsg->buflens[offset] != sizeof(*rec))
 507                 RETURN(-EFAULT);
 508
 509         r->ur_fsuid = NTOH__u32(rec->lk_fsuid);
 510         r->ur_fsgid = NTOH__u32(rec->lk_fsgid);
 511         r->ur_cap = NTOH__u32(rec->lk_cap);
 512         r->ur_suppgid1 = NTOH__u32(rec->lk_suppgid);
 513         r->ur_suppgid2 = NTOH__u32(-1);
 514         r->ur_fid1 = &rec->lk_fid1;
 515         r->ur_fid2 = &rec->lk_fid2;
 516
 517         r->ur_name = lustre_msg_buf(req->rq_reqmsg, offset + 1);
 518         r->ur_namelen = req->rq_reqmsg->buflens[offset + 1];
 519         RETURN(0);
 520 }
 521
 522 static int mds_unlink_unpack(struct ptlrpc_request *req, int offset,
 523                              struct mds_update_record *r)
 524 {
 525         struct mds_rec_unlink *rec = lustre_msg_buf(req->rq_reqmsg, offset);
 526         ENTRY;
 527
 528         if (req->rq_reqmsg->bufcount != offset + 2 ||
 529             req->rq_reqmsg->buflens[offset] != sizeof(*rec))
 530                 RETURN(-EFAULT);
 531
 532         r->ur_fsuid = NTOH__u32(rec->ul_fsuid);
 533         r->ur_fsgid = NTOH__u32(rec->ul_fsgid);
 534         r->ur_cap = NTOH__u32(rec->ul_cap);
 535         r->ur_mode = NTOH__u32(rec->ul_mode);
 536         r->ur_suppgid1 = NTOH__u32(rec->ul_suppgid);
 537         r->ur_suppgid2 = NTOH__u32(-1);
 538         r->ur_fid1 = &rec->ul_fid1;
 539         r->ur_fid2 = &rec->ul_fid2;
 540
 541         r->ur_name = lustre_msg_buf(req->rq_reqmsg, offset + 1);
 542         r->ur_namelen = req->rq_reqmsg->buflens[offset + 1];
 543         RETURN(0);
 544 }
 545
 546 static int mds_rename_unpack(struct ptlrpc_request *req, int offset,
 547                              struct mds_update_record *r)
 548 {
 549         struct mds_rec_rename *rec = lustre_msg_buf(req->rq_reqmsg, offset);
 550         ENTRY;
 551
 552         if (req->rq_reqmsg->bufcount != offset + 3 ||
 553             req->rq_reqmsg->buflens[offset] != sizeof(*rec))
 554                 RETURN(-EFAULT);
 555
 556         r->ur_fsuid = NTOH__u32(rec->rn_fsuid);
 557         r->ur_fsgid = NTOH__u32(rec->rn_fsgid);
 558         r->ur_cap = NTOH__u32(rec->rn_cap);
 559         r->ur_suppgid1 = NTOH__u32(rec->rn_suppgid1);
 560         r->ur_suppgid2 = NTOH__u32(rec->rn_suppgid2);
 561         r->ur_fid1 = &rec->rn_fid1;
 562         r->ur_fid2 = &rec->rn_fid2;
 563
 564         r->ur_name = lustre_msg_buf(req->rq_reqmsg, offset + 1);
 565         r->ur_namelen = req->rq_reqmsg->buflens[offset + 1];
 566
 567         r->ur_tgt = lustre_msg_buf(req->rq_reqmsg, offset + 2);
 568         r->ur_tgtlen = req->rq_reqmsg->buflens[offset + 2];
 569         RETURN(0);
 570 }
 571
 572 typedef int (*update_unpacker)(struct ptlrpc_request *req, int offset,
 573                                struct mds_update_record *r);
 574
 575 static update_unpacker mds_unpackers[REINT_MAX + 1] = {
 576         [REINT_SETATTR] mds_setattr_unpack,
 577         [REINT_CREATE] mds_create_unpack,
 578         [REINT_LINK] mds_link_unpack,
 579         [REINT_UNLINK] mds_unlink_unpack,
 580         [REINT_RENAME] mds_rename_unpack,
 581         [REINT_OPEN] mds_create_unpack,
 582 };
 583
 584 int mds_update_unpack(struct ptlrpc_request *req, int offset,
 585                       struct mds_update_record *rec)
 586 {
 587         __u32 *opcode = lustre_msg_buf(req->rq_reqmsg, offset);
 588         int rc, realop;
 589         ENTRY;
 590
 591         if (!opcode || req->rq_reqmsg->buflens[offset] < sizeof(*opcode))
 592                 RETURN(-EFAULT);
 593
 594         realop = rec->ur_opcode = NTOH__u32(*opcode);
 595         realop &= REINT_OPCODE_MASK;
 596
 597         if (realop < 0 || realop > REINT_MAX) {
 598                 LBUG();
 599                 RETURN(-EFAULT);
 600         }
 601
 602         rc = mds_unpackers[realop](req, offset, rec);
 603         RETURN(rc);
 604 }