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_fid(struct ll_fid *fid)
  40 {
  41         fid->id = HTON__u64(fid->id);
  42         fid->generation = HTON__u32(fid->generation);
  43         fid->f_type = HTON__u32(fid->f_type);
  44 }
  45
  46 static void mds_pack_body(struct mds_body *b)
  47 {
  48         if (b == NULL)
  49                 LBUG();
  50
  51         mds_pack_fid(&b->fid1);
  52         mds_pack_fid(&b->fid2);
  53         b->objid = HTON__u64(b->objid);
  54         b->size = HTON__u64(b->size);
  55         b->valid = HTON__u32(b->valid);
  56         b->mode = HTON__u32(b->mode);
  57         b->uid = HTON__u32(b->uid);
  58         b->gid = HTON__u32(b->gid);
  59         b->mtime = HTON__u32(b->mtime);
  60         b->ctime = HTON__u32(b->ctime);
  61         b->atime = HTON__u32(b->atime);
  62         b->flags = HTON__u32(b->flags);
  63         b->major = HTON__u32(b->major);
  64         b->minor = HTON__u32(b->minor);
  65         b->ino = HTON__u32(b->ino);
  66         b->nlink = HTON__u32(b->nlink);
  67         b->generation = HTON__u32(b->generation);
  68         b->last_xid = HTON__u32(b->last_xid);
  69         b->last_committed = HTON__u64(b->last_committed);
  70         b->last_rcvd = HTON__u64(b->last_rcvd);
  71 }
  72
  73 void mds_pack_req_body(struct ptlrpc_request *req)
  74 {
  75         struct mds_body *b = lustre_msg_buf(req->rq_reqmsg, 0);
  76         mds_pack_body(b);
  77 }
  78
  79 void mds_pack_rep_body(struct ptlrpc_request *req)
  80 {
  81         struct mds_body *b = lustre_msg_buf(req->rq_repmsg, 0);
  82         mds_pack_body(b);
  83 }
  84
  85
  86 /* packing of MDS records */
  87 void mds_create_pack(struct mds_rec_create *rec, struct inode *inode,
  88                      __u32 mode, __u64 id, __u32 uid, __u32 gid, __u64 time)
  89 {
  90         /* XXX do something about time, uid, gid */
  91         rec->cr_opcode = HTON__u32(REINT_CREATE);
  92         ll_inode2fid(&rec->cr_fid, inode);
  93         rec->cr_mode = HTON__u32(mode);
  94         rec->cr_id = HTON__u64(id);
  95         rec->cr_uid = HTON__u32(uid);
  96         rec->cr_gid = HTON__u32(gid);
  97         rec->cr_time = HTON__u64(time);
  98 }
  99
 100 void mds_setattr_pack(struct mds_rec_setattr *rec, struct inode *inode,
 101                       struct iattr *iattr)
 102 {
 103         rec->sa_opcode = HTON__u32(REINT_SETATTR);
 104         ll_inode2fid(&rec->sa_fid, inode);
 105         rec->sa_valid = HTON__u32(iattr->ia_valid);
 106         rec->sa_mode = HTON__u32(iattr->ia_mode);
 107         rec->sa_uid = HTON__u32(iattr->ia_uid);
 108         rec->sa_gid = HTON__u32(iattr->ia_gid);
 109         rec->sa_size = HTON__u64(iattr->ia_size);
 110         rec->sa_atime = HTON__u64(iattr->ia_atime);
 111         rec->sa_mtime = HTON__u64(iattr->ia_mtime);
 112         rec->sa_ctime = HTON__u64(iattr->ia_ctime);
 113         rec->sa_attr_flags = HTON__u32(iattr->ia_attr_flags);
 114 }
 115
 116 void mds_unlink_pack(struct mds_rec_unlink *rec, struct inode *inode,
 117                      struct inode *child)
 118 {
 119         rec->ul_opcode = HTON__u32(REINT_UNLINK);
 120         ll_inode2fid(&rec->ul_fid1, inode);
 121         ll_inode2fid(&rec->ul_fid2, child);
 122 }
 123
 124 void mds_link_pack(struct mds_rec_link *rec,
 125                    struct inode *inode, struct inode *dir)
 126 {
 127         rec->lk_opcode = HTON__u32(REINT_LINK);
 128         ll_inode2fid(&rec->lk_fid1, inode);
 129         ll_inode2fid(&rec->lk_fid2, dir);
 130 }
 131
 132 void mds_rename_pack(struct mds_rec_rename *rec, struct inode *srcdir,
 133                      struct inode *tgtdir)
 134 {
 135         /* XXX do something about time, uid, gid */
 136         rec->rn_opcode = HTON__u32(REINT_RENAME);
 137         ll_inode2fid(&rec->rn_fid1, srcdir);
 138         ll_inode2fid(&rec->rn_fid2, tgtdir);
 139 }
 140
 141 /* unpacking */
 142 void mds_unpack_fid(struct ll_fid *fid)
 143 {
 144         fid->id = NTOH__u64(fid->id);
 145         fid->generation = NTOH__u32(fid->generation);
 146         fid->f_type = NTOH__u32(fid->f_type);
 147 }
 148
 149 static void mds_unpack_body(struct mds_body *b)
 150 {
 151         if (b == NULL)
 152                 LBUG();
 153
 154         mds_unpack_fid(&b->fid1);
 155         mds_unpack_fid(&b->fid2);
 156         b->objid = NTOH__u64(b->objid);
 157         b->size = NTOH__u64(b->size);
 158         b->valid = NTOH__u32(b->valid);
 159         b->mode = NTOH__u32(b->mode);
 160         b->uid = NTOH__u32(b->uid);
 161         b->gid = NTOH__u32(b->gid);
 162         b->mtime = NTOH__u32(b->mtime);
 163         b->ctime = NTOH__u32(b->ctime);
 164         b->atime = NTOH__u32(b->atime);
 165         b->flags = NTOH__u32(b->flags);
 166         b->major = NTOH__u32(b->major);
 167         b->minor = NTOH__u32(b->minor);
 168         b->ino = NTOH__u32(b->ino);
 169         b->nlink = NTOH__u32(b->nlink);
 170         b->generation = NTOH__u32(b->generation);
 171         b->last_xid = NTOH__u32(b->last_xid);
 172         b->last_rcvd = NTOH__u64(b->last_rcvd);
 173         b->last_committed = NTOH__u64(b->last_committed);
 174 }
 175
 176
 177 void mds_unpack_req_body(struct ptlrpc_request *req)
 178 {
 179         struct mds_body *b = lustre_msg_buf(req->rq_reqmsg, 0);
 180         mds_unpack_body(b);
 181 }
 182
 183 void mds_unpack_rep_body(struct ptlrpc_request *req)
 184 {
 185         struct mds_body *b = lustre_msg_buf(req->rq_repmsg, 0);
 186         mds_unpack_body(b);
 187 }
 188
 189 static int mds_setattr_unpack(struct ptlrpc_request *req,
 190                               struct mds_update_record *r)
 191 {
 192         struct iattr *attr = &r->ur_iattr;
 193         struct mds_rec_setattr *rec = lustre_msg_buf(req->rq_reqmsg, 0);
 194         ENTRY;
 195
 196         if (req->rq_reqmsg->bufcount != 1 ||
 197             req->rq_reqmsg->buflens[0] != sizeof(*rec))
 198                 RETURN(-EFAULT);
 199
 200         r->ur_fid1 = &rec->sa_fid;
 201         attr->ia_valid = NTOH__u32(rec->sa_valid);
 202         attr->ia_mode = NTOH__u32(rec->sa_mode);
 203         attr->ia_uid = NTOH__u32(rec->sa_uid);
 204         attr->ia_gid = NTOH__u32(rec->sa_gid);
 205         attr->ia_size = NTOH__u64(rec->sa_size);
 206         attr->ia_atime = NTOH__u64(rec->sa_atime);
 207         attr->ia_mtime = NTOH__u64(rec->sa_mtime);
 208         attr->ia_ctime = NTOH__u64(rec->sa_ctime);
 209         attr->ia_attr_flags = NTOH__u32(rec->sa_attr_flags);
 210         RETURN(0);
 211 }
 212
 213 static int mds_create_unpack(struct ptlrpc_request *req,
 214                              struct mds_update_record *r)
 215 {
 216         struct mds_rec_create *rec = lustre_msg_buf(req->rq_reqmsg, 0);
 217         ENTRY;
 218
 219         if (req->rq_reqmsg->bufcount != 3 ||
 220             req->rq_reqmsg->buflens[0] != sizeof(*rec))
 221                 RETURN(-EFAULT);
 222
 223         r->ur_fid1 = &rec->cr_fid;
 224         r->ur_mode = NTOH__u32(rec->cr_mode);
 225         r->ur_id = NTOH__u64(rec->cr_id);
 226         r->ur_uid = NTOH__u32(rec->cr_uid);
 227         r->ur_gid = NTOH__u32(rec->cr_gid);
 228         r->ur_time = NTOH__u64(rec->cr_time);
 229
 230         r->ur_name = lustre_msg_buf(req->rq_reqmsg, 1);
 231         r->ur_namelen = req->rq_reqmsg->buflens[1];
 232
 233         r->ur_tgt = lustre_msg_buf(req->rq_reqmsg, 2);
 234         r->ur_tgtlen = req->rq_reqmsg->buflens[2];
 235         RETURN(0);
 236 }
 237
 238 static int mds_link_unpack(struct ptlrpc_request *req,
 239                            struct mds_update_record *r)
 240 {
 241         struct mds_rec_link *rec = lustre_msg_buf(req->rq_reqmsg, 0);
 242         ENTRY;
 243
 244         if (req->rq_reqmsg->bufcount != 2 ||
 245             req->rq_reqmsg->buflens[0] != sizeof(*rec))
 246                 RETURN(-EFAULT);
 247
 248         r->ur_fid1 = &rec->lk_fid1;
 249         r->ur_fid2 = &rec->lk_fid2;
 250
 251         r->ur_name = lustre_msg_buf(req->rq_reqmsg, 1);
 252         r->ur_namelen = req->rq_reqmsg->buflens[1];
 253         RETURN(0);
 254 }
 255
 256 static int mds_unlink_unpack(struct ptlrpc_request *req,
 257                              struct mds_update_record *r)
 258 {
 259         struct mds_rec_unlink *rec = lustre_msg_buf(req->rq_reqmsg, 0);
 260         ENTRY;
 261
 262         if (req->rq_reqmsg->bufcount != 2 ||
 263             req->rq_reqmsg->buflens[0] != sizeof(*rec))
 264                 RETURN(-EFAULT);
 265
 266         r->ur_fid1 = &rec->ul_fid1;
 267         r->ur_fid2 = &rec->ul_fid2;
 268
 269         r->ur_name = lustre_msg_buf(req->rq_reqmsg, 1);
 270         r->ur_namelen = req->rq_reqmsg->buflens[1];
 271         RETURN(0);
 272 }
 273
 274 static int mds_rename_unpack(struct ptlrpc_request *req,
 275                              struct mds_update_record *r)
 276 {
 277         struct mds_rec_rename *rec = lustre_msg_buf(req->rq_reqmsg, 0);
 278         ENTRY;
 279
 280         if (req->rq_reqmsg->bufcount != 3 ||
 281             req->rq_reqmsg->buflens[0] != sizeof(*rec))
 282                 RETURN(-EFAULT);
 283
 284         r->ur_fid1 = &rec->rn_fid1;
 285         r->ur_fid2 = &rec->rn_fid2;
 286
 287         r->ur_name = lustre_msg_buf(req->rq_reqmsg, 1);
 288         r->ur_namelen = req->rq_reqmsg->buflens[1];
 289
 290         r->ur_tgt = lustre_msg_buf(req->rq_reqmsg, 2);
 291         r->ur_tgtlen = req->rq_reqmsg->buflens[2];
 292         RETURN(0);
 293 }
 294
 295 typedef int (*update_unpacker)(struct ptlrpc_request *req,
 296                                struct mds_update_record *r);
 297
 298 static update_unpacker mds_unpackers[REINT_MAX + 1] = {
 299         [REINT_SETATTR] mds_setattr_unpack,
 300         [REINT_CREATE] mds_create_unpack,
 301         [REINT_LINK] mds_link_unpack,
 302         [REINT_UNLINK] mds_unlink_unpack,
 303         [REINT_RENAME] mds_rename_unpack,
 304 };
 305
 306 int mds_update_unpack(struct ptlrpc_request *req, struct mds_update_record *rec)
 307 {
 308         struct mds_update_record_hdr *hdr = lustre_msg_buf(req->rq_reqmsg, 0);
 309         int rc;
 310         ENTRY;
 311
 312         if (!hdr || req->rq_reqmsg->buflens[0] < sizeof(__u32))
 313                 RETURN(-EFAULT);
 314
 315         rec->ur_opcode = NTOH__u32(hdr->ur_opcode);
 316
 317         if (rec->ur_opcode < 0 || rec->ur_opcode > REINT_MAX)
 318                 RETURN(-EFAULT);
 319
 320         rc = mds_unpackers[rec->ur_opcode](req, rec);
 321         RETURN(rc);
 322 }