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