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 Light Update Records
   5  *
   6  * This code is issued under the GNU General Public License.
   7  * See the file COPYING in this distribution
   8  *
   9  * Copryright (C) 2002 Cluster File Systems, Inc.
  10  *
  11  */
  12
  13 #include <linux/config.h>
  14 #include <linux/module.h>
  15 #include <linux/kernel.h>
  16 #include <linux/mm.h>
  17 #include <linux/string.h>
  18 #include <linux/stat.h>
  19 #include <linux/errno.h>
  20 #include <linux/locks.h>
  21 #include <linux/unistd.h>
  22
  23 #include <asm/system.h>
  24 #include <asm/uaccess.h>
  25
  26 #include <linux/fs.h>
  27 #include <linux/stat.h>
  28 #include <asm/uaccess.h>
  29 #include <linux/slab.h>
  30 #include <asm/segment.h>
  31
  32 #define DEBUG_SUBSYSTEM S_MDS
  33
  34 #include <linux/obd_support.h>
  35 #include <linux/lustre_lib.h>
  36 #include <linux/lustre_mds.h>
  37 #include <linux/lustre_lite.h>
  38
  39 void mds_pack_inode2fid(struct ll_fid *fid, struct inode *inode)
  40 {
  41         fid->id = HTON__u64(inode->i_ino);
  42         fid->generation = HTON__u32(inode->i_generation);
  43         fid->f_type = HTON__u32(S_IFMT & inode->i_mode);
  44 }
  45
  46
  47 void mds_pack_inode2body(struct mds_body *b, struct inode *inode)
  48 {
  49         b->valid = OBD_MD_FLID | OBD_MD_FLATIME | OBD_MD_FLMTIME | OBD_MD_FLCTIME | OBD_MD_FLMODE | OBD_MD_FLUID | OBD_MD_FLGID | OBD_MD_FLNLINK | OBD_MD_FLGENER | OBD_MD_FLSIZE | OBD_MD_FLOBJID;
  50         b->size = HTON__u64(inode->i_size);
  51         b->mode = HTON__u32(inode->i_mode);
  52         b->uid = HTON__u32(inode->i_uid);
  53         b->gid = HTON__u32(inode->i_gid);
  54         b->mtime = HTON__u32(inode->i_mtime);
  55         b->ctime = HTON__u32(inode->i_ctime);
  56         b->atime = HTON__u32(inode->i_atime);
  57         b->flags = HTON__u32(inode->i_flags);
  58         //b->major = HTON__u32(inode->i_major);
  59         //b->minor = HTON__u32(inode->i_minor);
  60         b->ino = HTON__u32(inode->i_ino);
  61         b->nlink = HTON__u32(inode->i_nlink);
  62         b->generation = HTON__u32(inode->i_generation);
  63 }
  64
  65
  66 void mds_pack_fid(struct ll_fid *fid)
  67 {
  68         fid->id = HTON__u64(fid->id);
  69         fid->generation = HTON__u32(fid->generation);
  70         fid->f_type = HTON__u32(fid->f_type);
  71 }
  72
  73 static void mds_pack_body(struct mds_body *b)
  74 {
  75         if (b == NULL)
  76                 LBUG();
  77
  78         mds_pack_fid(&b->fid1);
  79         mds_pack_fid(&b->fid2);
  80         b->extra = HTON__u64(b->extra);
  81         b->size = HTON__u64(b->size);
  82         b->valid = HTON__u32(b->valid);
  83         b->mode = HTON__u32(b->mode);
  84         b->uid = HTON__u32(b->uid);
  85         b->gid = HTON__u32(b->gid);
  86         b->mtime = HTON__u32(b->mtime);
  87         b->ctime = HTON__u32(b->ctime);
  88         b->atime = HTON__u32(b->atime);
  89         b->flags = HTON__u32(b->flags);
  90         b->major = HTON__u32(b->major);
  91         b->minor = HTON__u32(b->minor);
  92         b->ino = HTON__u32(b->ino);
  93         b->nlink = HTON__u32(b->nlink);
  94         b->generation = HTON__u32(b->generation);
  95         b->last_xid = HTON__u32(b->last_xid);
  96 }
  97
  98 void mds_getattr_pack(struct ptlrpc_request *req, int offset,
  99                       struct inode *inode,
 100                       const char *name, int namelen)
 101 {
 102         struct mds_body *rec;
 103         rec = lustre_msg_buf(req->rq_reqmsg, offset);
 104
 105         ll_inode2fid(&rec->fid1, inode);
 106         if (name) {
 107                 char *tmp;
 108                 tmp = lustre_msg_buf(req->rq_reqmsg, offset + 1);
 109                 LOGL0(name, namelen, tmp);
 110         }
 111 }
 112
 113
 114 void mds_pack_req_body(struct ptlrpc_request *req)
 115 {
 116         struct mds_body *b = lustre_msg_buf(req->rq_reqmsg, 0);
 117         mds_pack_body(b);
 118 }
 119
 120 void mds_pack_rep_body(struct ptlrpc_request *req)
 121 {
 122         struct mds_body *b = lustre_msg_buf(req->rq_repmsg, 0);
 123         mds_pack_body(b);
 124 }
 125
 126
 127 /* packing of MDS records */
 128 void mds_create_pack(struct ptlrpc_request *req, int offset,
 129                      struct inode *inode, __u32 mode, __u64 rdev, __u32 uid,
 130                      __u32 gid, __u64 time, const char *name, int namelen,
 131                      const char *tgt, int tgtlen)
 132 {
 133         struct mds_rec_create *rec;
 134         char *tmp;
 135         rec = lustre_msg_buf(req->rq_reqmsg, offset);
 136
 137         /* XXX do something about time, uid, gid */
 138         rec->cr_opcode = HTON__u32(REINT_CREATE);
 139         ll_inode2fid(&rec->cr_fid, inode);
 140         rec->cr_mode = HTON__u32(mode);
 141         rec->cr_rdev = HTON__u64(rdev);
 142         rec->cr_uid = HTON__u32(uid);
 143         rec->cr_gid = HTON__u32(gid);
 144         rec->cr_time = HTON__u64(time);
 145
 146         tmp = lustre_msg_buf(req->rq_reqmsg, offset + 1);
 147         LOGL0(name, namelen, tmp);
 148
 149         if (tgt) {
 150                 tmp = lustre_msg_buf(req->rq_reqmsg, offset + 2);
 151                 LOGL0(tgt, tgtlen, tmp);
 152         }
 153 }
 154
 155 void mds_setattr_pack(struct ptlrpc_request *req, int offset,
 156                       struct inode *inode, struct iattr *iattr,
 157                       const char *name, int namelen)
 158 {
 159         struct mds_rec_setattr *rec;
 160         rec = lustre_msg_buf(req->rq_reqmsg, offset);
 161
 162         rec->sa_opcode = HTON__u32(REINT_SETATTR);
 163         ll_inode2fid(&rec->sa_fid, inode);
 164         rec->sa_valid = HTON__u32(iattr->ia_valid);
 165         rec->sa_mode = HTON__u32(iattr->ia_mode);
 166         rec->sa_uid = HTON__u32(iattr->ia_uid);
 167         rec->sa_gid = HTON__u32(iattr->ia_gid);
 168         rec->sa_size = HTON__u64(iattr->ia_size);
 169         rec->sa_atime = HTON__u64(iattr->ia_atime);
 170         rec->sa_mtime = HTON__u64(iattr->ia_mtime);
 171         rec->sa_ctime = HTON__u64(iattr->ia_ctime);
 172         rec->sa_attr_flags = HTON__u32(iattr->ia_attr_flags);
 173
 174         if (namelen) {
 175                 char *tmp;
 176                 tmp = lustre_msg_buf(req->rq_reqmsg, offset + 1);
 177                 LOGL0(name, namelen, tmp);
 178         }
 179 }
 180
 181 void mds_unlink_pack(struct ptlrpc_request *req, int offset,
 182                      struct inode *inode, struct inode *child,
 183                      const char *name, int namelen)
 184 {
 185         struct mds_rec_unlink *rec;
 186         char *tmp;
 187
 188         rec = lustre_msg_buf(req->rq_reqmsg, offset);
 189
 190         rec->ul_opcode = HTON__u32(REINT_UNLINK);
 191         ll_inode2fid(&rec->ul_fid1, inode);
 192         if (child)
 193                 ll_inode2fid(&rec->ul_fid2, child);
 194
 195         tmp = lustre_msg_buf(req->rq_reqmsg, offset + 1);
 196         LOGL0(name, namelen, tmp);
 197 }
 198
 199 void mds_link_pack(struct ptlrpc_request *req, int offset,
 200                    struct inode *inode, struct inode *dir,
 201                    const char *name, int namelen)
 202 {
 203         struct mds_rec_link *rec;
 204         char *tmp;
 205
 206         rec = lustre_msg_buf(req->rq_reqmsg, offset);
 207
 208         rec->lk_opcode = HTON__u32(REINT_LINK);
 209         ll_inode2fid(&rec->lk_fid1, inode);
 210         ll_inode2fid(&rec->lk_fid2, dir);
 211
 212         tmp = lustre_msg_buf(req->rq_reqmsg, offset + 1);
 213         LOGL0(name, namelen, tmp);
 214 }
 215
 216 void mds_rename_pack(struct ptlrpc_request *req, int offset,
 217                      struct inode *srcdir, struct inode *tgtdir,
 218                      const char *old, int oldlen, const char *new, int newlen)
 219 {
 220         struct mds_rec_rename *rec;
 221         char *tmp;
 222
 223         rec = lustre_msg_buf(req->rq_reqmsg, offset);
 224
 225         /* XXX do something about time, uid, gid */
 226         rec->rn_opcode = HTON__u32(REINT_RENAME);
 227         ll_inode2fid(&rec->rn_fid1, srcdir);
 228         ll_inode2fid(&rec->rn_fid2, tgtdir);
 229
 230         tmp = lustre_msg_buf(req->rq_reqmsg, offset + 1);
 231         LOGL0(old, oldlen, tmp);
 232
 233         if (new) {
 234                 tmp = lustre_msg_buf(req->rq_reqmsg, offset + 2);
 235                 LOGL0(new, newlen, tmp);
 236         }
 237 }
 238
 239 /* unpacking */
 240 void mds_unpack_fid(struct ll_fid *fid)
 241 {
 242         fid->id = NTOH__u64(fid->id);
 243         fid->generation = NTOH__u32(fid->generation);
 244         fid->f_type = NTOH__u32(fid->f_type);
 245 }
 246
 247 void mds_unpack_body(struct mds_body *b)
 248 {
 249         if (b == NULL)
 250                 LBUG();
 251
 252         mds_unpack_fid(&b->fid1);
 253         mds_unpack_fid(&b->fid2);
 254         b->extra = NTOH__u64(b->extra);
 255         b->size = NTOH__u64(b->size);
 256         b->valid = NTOH__u32(b->valid);
 257         b->mode = NTOH__u32(b->mode);
 258         b->uid = NTOH__u32(b->uid);
 259         b->gid = NTOH__u32(b->gid);
 260         b->mtime = NTOH__u32(b->mtime);
 261         b->ctime = NTOH__u32(b->ctime);
 262         b->atime = NTOH__u32(b->atime);
 263         b->flags = NTOH__u32(b->flags);
 264         b->major = NTOH__u32(b->major);
 265         b->minor = NTOH__u32(b->minor);
 266         b->ino = NTOH__u32(b->ino);
 267         b->nlink = NTOH__u32(b->nlink);
 268         b->generation = NTOH__u32(b->generation);
 269         b->last_xid = NTOH__u32(b->last_xid);
 270 }
 271
 272 static int mds_setattr_unpack(struct ptlrpc_request *req, int offset,
 273                               struct mds_update_record *r)
 274 {
 275         struct iattr *attr = &r->ur_iattr;
 276         struct mds_rec_setattr *rec = lustre_msg_buf(req->rq_reqmsg, offset);
 277         ENTRY;
 278
 279         if (req->rq_reqmsg->bufcount < offset + 1 ||
 280             req->rq_reqmsg->buflens[offset] != sizeof(*rec))
 281                 RETURN(-EFAULT);
 282
 283         r->ur_fid1 = &rec->sa_fid;
 284         attr->ia_valid = NTOH__u32(rec->sa_valid);
 285         attr->ia_mode = NTOH__u32(rec->sa_mode);
 286         attr->ia_uid = NTOH__u32(rec->sa_uid);
 287         attr->ia_gid = NTOH__u32(rec->sa_gid);
 288         attr->ia_size = NTOH__u64(rec->sa_size);
 289         attr->ia_atime = NTOH__u64(rec->sa_atime);
 290         attr->ia_mtime = NTOH__u64(rec->sa_mtime);
 291         attr->ia_ctime = NTOH__u64(rec->sa_ctime);
 292         attr->ia_attr_flags = NTOH__u32(rec->sa_attr_flags);
 293
 294         if (req->rq_reqmsg->bufcount == offset + 2) {
 295                 r->ur_namelen = req->rq_reqmsg->buflens[offset + 1];
 296                 r->ur_name = lustre_msg_buf(req->rq_reqmsg, offset + 1);
 297         } else
 298                 r->ur_namelen = 0;
 299
 300         RETURN(0);
 301 }
 302
 303 static int mds_create_unpack(struct ptlrpc_request *req, int offset,
 304                              struct mds_update_record *r)
 305 {
 306         struct mds_rec_create *rec = lustre_msg_buf(req->rq_reqmsg, offset);
 307         ENTRY;
 308
 309         if (req->rq_reqmsg->bufcount != offset + 3 ||
 310             req->rq_reqmsg->buflens[offset] != sizeof(*rec))
 311                 RETURN(-EFAULT);
 312
 313         r->ur_fid1 = &rec->cr_fid;
 314         r->ur_mode = NTOH__u32(rec->cr_mode);
 315         r->ur_rdev = NTOH__u64(rec->cr_rdev);
 316         r->ur_uid = NTOH__u32(rec->cr_uid);
 317         r->ur_gid = NTOH__u32(rec->cr_gid);
 318         r->ur_time = NTOH__u64(rec->cr_time);
 319
 320         r->ur_name = lustre_msg_buf(req->rq_reqmsg, offset + 1);
 321         r->ur_namelen = req->rq_reqmsg->buflens[offset + 1];
 322
 323         r->ur_tgt = lustre_msg_buf(req->rq_reqmsg, offset + 2);
 324         r->ur_tgtlen = req->rq_reqmsg->buflens[offset + 2];
 325         RETURN(0);
 326 }
 327
 328 static int mds_link_unpack(struct ptlrpc_request *req, int offset,
 329                            struct mds_update_record *r)
 330 {
 331         struct mds_rec_link *rec = lustre_msg_buf(req->rq_reqmsg, offset);
 332         ENTRY;
 333
 334         if (req->rq_reqmsg->bufcount != offset + 2 ||
 335             req->rq_reqmsg->buflens[offset] != sizeof(*rec))
 336                 RETURN(-EFAULT);
 337
 338         r->ur_fid1 = &rec->lk_fid1;
 339         r->ur_fid2 = &rec->lk_fid2;
 340
 341         r->ur_name = lustre_msg_buf(req->rq_reqmsg, offset + 1);
 342         r->ur_namelen = req->rq_reqmsg->buflens[offset + 1];
 343         RETURN(0);
 344 }
 345
 346 static int mds_unlink_unpack(struct ptlrpc_request *req, int offset,
 347                              struct mds_update_record *r)
 348 {
 349         struct mds_rec_unlink *rec = lustre_msg_buf(req->rq_reqmsg, offset);
 350         ENTRY;
 351
 352         if (req->rq_reqmsg->bufcount != offset + 2 ||
 353             req->rq_reqmsg->buflens[offset] != sizeof(*rec))
 354                 RETURN(-EFAULT);
 355
 356         r->ur_fid1 = &rec->ul_fid1;
 357         r->ur_fid2 = &rec->ul_fid2;
 358
 359         r->ur_name = lustre_msg_buf(req->rq_reqmsg, offset + 1);
 360         r->ur_namelen = req->rq_reqmsg->buflens[offset + 1];
 361         RETURN(0);
 362 }
 363
 364 static int mds_rename_unpack(struct ptlrpc_request *req, int offset,
 365                              struct mds_update_record *r)
 366 {
 367         struct mds_rec_rename *rec = lustre_msg_buf(req->rq_reqmsg, offset);
 368         ENTRY;
 369
 370         if (req->rq_reqmsg->bufcount != offset + 3 ||
 371             req->rq_reqmsg->buflens[offset] != sizeof(*rec))
 372                 RETURN(-EFAULT);
 373
 374         r->ur_fid1 = &rec->rn_fid1;
 375         r->ur_fid2 = &rec->rn_fid2;
 376
 377         r->ur_name = lustre_msg_buf(req->rq_reqmsg, offset + 1);
 378         r->ur_namelen = req->rq_reqmsg->buflens[offset + 1];
 379
 380         r->ur_tgt = lustre_msg_buf(req->rq_reqmsg, offset + 2);
 381         r->ur_tgtlen = req->rq_reqmsg->buflens[offset + 2];
 382         RETURN(0);
 383 }
 384
 385 typedef int (*update_unpacker)(struct ptlrpc_request *req, int offset,
 386                                struct mds_update_record *r);
 387
 388 static update_unpacker mds_unpackers[REINT_MAX + 1] = {
 389         [REINT_SETATTR] mds_setattr_unpack,
 390         [REINT_CREATE] mds_create_unpack,
 391         [REINT_LINK] mds_link_unpack,
 392         [REINT_UNLINK] mds_unlink_unpack,
 393         [REINT_RENAME] mds_rename_unpack,
 394         [REINT_RECREATE] mds_create_unpack,
 395 };
 396
 397 int mds_update_unpack(struct ptlrpc_request *req, int offset,
 398                       struct mds_update_record *rec)
 399 {
 400         struct mds_update_record_hdr *hdr =
 401                 lustre_msg_buf(req->rq_reqmsg, offset);
 402         int rc;
 403         ENTRY;
 404
 405         if (!hdr || req->rq_reqmsg->buflens[offset] < sizeof(*hdr))
 406                 RETURN(-EFAULT);
 407
 408         rec->ur_opcode = NTOH__u32(hdr->ur_opcode);
 409
 410         if (rec->ur_opcode < 0 || rec->ur_opcode > REINT_MAX)
 411                 RETURN(-EFAULT);
 412
 413         rc = mds_unpackers[rec->ur_opcode](req, offset, rec);
 414         RETURN(rc);
 415 }