new MClientFileCaps encoding

diff --git a/src/client/Client.cc b/src/client/Client.cc
index f92ec0291b48585867ce37b9922235bbbbfdb237..35745c659da586e24bba766f98d27bef09cdfab7 100644 (file)
--- a/src/client/Client.cc
+++ b/src/client/Client.cc
@@ -1242,25 +1242,30 @@ void Client::handle_file_caps(MClientFileCaps *m)
   // did file size decrease?
   if ((old_caps & (CAP_FILE_RD|CAP_FILE_WR)) == 0 &&
       (new_caps & (CAP_FILE_RD|CAP_FILE_WR)) != 0 &&
-      in->inode.size > m->get_inode().size) {
-    dout(10) << "*** file size decreased from " << in->inode.size << " to " << m->get_inode().size << dendl;
+      in->inode.size > (loff_t)m->get_size()) {
+    dout(10) << "*** file size decreased from " << in->inode.size << " to " << m->get_size() << dendl;
     
     // trim filecache?
     if (g_conf.client_oc)
-      in->fc.truncate(in->inode.size, m->get_inode().size);
+      in->fc.truncate(in->inode.size, m->get_size());
 
-    in->inode.size = in->file_wr_size = m->get_inode().size; 
+    in->inode.size = in->file_wr_size = m->get_size(); 
   }
 
   // update inode
-  in->inode = m->get_inode();      // might have updated size... FIXME this is overkill!
+  in->inode.size = m->get_size();      // might have updated size... FIXME this is overkill!
+  in->inode.mtime = m->get_mtime();
+  in->inode.atime = m->get_atime();
 
   // preserve our (possibly newer) file size, mtime
-  if (in->file_wr_size > in->inode.size)
-    m->get_inode().size = in->inode.size = in->file_wr_size;
-  if (in->file_wr_mtime > in->inode.mtime)
-    m->get_inode().mtime = in->inode.mtime = in->file_wr_mtime;
-
+  if (in->file_wr_size > in->inode.size) {
+    in->inode.size = in->file_wr_size;
+    m->set_size(in->file_wr_size);
+  }
+  if (in->file_wr_mtime > in->inode.mtime) {
+    in->inode.mtime = in->file_wr_mtime;
+    m->set_mtime(in->file_wr_mtime);
+  }
 
 
   if (g_conf.client_oc) {

diff --git a/src/include/ceph_fs.h b/src/include/ceph_fs.h
index 47c05853d6d8ea08b5c0934c05ed10299af2cfb3..e600c594dd4862973911ac0b8dd7b810a3279ccd 100644 (file)
--- a/src/include/ceph_fs.h
+++ b/src/include/ceph_fs.h
@@ -418,6 +418,18 @@ struct ceph_mds_reply_dirfrag {
        __u32 dist[];
 } __attribute__ ((packed));
 
+/* client file caps */
+struct ceph_mds_file_caps {
+       __le32 op;
+       __le32 mds;
+       __le64 seq;
+       __le32 caps, wanted;
+       __le64 ino;
+       __le64 size;
+       struct ceph_timeval mtime, atime;
+} __attribute__ ((packed));
+
+/* client reconnect */
 struct ceph_mds_cap_reconnect {
        __le32 wanted;
        __le32 issued;

diff --git a/src/mds/Locker.cc b/src/mds/Locker.cc
index ce027a694686c96637ecd5ae21ce293f3816331e..94d8773feecc814a4726b915c48b39d8d678170e 100644 (file)
--- a/src/mds/Locker.cc
+++ b/src/mds/Locker.cc
@@ -734,27 +734,27 @@ void Locker::handle_client_file_caps(MClientFileCaps *m)
   }
 
   // merge in atime?
-  if (m->get_inode().atime > in->inode.atime) {
-      dout(7) << "  taking atime " << m->get_inode().atime << " > " 
+  if (m->get_atime() > in->inode.atime) {
+      dout(7) << "  taking atime " << m->get_atime() << " > " 
               << in->inode.atime << " for " << *in << dendl;
-    in->inode.atime = m->get_inode().atime;
+    in->inode.atime = m->get_atime();
   }
   
   if ((has|had) & CAP_FILE_WR) {
     bool dirty = false;
 
     // mtime
-    if (m->get_inode().mtime > in->inode.mtime) {
-      dout(7) << "  taking mtime " << m->get_inode().mtime << " > " 
+    if (m->get_mtime() > in->inode.mtime) {
+      dout(7) << "  taking mtime " << m->get_mtime() << " > " 
               << in->inode.mtime << " for " << *in << dendl;
-      in->inode.mtime = m->get_inode().mtime;
+      in->inode.mtime = m->get_mtime();
       dirty = true;
     }
     // size
-    if (m->get_inode().size > in->inode.size) {
-      dout(7) << "  taking size " << m->get_inode().size << " > " 
+    if ((loff_t)m->get_size() > in->inode.size) {
+      dout(7) << "  taking size " << m->get_size() << " > " 
               << in->inode.size << " for " << *in << dendl;
-      in->inode.size = m->get_inode().size;
+      in->inode.size = m->get_size();
       dirty = true;
     }
 

diff --git a/src/messages/MClientFileCaps.h b/src/messages/MClientFileCaps.h
index dfeca48a1217c2b5e984d10ecec1dfdb658bf3a4..6d552c32719677842245de137db1a958bd896395 100644 (file)
--- a/src/messages/MClientFileCaps.h
+++ b/src/messages/MClientFileCaps.h
@@ -43,72 +43,67 @@ class MClientFileCaps : public Message {
   }
 
  private:
-  int32_t op; 
-  inode_t inode;
-  capseq_t seq;
-  int32_t caps;
-  int32_t wanted;
-  
-  int32_t mds;
+  struct ceph_mds_file_caps h;
 
  public:
-  inodeno_t get_ino() { return inode.ino; }
-  inode_t&  get_inode() { return inode; }
-  int       get_caps() { return caps; }
-  int       get_wanted() { return wanted; }
-  capseq_t  get_seq() { return seq; }
+  int       get_caps() { return le32_to_cpu(h.caps); }
+  int       get_wanted() { return le32_to_cpu(h.wanted); }
+  capseq_t  get_seq() { return le64_to_cpu(h.seq); }
+
+  inodeno_t get_ino() { return le64_to_cpu(h.ino); }
+  __u64 get_size() { return le64_to_cpu(h.size);  }
+  utime_t get_mtime() { return utime_t(h.mtime); }
+  utime_t get_atime() { return utime_t(h.atime); }
 
   // for cap migration
-  int       get_mds() { return mds; }
-  int       get_op() { return op; }
+  int       get_mds() { return le32_to_cpu(h.mds); }
+  int       get_op() { return le32_to_cpu(h.op); }
 
-  void set_caps(int c) { caps = c; }
-  void set_wanted(int w) { wanted = w; }
+  void set_caps(int c) { h.caps = cpu_to_le32(c); }
+  void set_wanted(int w) { h.wanted = cpu_to_le32(w); }
 
-  void set_mds(int m) { mds = m; }
-  void set_op(int s) { op = s; }
+  void set_mds(int m) { h.mds = cpu_to_le32(m); }
+  void set_op(int o) { h.op = cpu_to_le32(o); }
+
+  void set_size(loff_t s) { h.size = cpu_to_le64(s); }
+  void set_mtime(utime_t t) { h.mtime = t.tv_ref(); }
+  void set_atime(utime_t t) { h.atime = t.tv_ref(); }
 
   MClientFileCaps() {}
-  MClientFileCaps(int op_,
-                 inode_t& inode_,
-                  long seq_,
-                  int caps_,
-                  int wanted_,
-                  int mds_=0) :
-    Message(CEPH_MSG_CLIENT_FILECAPS),
-    op(op_),
-    inode(inode_),
-    seq(seq_),
-    caps(caps_),
-    wanted(wanted_),
-    mds(mds_) { }
+  MClientFileCaps(int op,
+                 inode_t& inode,
+                  long seq,
+                  int caps,
+                  int wanted,
+                  int mds=0) :
+    Message(CEPH_MSG_CLIENT_FILECAPS) {
+    h.op = cpu_to_le32(op);
+    h.mds = cpu_to_le32(mds);
+    h.seq = cpu_to_le64(seq);
+    h.caps = cpu_to_le32(caps);
+    h.wanted = cpu_to_le32(wanted);
+    h.ino = cpu_to_le64(inode.ino);
+    h.size = cpu_to_le64(inode.size);
+    h.mtime = inode.mtime.tv_ref();
+    h.atime = inode.atime.tv_ref();
+  }
 
   const char *get_type_name() { return "Cfcap";}
   void print(ostream& out) {
-    out << "client_file_caps(" << get_opname(op)
-       << " " << inode.ino
-       << " seq " << seq
-       << " caps " << cap_string(caps) 
-       << " wanted" << cap_string(wanted) 
+    out << "client_file_caps(" << le32_to_cpu(h.op)
+       << " " << le64_to_cpu(h.ino)
+       << " seq " << le32_to_cpu(h.seq)
+       << " caps " << cap_string(le32_to_cpu(h.caps)) 
+       << " wanted" << cap_string(le32_to_cpu(h.wanted)) 
        << ")";
   }
   
   void decode_payload() {
-    int off = 0;
-    ::_decode(op, payload, off);
-    ::_decode(seq, payload, off);
-    ::_decode(inode, payload, off);
-    ::_decode(caps, payload, off);
-    ::_decode(wanted, payload, off);
-    ::_decode(mds, payload, off);
+    bufferlist::iterator p = payload.begin();
+    ::_decode_simple(h, p);
   }
   void encode_payload() {
-    ::_encode(op, payload);
-    ::_encode(seq, payload);
-    ::_encode(inode, payload);
-    ::_encode(caps, payload);
-    ::_encode(wanted, payload);
-    ::_encode(mds, payload);
+    ::_encode_simple(h, payload);
   }
 };