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