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  * Copryright (C) 2002 Cluster File Systems, Inc.
   5  *
   6  *   This file is part of Lustre, http://www.sf.net/projects/lustre/
   7  *
   8  *   This code is issued under the GNU General Public License.
   9  *   See the file COPYING in this distribution
  10  *
  11  * Lustre Lite Update Records
  12  */
  13
  14 #include <linux/config.h>
  15 #include <linux/module.h>
  16 #include <linux/kernel.h>
  17 #include <linux/mm.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
  23 #else
  24 #include <linux/buffer_head.h>   // for wait_on_buffer
  25 #endif
  26 #include <linux/unistd.h>
  27
  28 #include <asm/system.h>
  29 #include <asm/uaccess.h>
  30
  31 #include <linux/fs.h>
  32 #include <linux/stat.h>
  33 #include <asm/uaccess.h>
  34 #include <linux/slab.h>
  35 #include <asm/segment.h>
  36
  37 #define DEBUG_SUBSYSTEM S_MDS
  38
  39 #include <linux/obd_support.h>
  40 #include <linux/lustre_lib.h>
  41 #include <linux/lustre_mds.h>
  42 #include <linux/lustre_lite.h>
  43
  44 void mds_pack_inode2fid(struct ll_fid *fid, struct inode *inode)
  45 {
  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);
  49 }
  50
  51
  52 void mds_pack_inode2body(struct mds_body *b, struct inode *inode)
  53 {
  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);
  69 }
  70
  71
  72 void mds_pack_fid(struct ll_fid *fid)
  73 {
  74         fid->id = HTON__u64(fid->id);
  75         fid->generation = HTON__u32(fid->generation);
  76         fid->f_type = HTON__u32(fid->f_type);
  77 }
  78
  79 static void mds_pack_body(struct mds_body *b)
  80 {
  81         if (b == NULL)
  82                 LBUG();
  83
  84         b->fsuid = HTON__u32(current->fsuid);
  85         b->fsgid = HTON__u32(current->fsgid);
  86         b->capability = HTON__u32(current->cap_effective);
  87
  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);
 103 }
 104
 105 void mds_getattr_pack(struct ptlrpc_request *req, int offset,
 106                       struct inode *inode,
 107                       const char *name, int namelen)
 108 {
 109         struct mds_body *b;
 110         b = lustre_msg_buf(req->rq_reqmsg, offset);
 111
 112         b->fsuid = HTON__u32(current->fsuid);
 113         b->fsgid = HTON__u32(current->fsgid);
 114         b->capability = HTON__u32(current->cap_effective);
 115
 116         ll_inode2fid(&b->fid1, inode);
 117         if (name) {
 118                 char *tmp;
 119                 tmp = lustre_msg_buf(req->rq_reqmsg, offset + 1);
 120                 LOGL0(name, namelen, tmp);
 121         }
 122 }
 123
 124 void mds_readdir_pack(struct ptlrpc_request *req, int offset,
 125                       obd_id ino, int type)
 126 {
 127         struct mds_body *b;
 128
 129         b = lustre_msg_buf(req->rq_reqmsg, offset);
 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);
 136 }
 137
 138
 139 void mds_pack_req_body(struct ptlrpc_request *req)
 140 {
 141         struct mds_body *b = lustre_msg_buf(req->rq_reqmsg, 0);
 142         mds_pack_body(b);
 143 }
 144
 145 void mds_pack_rep_body(struct ptlrpc_request *req)
 146 {
 147         struct mds_body *b = lustre_msg_buf(req->rq_repmsg, 0);
 148         mds_pack_body(b);
 149 }
 150
 151
 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)
 157 {
 158         struct mds_rec_create *rec;
 159         char *tmp;
 160         rec = lustre_msg_buf(req->rq_reqmsg, offset);
 161
 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);
 174
 175         tmp = lustre_msg_buf(req->rq_reqmsg, offset + 1);
 176         LOGL0(name, namelen, tmp);
 177
 178         if (data) {
 179                 tmp = lustre_msg_buf(req->rq_reqmsg, offset + 2);
 180                 LOGL0(data, datalen, tmp);
 181         }
 182 }
 183
 184 void mds_setattr_pack(struct ptlrpc_request *req, int offset,
 185                       struct inode *inode, struct iattr *iattr,
 186                       const char *name, int namelen)
 187 {
 188         struct mds_rec_setattr *rec;
 189         rec = lustre_msg_buf(req->rq_reqmsg, offset);
 190
 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);
 205
 206         if (namelen) {
 207                 char *tmp;
 208                 tmp = lustre_msg_buf(req->rq_reqmsg, offset + 1);
 209                 LOGL0(name, namelen, tmp);
 210         }
 211 }
 212
 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)
 216 {
 217         struct mds_rec_unlink *rec;
 218         char *tmp;
 219
 220         rec = lustre_msg_buf(req->rq_reqmsg, offset);
 221
 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);
 228         if (child)
 229                 ll_inode2fid(&rec->ul_fid2, child);
 230
 231         tmp = lustre_msg_buf(req->rq_reqmsg, offset + 1);
 232         LOGL0(name, namelen, tmp);
 233 }
 234
 235 void mds_link_pack(struct ptlrpc_request *req, int offset,
 236                    struct inode *inode, struct inode *dir,
 237                    const char *name, int namelen)
 238 {
 239         struct mds_rec_link *rec;
 240         char *tmp;
 241
 242         rec = lustre_msg_buf(req->rq_reqmsg, offset);
 243
 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);
 250
 251         tmp = lustre_msg_buf(req->rq_reqmsg, offset + 1);
 252         LOGL0(name, namelen, tmp);
 253 }
 254
 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)
 258 {
 259         struct mds_rec_rename *rec;
 260         char *tmp;
 261
 262         rec = lustre_msg_buf(req->rq_reqmsg, offset);
 263
 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);
 271
 272         tmp = lustre_msg_buf(req->rq_reqmsg, offset + 1);
 273         LOGL0(old, oldlen, tmp);
 274
 275         if (new) {
 276                 tmp = lustre_msg_buf(req->rq_reqmsg, offset + 2);
 277                 LOGL0(new, newlen, tmp);
 278         }
 279 }
 280
 281 /* unpacking */
 282 void mds_unpack_fid(struct ll_fid *fid)
 283 {
 284         fid->id = NTOH__u64(fid->id);
 285         fid->generation = NTOH__u32(fid->generation);
 286         fid->f_type = NTOH__u32(fid->f_type);
 287 }
 288
 289 void mds_unpack_body(struct mds_body *b)
 290 {
 291         if (b == NULL)
 292                 LBUG();
 293
 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);
 312 }
 313
 314 static int mds_setattr_unpack(struct ptlrpc_request *req, int offset,
 315                               struct mds_update_record *r)
 316 {
 317         struct iattr *attr = &r->ur_iattr;
 318         struct mds_rec_setattr *rec = lustre_msg_buf(req->rq_reqmsg, offset);
 319         ENTRY;
 320
 321         if (req->rq_reqmsg->bufcount < offset + 1 ||
 322             req->rq_reqmsg->buflens[offset] != sizeof(*rec))
 323                 RETURN(-EFAULT);
 324
 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);
 338
 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);
 342         } else
 343                 r->ur_namelen = 0;
 344
 345         RETURN(0);
 346 }
 347
 348 static int mds_create_unpack(struct ptlrpc_request *req, int offset,
 349                              struct mds_update_record *r)
 350 {
 351         struct mds_rec_create *rec = lustre_msg_buf(req->rq_reqmsg, offset);
 352         ENTRY;
 353
 354         if (req->rq_reqmsg->bufcount < offset + 2 ||
 355             req->rq_reqmsg->buflens[offset] != sizeof(*rec))
 356                 RETURN(-EFAULT);
 357
 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);
 368
 369         r->ur_name = lustre_msg_buf(req->rq_reqmsg, offset + 1);
 370         r->ur_namelen = req->rq_reqmsg->buflens[offset + 1];
 371
 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];
 375         } else {
 376                 r->ur_tgt = NULL;
 377                 r->ur_tgtlen = 0;
 378         }
 379         RETURN(0);
 380 }
 381
 382 static int mds_link_unpack(struct ptlrpc_request *req, int offset,
 383                            struct mds_update_record *r)
 384 {
 385         struct mds_rec_link *rec = lustre_msg_buf(req->rq_reqmsg, offset);
 386         ENTRY;
 387
 388         if (req->rq_reqmsg->bufcount != offset + 2 ||
 389             req->rq_reqmsg->buflens[offset] != sizeof(*rec))
 390                 RETURN(-EFAULT);
 391
 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;
 397
 398         r->ur_name = lustre_msg_buf(req->rq_reqmsg, offset + 1);
 399         r->ur_namelen = req->rq_reqmsg->buflens[offset + 1];
 400         RETURN(0);
 401 }
 402
 403 static int mds_unlink_unpack(struct ptlrpc_request *req, int offset,
 404                              struct mds_update_record *r)
 405 {
 406         struct mds_rec_unlink *rec = lustre_msg_buf(req->rq_reqmsg, offset);
 407         ENTRY;
 408
 409         if (req->rq_reqmsg->bufcount != offset + 2 ||
 410             req->rq_reqmsg->buflens[offset] != sizeof(*rec))
 411                 RETURN(-EFAULT);
 412
 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;
 419
 420         r->ur_name = lustre_msg_buf(req->rq_reqmsg, offset + 1);
 421         r->ur_namelen = req->rq_reqmsg->buflens[offset + 1];
 422         RETURN(0);
 423 }
 424
 425 static int mds_rename_unpack(struct ptlrpc_request *req, int offset,
 426                              struct mds_update_record *r)
 427 {
 428         struct mds_rec_rename *rec = lustre_msg_buf(req->rq_reqmsg, offset);
 429         ENTRY;
 430
 431         if (req->rq_reqmsg->bufcount != offset + 3 ||
 432             req->rq_reqmsg->buflens[offset] != sizeof(*rec))
 433                 RETURN(-EFAULT);
 434
 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;
 440
 441         r->ur_name = lustre_msg_buf(req->rq_reqmsg, offset + 1);
 442         r->ur_namelen = req->rq_reqmsg->buflens[offset + 1];
 443
 444         r->ur_tgt = lustre_msg_buf(req->rq_reqmsg, offset + 2);
 445         r->ur_tgtlen = req->rq_reqmsg->buflens[offset + 2];
 446         RETURN(0);
 447 }
 448
 449 typedef int (*update_unpacker)(struct ptlrpc_request *req, int offset,
 450                                struct mds_update_record *r);
 451
 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,
 458 };
 459
 460 int mds_update_unpack(struct ptlrpc_request *req, int offset,
 461                       struct mds_update_record *rec)
 462 {
 463         __u32 *opcode = lustre_msg_buf(req->rq_reqmsg, offset);
 464         int rc, realop;
 465         ENTRY;
 466
 467         if (!opcode || req->rq_reqmsg->buflens[offset] < sizeof(*opcode))
 468                 RETURN(-EFAULT);
 469
 470         realop = rec->ur_opcode = NTOH__u32(*opcode);
 471         realop &= REINT_OPCODE_MASK;
 472
 473         if (realop < 0 || realop > REINT_MAX)
 474                 RETURN(-EFAULT);
 475
 476         rc = mds_unpackers[realop](req, offset, rec);
 477         RETURN(rc);
 478 }