Whamcloud - gitweb
git://git.whamcloud.com / fs / lustre-release.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
- Beginning of new REINT replay infrastructure.
[fs/lustre-release.git] / lustre / lib / mds_updates.c
diff --git a/lustre/lib/mds_updates.c b/lustre/lib/mds_updates.c
index 3cf6dbf..345ccba 100644 (file)
--- a/lustre/lib/mds_updates.c
+++ b/lustre/lib/mds_updates.c
@@ -1,13 +1,14 @@
 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
  * vim:expandtab:shiftwidth=8:tabstop=8:
  *
- * Lustre Light Update Records
+ * Copryright (C) 2002 Cluster File Systems, Inc.
  *
- * This code is issued under the GNU General Public License.
- * See the file COPYING in this distribution
+ *   This file is part of Lustre, http://www.sf.net/projects/lustre/
  *
- * Copryright (C) 2002 Cluster File Systems, Inc.
+ *   This code is issued under the GNU General Public License.
+ *   See the file COPYING in this distribution
  *
+ * Lustre Lite Update Records
  */
 
 #include <linux/config.h>
@@ -17,7 +18,11 @@
 #include <linux/string.h>
 #include <linux/stat.h>
 #include <linux/errno.h>
-#include <linux/locks.h>
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
+#include <linux/locks.h>   // for wait_on_buffer
+#else 
+#include <linux/buffer_head.h>   // for wait_on_buffer
+#endif
 #include <linux/unistd.h>
 
 #include <asm/system.h>
@@ -47,8 +52,8 @@ void mds_pack_inode2fid(struct ll_fid *fid, struct inode *inode)
 void mds_pack_inode2body(struct mds_body *b, struct inode *inode)
 {
         b->valid = OBD_MD_FLID | OBD_MD_FLATIME | OBD_MD_FLMTIME |
-                OBD_MD_FLCTIME | OBD_MD_FLMODE | OBD_MD_FLSIZE | OBD_MD_FLUID |
-                OBD_MD_FLGID | OBD_MD_FLNLINK | OBD_MD_FLGENER;
+                OBD_MD_FLCTIME | OBD_MD_FLSIZE | OBD_MD_FLUID | OBD_MD_FLGID |
+                OBD_MD_FLTYPE | OBD_MD_FLMODE | OBD_MD_FLNLINK | OBD_MD_FLGENER;
         b->ino = HTON__u32(inode->i_ino);
         b->atime = HTON__u32(inode->i_atime);
         b->mtime = HTON__u32(inode->i_mtime);
@@ -77,10 +82,13 @@ static void mds_pack_body(struct mds_body *b)
         if (b == NULL)
                 LBUG();
 
+        b->fsuid = HTON__u32(current->fsuid);
+        b->fsgid = HTON__u32(current->fsgid);
+
         mds_pack_fid(&b->fid1);
         mds_pack_fid(&b->fid2);
-        b->extra = HTON__u64(b->extra);
         b->size = HTON__u64(b->size);
+        b->ino = HTON__u32(b->ino);
         b->valid = HTON__u32(b->valid);
         b->mode = HTON__u32(b->mode);
         b->uid = HTON__u32(b->uid);
@@ -89,22 +97,20 @@ static void mds_pack_body(struct mds_body *b)
         b->ctime = HTON__u32(b->ctime);
         b->atime = HTON__u32(b->atime);
         b->flags = HTON__u32(b->flags);
-        b->major = HTON__u32(b->major);
-        b->minor = HTON__u32(b->minor);
-        b->ino = HTON__u32(b->ino);
+        b->rdev = HTON__u32(b->rdev);
         b->nlink = HTON__u32(b->nlink);
         b->generation = HTON__u32(b->generation);
 }
 
 void mds_getattr_pack(struct ptlrpc_request *req, int offset,
-                      struct inode *inode, 
+                      struct inode *inode,
                       const char *name, int namelen)
 {
         struct mds_body *rec;
         rec = lustre_msg_buf(req->rq_reqmsg, offset);
 
         ll_inode2fid(&rec->fid1, inode);
-        if (name) { 
+        if (name) {
                 char *tmp;
                 tmp = lustre_msg_buf(req->rq_reqmsg, offset + 1);
                 LOGL0(name, namelen, tmp);
@@ -112,13 +118,13 @@ void mds_getattr_pack(struct ptlrpc_request *req, int offset,
 }
 
 
-void mds_pack_req_body(struct ptlrpc_request *req) 
+void mds_pack_req_body(struct ptlrpc_request *req)
 {
         struct mds_body *b = lustre_msg_buf(req->rq_reqmsg, 0);
         mds_pack_body(b);
 }
 
-void mds_pack_rep_body(struct ptlrpc_request *req) 
+void mds_pack_rep_body(struct ptlrpc_request *req)
 {
         struct mds_body *b = lustre_msg_buf(req->rq_repmsg, 0);
         mds_pack_body(b);
@@ -137,6 +143,8 @@ void mds_create_pack(struct ptlrpc_request *req, int offset,
 
         /* XXX do something about time, uid, gid */
         rec->cr_opcode = HTON__u32(REINT_CREATE);
+        rec->cr_fsuid = HTON__u32(current->fsuid);
+        rec->cr_fsgid = HTON__u32(current->fsgid);
         ll_inode2fid(&rec->cr_fid, inode);
         rec->cr_mode = HTON__u32(mode);
         rec->cr_rdev = HTON__u64(rdev);
@@ -154,13 +162,15 @@ void mds_create_pack(struct ptlrpc_request *req, int offset,
 }
 
 void mds_setattr_pack(struct ptlrpc_request *req, int offset,
-                      struct inode *inode, struct iattr *iattr, 
+                      struct inode *inode, struct iattr *iattr,
                       const char *name, int namelen)
 {
         struct mds_rec_setattr *rec;
         rec = lustre_msg_buf(req->rq_reqmsg, offset);
 
         rec->sa_opcode = HTON__u32(REINT_SETATTR);
+        rec->sa_fsuid = HTON__u32(current->fsuid);
+        rec->sa_fsgid = HTON__u32(current->fsgid);
         ll_inode2fid(&rec->sa_fid, inode);
         rec->sa_valid = HTON__u32(iattr->ia_valid);
         rec->sa_mode = HTON__u32(iattr->ia_mode);
@@ -172,7 +182,7 @@ void mds_setattr_pack(struct ptlrpc_request *req, int offset,
         rec->sa_ctime = HTON__u64(iattr->ia_ctime);
         rec->sa_attr_flags = HTON__u32(iattr->ia_attr_flags);
 
-        if (namelen) { 
+        if (namelen) {
                 char *tmp;
                 tmp = lustre_msg_buf(req->rq_reqmsg, offset + 1);
                 LOGL0(name, namelen, tmp);
@@ -180,7 +190,7 @@ void mds_setattr_pack(struct ptlrpc_request *req, int offset,
 }
 
 void mds_unlink_pack(struct ptlrpc_request *req, int offset,
-                     struct inode *inode, struct inode *child,
+                     struct inode *inode, struct inode *child, __u32 mode,
                      const char *name, int namelen)
 {
         struct mds_rec_unlink *rec;
@@ -189,8 +199,11 @@ void mds_unlink_pack(struct ptlrpc_request *req, int offset,
         rec = lustre_msg_buf(req->rq_reqmsg, offset);
 
         rec->ul_opcode = HTON__u32(REINT_UNLINK);
+        rec->ul_fsuid = HTON__u32(current->fsuid);
+        rec->ul_fsgid = HTON__u32(current->fsgid);
+        rec->ul_mode = HTON__u32(mode);
         ll_inode2fid(&rec->ul_fid1, inode);
-        if (child) 
+        if (child)
                 ll_inode2fid(&rec->ul_fid2, child);
 
         tmp = lustre_msg_buf(req->rq_reqmsg, offset + 1);
@@ -207,6 +220,8 @@ void mds_link_pack(struct ptlrpc_request *req, int offset,
         rec = lustre_msg_buf(req->rq_reqmsg, offset);
 
         rec->lk_opcode = HTON__u32(REINT_LINK);
+        rec->lk_fsuid = HTON__u32(current->fsuid);
+        rec->lk_fsgid = HTON__u32(current->fsgid);
         ll_inode2fid(&rec->lk_fid1, inode);
         ll_inode2fid(&rec->lk_fid2, dir);
 
@@ -225,6 +240,8 @@ void mds_rename_pack(struct ptlrpc_request *req, int offset,
 
         /* XXX do something about time, uid, gid */
         rec->rn_opcode = HTON__u32(REINT_RENAME);
+        rec->rn_fsuid = HTON__u32(current->fsuid);
+        rec->rn_fsgid = HTON__u32(current->fsgid);
         ll_inode2fid(&rec->rn_fid1, srcdir);
         ll_inode2fid(&rec->rn_fid2, tgtdir);
 
@@ -252,9 +269,11 @@ void mds_unpack_body(struct mds_body *b)
 
         mds_unpack_fid(&b->fid1);
         mds_unpack_fid(&b->fid2);
-        b->extra = NTOH__u64(b->extra);
         b->size = NTOH__u64(b->size);
         b->valid = NTOH__u32(b->valid);
+        b->fsuid = NTOH__u32(b->fsuid);
+        b->fsgid = NTOH__u32(b->fsgid);
+        b->ino = NTOH__u32(b->ino);
         b->mode = NTOH__u32(b->mode);
         b->uid = NTOH__u32(b->uid);
         b->gid = NTOH__u32(b->gid);
@@ -262,9 +281,7 @@ void mds_unpack_body(struct mds_body *b)
         b->ctime = NTOH__u32(b->ctime);
         b->atime = NTOH__u32(b->atime);
         b->flags = NTOH__u32(b->flags);
-        b->major = NTOH__u32(b->major);
-        b->minor = NTOH__u32(b->minor);
-        b->ino = NTOH__u32(b->ino);
+        b->rdev = NTOH__u32(b->rdev);
         b->nlink = NTOH__u32(b->nlink);
         b->generation = NTOH__u32(b->generation);
 }
@@ -280,6 +297,8 @@ static int mds_setattr_unpack(struct ptlrpc_request *req, int offset,
             req->rq_reqmsg->buflens[offset] != sizeof(*rec))
                 RETURN(-EFAULT);
 
+        r->ur_fsuid = NTOH__u32(rec->sa_fsuid);
+        r->ur_fsgid = NTOH__u32(rec->sa_fsgid);
         r->ur_fid1 = &rec->sa_fid;
         attr->ia_valid = NTOH__u32(rec->sa_valid);
         attr->ia_mode = NTOH__u32(rec->sa_mode);
@@ -291,10 +310,10 @@ static int mds_setattr_unpack(struct ptlrpc_request *req, int offset,
         attr->ia_ctime = NTOH__u64(rec->sa_ctime);
         attr->ia_attr_flags = NTOH__u32(rec->sa_attr_flags);
 
-        if (req->rq_reqmsg->bufcount == offset + 2) { 
+        if (req->rq_reqmsg->bufcount == offset + 2) {
                 r->ur_namelen = req->rq_reqmsg->buflens[offset + 1];
                 r->ur_name = lustre_msg_buf(req->rq_reqmsg, offset + 1);
-        } else 
+        } else
                 r->ur_namelen = 0;
 
         RETURN(0);
@@ -306,10 +325,12 @@ static int mds_create_unpack(struct ptlrpc_request *req, int offset,
         struct mds_rec_create *rec = lustre_msg_buf(req->rq_reqmsg, offset);
         ENTRY;
 
-        if (req->rq_reqmsg->bufcount != offset + 3 ||
+        if (req->rq_reqmsg->bufcount < offset + 2 ||
             req->rq_reqmsg->buflens[offset] != sizeof(*rec))
                 RETURN(-EFAULT);
 
+        r->ur_fsuid = NTOH__u32(rec->cr_fsuid);
+        r->ur_fsgid = NTOH__u32(rec->cr_fsgid);
         r->ur_fid1 = &rec->cr_fid;
         r->ur_mode = NTOH__u32(rec->cr_mode);
         r->ur_rdev = NTOH__u64(rec->cr_rdev);
@@ -320,8 +341,13 @@ static int mds_create_unpack(struct ptlrpc_request *req, int offset,
         r->ur_name = lustre_msg_buf(req->rq_reqmsg, offset + 1);
         r->ur_namelen = req->rq_reqmsg->buflens[offset + 1];
 
-        r->ur_tgt = lustre_msg_buf(req->rq_reqmsg, offset + 2);
-        r->ur_tgtlen = req->rq_reqmsg->buflens[offset + 2];
+        if (req->rq_reqmsg->bufcount == offset + 3) { 
+                r->ur_tgt = lustre_msg_buf(req->rq_reqmsg, offset + 2);
+                r->ur_tgtlen = req->rq_reqmsg->buflens[offset + 2];
+        } else { 
+                r->ur_tgt = NULL;
+                r->ur_tgtlen = 0;
+        }
         RETURN(0);
 }
 
@@ -335,6 +361,8 @@ static int mds_link_unpack(struct ptlrpc_request *req, int offset,
             req->rq_reqmsg->buflens[offset] != sizeof(*rec))
                 RETURN(-EFAULT);
 
+        r->ur_fsuid = NTOH__u32(rec->lk_fsuid);
+        r->ur_fsgid = NTOH__u32(rec->lk_fsgid);
         r->ur_fid1 = &rec->lk_fid1;
         r->ur_fid2 = &rec->lk_fid2;
 
@@ -353,6 +381,9 @@ static int mds_unlink_unpack(struct ptlrpc_request *req, int offset,
             req->rq_reqmsg->buflens[offset] != sizeof(*rec))
                 RETURN(-EFAULT);
 
+        r->ur_fsuid = NTOH__u32(rec->ul_fsuid);
+        r->ur_fsgid = NTOH__u32(rec->ul_fsgid);
+        r->ur_mode = NTOH__u32(rec->ul_mode);
         r->ur_fid1 = &rec->ul_fid1;
         r->ur_fid2 = &rec->ul_fid2;
 
@@ -371,6 +402,8 @@ static int mds_rename_unpack(struct ptlrpc_request *req, int offset,
             req->rq_reqmsg->buflens[offset] != sizeof(*rec))
                 RETURN(-EFAULT);
 
+        r->ur_fsuid = NTOH__u32(rec->rn_fsuid);
+        r->ur_fsgid = NTOH__u32(rec->rn_fsgid);
         r->ur_fid1 = &rec->rn_fid1;
         r->ur_fid2 = &rec->rn_fid2;
 
@@ -391,24 +424,24 @@ static update_unpacker mds_unpackers[REINT_MAX + 1] = {
         [REINT_LINK] mds_link_unpack,
         [REINT_UNLINK] mds_unlink_unpack,
         [REINT_RENAME] mds_rename_unpack,
-        [REINT_RECREATE] mds_create_unpack,
 };
 
 int mds_update_unpack(struct ptlrpc_request *req, int offset,
                       struct mds_update_record *rec)
 {
         __u32 *opcode = lustre_msg_buf(req->rq_reqmsg, offset);
-        int rc;
+        int rc, realop;
         ENTRY;
 
         if (!opcode || req->rq_reqmsg->buflens[offset] < sizeof(*opcode))
                 RETURN(-EFAULT);
 
-        rec->ur_opcode = NTOH__u32(*opcode);
+        realop = rec->ur_opcode = NTOH__u32(*opcode);
+        realop &= REINT_OPCODE_MASK;
 
-        if (rec->ur_opcode < 0 || rec->ur_opcode > REINT_MAX)
+        if (realop < 0 || realop > REINT_MAX)
                 RETURN(-EFAULT);
 
-        rc = mds_unpackers[rec->ur_opcode](req, offset, rec);
+        rc = mds_unpackers[realop](req, offset, rec);
         RETURN(rc);
 }
Lustre primary development and releases