Skip to contentSkip to conversation

Inline data support

RFC Superseded Li Wang 2 participants 3 messages Jul 3, 2013 – Jul 8, 2013

Subsystems (2)

v1 of 6 Superseded Latest is v6 →

lore
Share & tools
lore

Li Wang

author
#0 lore raw

RFC 1/1 Inline data support

This patch gives a preliminary implementation of inline data support for Ceph. Comments are appreciated.

---
 src/client/Client.cc        |  158 ++++++++++++++++++++++++++++++++++++++-----
 src/client/Inode.h          |    6 ++
 src/include/ceph_fs.h       |    9 +++
 src/mds/CInode.cc           |   22 ++++++
 src/mds/Capability.h        |    3 +
 src/mds/Locker.cc           |   48 +++++++++++++
 src/mds/mdstypes.cc         |    4 ++
 src/mds/mdstypes.h          |    3 +
 src/messages/MClientCaps.h  |    6 ++
 src/messages/MClientReply.h |    4 ++
 10 files changed, 246 insertions(+), 17 deletions(-)
src/client/Client.cc +141 -17
index bddfa0a..fe947be 100644
@@ -632,6 +632,11 @@ Inode * Client::add_update_inode(InodeStat *st, utime_t from, MetaSession *sessi
     in->layout = st->layout;
     in->ctime = st->ctime;
     in->max_size = st->max_size;  // right?
+
+    if (st->inline_version > in->inline_version) {
+      in->inline_version = st->inline_version;
+      in->inline_data = st->inline_data;
+    }
   
     update_inode_file_bits(in, st->truncate_seq, st->truncate_size, st->size,
 			   st->time_warp_seq, st->ctime, st->mtime, st->atime,
@@ -2321,6 +2326,17 @@ void Client::send_cap(Inode *in, MetaSession *session, Cap *cap,
     ::encode(in->xattrs, m->xattrbl);
     m->head.xattr_version = in->xattr_version;
   }
+
+  if ((flush & CEPH_CAP_FILE_WR) &&
+      (flush & CEPH_CAP_FILE_BUFFER)) {
+    if (in->inline_commit_data.length()) {
+      m->head.inline_version = 0;
+      m->inline_data = in->inline_commit_data;
+    } else {
+      m->head.inline_version = in->inline_version;
+      m->inline_data = in->inline_data;
+    }
+  }
   
   m->head.layout = in->layout;
   m->head.size = in->size;
@@ -3550,6 +3566,13 @@ void Client::handle_cap_grant(MetaSession *session, Inode *in, Cap *cap, MClient
     ::decode(in->xattrs, p);
     in->xattr_version = m->head.xattr_version;
   }
+  if ((new_caps & CEPH_CAP_FILE_CACHE) &&
+      (m->get_inline_version() >= in->inline_version)) {
+    ldout(cct, 10) << " update inline version " << m->get_inline_version() << dendl;
+    in->inline_version = m->get_inline_version();
+    in->inline_data = m->inline_data;
+  }
+
   update_inode_file_bits(in, m->get_truncate_seq(), m->get_truncate_size(), m->get_size(),
 			 m->get_time_warp_seq(), m->get_ctime(), m->get_mtime(), m->get_atime(), issued);
 
@@ -5637,6 +5660,13 @@ int Client::_read(Fh *f, int64_t offset, uint64_t size, bufferlist *bl)
   Inode *in = f->inode;
 
   //bool lazy = f->mode == CEPH_FILE_MODE_LAZY;
+  if ((in->inline_version != CEPH_INLINE_DISABLED) &&
+      !(in->caps_issued(NULL) & CEPH_CAP_FILE_CACHE)) {
+    ldout(cct, 10) << " read inline from mds." << dendl;
+    int ret = _getattr(in, CEPH_STAT_CAP_INLINE, -1, -1, true);
+    if (ret < 0)
+      return ret;
+  }
 
   int have;
   int r = get_caps(in, CEPH_CAP_FILE_RD, CEPH_CAP_FILE_CACHE, &have, -1);
@@ -5650,15 +5680,31 @@ int Client::_read(Fh *f, int64_t offset, uint64_t size, bufferlist *bl)
     movepos = true;
   }
 
-  if (!conf->client_debug_force_sync_read &&
-      (cct->_conf->client_oc && (have & CEPH_CAP_FILE_CACHE))) {
+  unsigned int inlinesize = 0;
+  if (in->inline_version != CEPH_INLINE_DISABLED) {
+    if (offset < in->inline_data.length()) {
+      inlinesize = in->inline_data.length() - offset;
+      if (inlinesize > size)
+        inlinesize = size;
+      in->inline_data.copy(offset, inlinesize, *bl);
+    }
+  }
+
+  if (size > inlinesize) {
+    bufferlist blread;
+    int64_t bloffset = offset + inlinesize;
+    uint64_t blsize = size - inlinesize;
+    if (!conf->client_debug_force_sync_read &&
+        (cct->_conf->client_oc && (have & CEPH_CAP_FILE_CACHE))) {
 
-    if (f->flags & O_RSYNC) {
-      _flush_range(in, offset, size);
+      if (f->flags & O_RSYNC) {
+        _flush_range(in, bloffset, blsize);
+      }
+      r = _read_async(f, bloffset, blsize, &blread);
+    } else {
+      r = _read_sync(f, bloffset, blsize, &blread);
     }
-    r = _read_async(f, offset, size, bl);
-  } else {
-    r = _read_sync(f, offset, size, bl);
+    bl->claim_append(blread);
   }
 
   // don't move pointer if the read failed
@@ -5935,22 +5981,91 @@ int Client::_write(Fh *f, int64_t offset, uint64_t size, const char *buf)
   // time it.
   utime_t start = ceph_clock_now(cct);
 
-  // copy into fresh buffer (since our write may be resub, async)
-  bufferptr bp;
-  if (size > 0) bp = buffer::copy(buf, size);
-  bufferlist bl;
-  bl.push_back( bp );
-
   utime_t lat;
   uint64_t totalwritten;
   uint64_t endoff = offset + size;
   int have;
-  int r = get_caps(in, CEPH_CAP_FILE_WR, CEPH_CAP_FILE_BUFFER, &have, endoff);
+  int want;
+  if (in->inline_version != CEPH_INLINE_DISABLED) {
+    want = 0;
+    if (offset < CEPH_INLINE_SIZE)
+      want |= CEPH_CAP_FILE_CACHE;
+    if (offset + size > CEPH_INLINE_SIZE)
+      want |= CEPH_CAP_FILE_BUFFER;
+  } else {
+    want = CEPH_CAP_FILE_BUFFER;
+  }
+  int r = get_caps(in, CEPH_CAP_FILE_WR, want, &have, endoff);
   if (r < 0)
     return r;
 
   ldout(cct, 10) << " snaprealm " << *in->snaprealm << dendl;
 
+  bufferlist inlinebl, osdbl;
+  if (size > 0) {
+    // copy into fresh buffer (since our write may be resub, async)
+    bufferptr bp(buf, size);
+    if ((in->inline_version != CEPH_INLINE_DISABLED) &&
+        (want & CEPH_CAP_FILE_CACHE)) {
+
+      if (want & CEPH_CAP_FILE_BUFFER) {
+        bufferptr inlinebp(bp, 0, CEPH_INLINE_SIZE - offset);
+        inlinebl.push_back(inlinebp);
+        bufferptr osdbp(bp, CEPH_INLINE_SIZE - offset, size + offset - CEPH_INLINE_SIZE);
+        osdbl.push_back(osdbp);
+      } else {
+        inlinebl.push_back(bp);
+      }
+
+      if (have & CEPH_CAP_FILE_CACHE) {
+        bufferlist bl;
+
+        uint32_t len = in->inline_data.length();
+        if (offset < len) {
+          bl.substr_of(in->inline_data, 0, offset);
+        } else {
+          bl.append(in->inline_data);
+          if (offset > len)
+            bl.append_zero(offset - len);
+        }
+        bl.append(inlinebl);
+        if (bl.length() < len)
+          in->inline_data.copy(bl.length(), len - bl.length(), bl);
+
+        if (in->inline_version >= CEPH_INLINE_MIGRATION) {
+          ldout(cct, 10) << " migrate data." << dendl;
+          bl.append(osdbl);
+          osdbl.claim(bl);
+        } else {
+          in->inline_data.claim(bl);
+        }
+      } else {
+        encode((uint32_t)offset, in->inline_commit_data);
+        encode(inlinebl, in->inline_commit_data);
+      }
+
+      if ((in->inline_version < CEPH_INLINE_MIGRATION) ||
+          !(have & CEPH_CAP_FILE_CACHE)) {
+        mark_caps_dirty(in, CEPH_CAP_FILE_WR | CEPH_CAP_FILE_BUFFER);
+        check_caps(in, true);
+      }
+
+      if (!(have & CEPH_CAP_FILE_CACHE)) {
+        in->inline_commit_data.clear();
+      }
+    } else {
+      osdbl.push_back(bp);
+    }
+  }
+
+  uint64_t osdsize = osdbl.length();
+  int64_t osdoffset = offset + size - osdsize;
+  if (osdoffset < 0)
+    osdoffset = 0;
+
+  if (!osdsize)
+    goto skip_osd;
+
   if (cct->_conf->client_oc && (have & CEPH_CAP_FILE_BUFFER)) {
     // do buffered write
     if (!in->oset.dirty_or_tx)
@@ -5960,7 +6075,7 @@ int Client::_write(Fh *f, int64_t offset, uint64_t size, const char *buf)
 
     // async, caching, non-blocking.
     r = objectcacher->file_write(&in->oset, &in->layout, in->snaprealm->get_snap_context(),
-			         offset, size, bl, ceph_clock_now(cct), 0,
+			         osdoffset, osdsize, osdbl, ceph_clock_now(cct), 0,
 			         client_lock);
 
     put_cap_ref(in, CEPH_CAP_FILE_BUFFER);
@@ -5972,7 +6087,7 @@ int Client::_write(Fh *f, int64_t offset, uint64_t size, const char *buf)
     // O_DSYNC == O_SYNC on linux < 2.6.33
     // O_SYNC = __O_SYNC | O_DSYNC on linux >= 2.6.33
     if ((f->flags & O_SYNC) || (f->flags & O_DSYNC)) {
-      _flush_range(in, offset, size);
+      _flush_range(in, osdoffset, osdsize);
     }
   } else {
     // simple, non-atomic sync write
@@ -5986,7 +6101,7 @@ int Client::_write(Fh *f, int64_t offset, uint64_t size, const char *buf)
     get_cap_ref(in, CEPH_CAP_FILE_BUFFER);  // released by onsafe callback
 
     r = filer->write_trunc(in->ino, &in->layout, in->snaprealm->get_snap_context(),
-			   offset, size, bl, ceph_clock_now(cct), 0,
+			   osdoffset, osdsize, osdbl, ceph_clock_now(cct), 0,
 			   in->truncate_size, in->truncate_seq,
 			   onfinish, onsafe);
     if (r < 0)
@@ -6001,6 +6116,15 @@ int Client::_write(Fh *f, int64_t offset, uint64_t size, const char *buf)
   }
 
   // if we get here, write was successful, update client metadata
+skip_osd:
+  if ((have & CEPH_CAP_FILE_CACHE) &&
+      (in->inline_version >= CEPH_INLINE_MIGRATION)) {
+    ldout(cct, 10) << " disable inline." << dendl;
+    in->inline_version = CEPH_INLINE_DISABLED;
+    in->inline_data.clear();
+    mark_caps_dirty(in, CEPH_CAP_FILE_WR | CEPH_CAP_FILE_BUFFER);
+    check_caps(in, true);
+  }
 
   // time
   lat = ceph_clock_now(cct);
src/client/Inode.h +6 -0
index b33c38e..455fc37 100644
@@ -111,6 +111,11 @@ class Inode {
   version_t version;           // auth only
   version_t xattr_version;
 
+  // inline data
+  bufferlist inline_data;
+  version_t  inline_version;
+  bufferlist inline_commit_data;
+
   bool is_symlink() const { return (mode & S_IFMT) == S_IFLNK; }
   bool is_dir()     const { return (mode & S_IFMT) == S_IFDIR; }
   bool is_file()    const { return (mode & S_IFMT) == S_IFREG; }
@@ -205,6 +210,7 @@ class Inode {
       rdev(0), mode(0), uid(0), gid(0), nlink(0),
       size(0), truncate_seq(1), truncate_size(-1),
       time_warp_seq(0), max_size(0), version(0), xattr_version(0),
+      inline_version(0),
       flags(0),
       dir_hashed(false), dir_replicated(false), auth_cap(NULL),
       dirty_caps(0), flushing_caps(0), flushing_cap_seq(0), shared_gen(0), cache_gen(0),
src/include/ceph_fs.h +9 -0
index 6c41d14..bd81687 100644
@@ -471,6 +471,7 @@ struct ceph_mds_reply_inode {
 	struct ceph_file_layout layout;
 	struct ceph_timespec ctime, mtime, atime;
 	__le32 time_warp_seq;
+	__le32 inline_version;
 	__le64 size, max_size, truncate_size;
 	__le32 truncate_seq;
 	__le32 mode, uid, gid;
@@ -522,6 +523,10 @@ struct ceph_filelock {
 
 int ceph_flags_to_mode(int flags);
 
+/* inline data state */
+#define CEPH_INLINE_DISABLED   ((__u32)-1)
+#define CEPH_INLINE_MIGRATION  (CEPH_INLINE_DISABLED >> 1)
+#define CEPH_INLINE_SIZE       (1 << 8)
 
 /* capability bits */
 #define CEPH_CAP_PIN         1  /* no specific capabilities beyond the pin */
@@ -580,6 +585,7 @@ int ceph_flags_to_mode(int flags);
 #define CEPH_STAT_CAP_MTIME    CEPH_CAP_FILE_SHARED
 #define CEPH_STAT_CAP_SIZE     CEPH_CAP_FILE_SHARED
 #define CEPH_STAT_CAP_ATIME    CEPH_CAP_FILE_SHARED  /* fixme */
+#define CEPH_STAT_CAP_INLINE   CEPH_CAP_FILE_SHARED
 #define CEPH_STAT_CAP_XATTR    CEPH_CAP_XATTR_SHARED
 #define CEPH_STAT_CAP_INODE_ALL (CEPH_CAP_PIN |			\
 				 CEPH_CAP_AUTH_SHARED |	\
@@ -657,6 +663,9 @@ struct ceph_mds_caps {
 	struct ceph_timespec mtime, atime, ctime;
 	struct ceph_file_layout layout;
 	__le32 time_warp_seq;
+
+	/* ilnine data */
+	__le32 inline_version;
 } __attribute__ ((packed));
 
 /* cap release msg head */
src/mds/CInode.cc +22 -0
index 781ed72..3999078 100644
@@ -2706,6 +2706,17 @@ int CInode::encode_inodestat(bufferlist& bl, Session *session,
   e.rfiles = i->rstat.rfiles;
   e.rsubdirs = i->rstat.rsubdirs;
 
+  // inline data
+  bufferlist inline_data;
+  if (!cap || (cap->client_inline_version < i->inline_version)) {
+    e.inline_version = i->inline_version;
+    inline_data = i->inline_data;
+  }
+  if (cap && (cap->client_inline_version < i->inline_version)) {
+    cap->client_inline_version = i->inline_version;
+    cap->server_inline_version = i->inline_version;
+  }
+
   // auth
   i = pauth ? pi:oi;
   e.mode = i->mode;
@@ -2738,6 +2749,7 @@ int CInode::encode_inodestat(bufferlist& bl, Session *session,
     bytes += (sizeof(__u32) + sizeof(__u32)) * dirfragtree._splits.size();
     bytes += sizeof(__u32) + symlink.length();
     bytes += sizeof(__u32) + xbl.length();
+    bytes += sizeof(__u32) + inline_data.length();
     if (bytes > max_bytes)
       return -ENOSPC;
   }
@@ -2833,6 +2845,7 @@ int CInode::encode_inodestat(bufferlist& bl, Session *session,
     ::encode(i->dir_layout, bl);
   }
   ::encode(xbl, bl);
+  ::encode(inline_data, bl);
 
   return valid;
 }
@@ -2865,6 +2878,15 @@ void CInode::encode_cap_message(MClientCaps *m, Capability *cap)
   i->atime.encode_timeval(&m->head.atime);
   m->head.time_warp_seq = i->time_warp_seq;
 
+  if ((cap->pending() & CEPH_CAP_FILE_CACHE) &&
+      (i->inline_version > cap->client_inline_version)) {
+    dout(10) << " push updated inline data version " << i->inline_version << dendl;
+    m->head.inline_version = i->inline_version;
+    m->inline_data = i->inline_data;
+    cap->client_inline_version = i->inline_version;
+    cap->server_inline_version = i->inline_version;
+  }
+  
   // max_size is min of projected, actual.
   uint64_t oldms = oi->client_ranges.count(client) ? oi->client_ranges[client].range.last : 0;
   uint64_t newms = pi->client_ranges.count(client) ? pi->client_ranges[client].range.last : 0;
src/mds/Capability.h +3 -0
index 54d2312..aa8fbb9 100644
@@ -207,6 +207,8 @@ private:
 public:
   snapid_t client_follows;
   version_t client_xattr_version;
+  version_t client_inline_version;
+  version_t server_inline_version;
   
   xlist<Capability*>::item item_session_caps;
   xlist<Capability*>::item item_snaprealm_caps;
@@ -221,6 +223,7 @@ public:
     mseq(0),
     suppress(0), stale(false),
     client_follows(0), client_xattr_version(0),
+    client_inline_version(0), server_inline_version(0),
     item_session_caps(this), item_snaprealm_caps(this) {
     g_num_cap++;
     g_num_capa++;
src/mds/Locker.cc +48 -0

54 lines not on this page · raw message

src/mds/mdstypes.cc +4 -0
index b1ce640..bb56122 100644
@@ -227,6 +227,8 @@ void inode_t::encode(bufferlist &bl) const
   ::encode(mtime, bl);
   ::encode(atime, bl);
   ::encode(time_warp_seq, bl);
+  ::encode(inline_version, bl);
+  ::encode(inline_data, bl);
   ::encode(client_ranges, bl);
 
   ::encode(dirstat, bl);
@@ -273,6 +275,8 @@ void inode_t::decode(bufferlist::iterator &p)
   ::decode(mtime, p);
   ::decode(atime, p);
   ::decode(time_warp_seq, p);
+  ::decode(inline_version, p);
+  ::decode(inline_data, p);
   if (struct_v >= 3) {
     ::decode(client_ranges, p);
   } else {
src/mds/mdstypes.h +3 -0
index aa9d165..7e8a69a 100644
@@ -334,6 +334,8 @@ struct inode_t {
   utime_t    mtime;   // file data modify time.
   utime_t    atime;   // file data access time.
   uint32_t   time_warp_seq;  // count of (potential) mtime/atime timewarps (i.e., utimes())
+  bufferlist inline_data;
+  version_t  inline_version;
 
   map<client_t,client_writeable_range_t> client_ranges;  // client(s) can write to these ranges
 
@@ -355,6 +357,7 @@ struct inode_t {
 	      size(0), truncate_seq(0), truncate_size(0), truncate_from(0),
 	      truncate_pending(0),
 	      time_warp_seq(0),
+	      inline_version(1),
 	      version(0), file_data_version(0), xattr_version(0), last_renamed_version(0) { 
     clear_layout();
     memset(&dir_layout, 0, sizeof(dir_layout));
src/messages/MClientCaps.h +6 -0
index 117f241..aab28d2 100644
@@ -29,6 +29,7 @@ class MClientCaps : public Message {
   bufferlist snapbl;
   bufferlist xattrbl;
   bufferlist flockbl;
+  bufferlist inline_data;
 
   int      get_caps() { return head.caps; }
   int      get_wanted() { return head.wanted; }
@@ -49,6 +50,7 @@ class MClientCaps : public Message {
   utime_t get_mtime() { return utime_t(head.mtime); }
   utime_t get_atime() { return utime_t(head.atime); }
   __u32 get_time_warp_seq() { return head.time_warp_seq; }
+  __u32 get_inline_version() { return head.inline_version; }
 
   ceph_file_layout& get_layout() { return head.layout; }
 
@@ -151,6 +153,8 @@ public:
     // conditionally decode flock metadata
     if (header.version >= 2)
       ::decode(flockbl, p);
+
+    ::decode(inline_data, p);
   }
   void encode_payload(uint64_t features) {
     head.snap_trace_len = snapbl.length();
@@ -166,6 +170,8 @@ public:
     } else {
       header.version = 1;  // old
     }
+
+    ::encode(inline_data, payload);
   }
 };
 
src/messages/MClientReply.h +4 -0
index 896245f..b15e843 100644
@@ -108,6 +108,8 @@ struct InodeStat {
   uint64_t truncate_size;
   utime_t ctime, mtime, atime;
   version_t time_warp_seq;
+  bufferlist inline_data;
+  version_t inline_version;
 
   frag_info_t dirstat;
   nest_info_t rstat;
@@ -144,6 +146,7 @@ struct InodeStat {
     mtime.decode_timeval(&e.mtime);
     atime.decode_timeval(&e.atime);
     time_warp_seq = e.time_warp_seq;
+    inline_version = e.inline_version;
     mode = e.mode;
     uid = e.uid;
     gid = e.gid;
@@ -174,6 +177,7 @@ struct InodeStat {
 
     xattr_version = e.xattr_version;
     ::decode(xattrbl, p);
+    ::decode(inline_data, p);
   }
   
   // see CInode::encode_inodestat for encoder.
Signature · 1 line
1.7.9.5
#1 lore raw
Quoted 5 lines · Li Wang

This patch gives a preliminary implementation of inline data support for Ceph. Comments are appreciated.

A few comments below (although I didn't have time for a thorough review). My main concern is that it looks like it is possible to have a file that is half-inlined and half not. That seems to complicate things and it's not clear to me that it is much of a win (correct me if I'm wrong here!).

My other concern is that it is pretty simple to reason about this if the shared reader and exclusive writer cases. For shared write, or mixed read/write (LOCK_MIX filelock state on mds) it all sort of falls apart. Is the plan for the MDS to uninline in that case before issuing those caps to clients? That's clearly not implemented here (yet), but just want to confirm whether that is the rough plan. (Maybe we discussed this during the CDS session but I can't remember.)

There are protocol compatibility issues (noted below), but we can deal with that last, I think.

Thanks!
sage

Quoted 32 lines
---
 src/client/Client.cc        |  158 ++++++++++++++++++++++++++++++++++++++-----
 src/client/Inode.h          |    6 ++
 src/include/ceph_fs.h       |    9 +++
 src/mds/CInode.cc           |   22 ++++++
 src/mds/Capability.h        |    3 +
 src/mds/Locker.cc           |   48 +++++++++++++
 src/mds/mdstypes.cc         |    4 ++
 src/mds/mdstypes.h          |    3 +
 src/messages/MClientCaps.h  |    6 ++
 src/messages/MClientReply.h |    4 ++
 10 files changed, 246 insertions(+), 17 deletions(-)
src/client/Client.cc +5 -0
index bddfa0a..fe947be 100644
@@ -632,6 +632,11 @@ Inode * Client::add_update_inode(InodeStat *st, utime_t from, MetaSession *sessi
     in->layout = st->layout;
     in->ctime = st->ctime;
     in->max_size = st->max_size;  // right?
+
+    if (st->inline_version > in->inline_version) {
+      in->inline_version = st->inline_version;
+      in->inline_data = st->inline_data;
+    }
 
     update_inode_file_bits(in, st->truncate_seq, st->truncate_size, st->size,
 			   st->time_warp_seq, st->ctime, st->mtime, st->atime,
@@ -2321,6 +2326,17 @@ void Client::send_cap(Inode *in, MetaSession *session, Cap *cap,
     ::encode(in->xattrs, m->xattrbl);
     m->head.xattr_version = in->xattr_version;

src/client/Client.cc void Client::send_cap(Inode *in, MetaSession *session, Cap *cap, · line 2337

Quoted 10 lines
src/client/Client.cc +9 -0
   }
+
+  if ((flush & CEPH_CAP_FILE_WR) &&
+      (flush & CEPH_CAP_FILE_BUFFER)) {
+    if (in->inline_commit_data.length()) {
+      m->head.inline_version = 0;
+      m->inline_data = in->inline_commit_data;
+    } else {
+      m->head.inline_version = in->inline_version;
+      m->inline_data = in->inline_data;

It seems like if the inline data hasn't changed, we should be able to avoid sending the old data over the wire and just set the version. The MDS should be able to infer that there was no change from that, and/or from the dirty_caps not includeing WR.

Quoted 38 lines
src/client/Client.cc +16 -1
+    }
+  }
 
   m->head.layout = in->layout;
   m->head.size = in->size;
@@ -3550,6 +3566,13 @@ void Client::handle_cap_grant(MetaSession *session, Inode *in, Cap *cap, MClient
     ::decode(in->xattrs, p);
     in->xattr_version = m->head.xattr_version;
   }
+  if ((new_caps & CEPH_CAP_FILE_CACHE) &&
+      (m->get_inline_version() >= in->inline_version)) {
+    ldout(cct, 10) << " update inline version " << m->get_inline_version() << dendl;
+    in->inline_version = m->get_inline_version();
+    in->inline_data = m->inline_data;
+  }
+
   update_inode_file_bits(in, m->get_truncate_seq(), m->get_truncate_size(), m->get_size(),
 			 m->get_time_warp_seq(), m->get_ctime(), m->get_mtime(), m->get_atime(), issued);
 
@@ -5637,6 +5660,13 @@ int Client::_read(Fh *f, int64_t offset, uint64_t size, bufferlist *bl)
   Inode *in = f->inode;
 
   //bool lazy = f->mode == CEPH_FILE_MODE_LAZY;
+  if ((in->inline_version != CEPH_INLINE_DISABLED) &&
+      !(in->caps_issued(NULL) & CEPH_CAP_FILE_CACHE)) {
+    ldout(cct, 10) << " read inline from mds." << dendl;
+    int ret = _getattr(in, CEPH_STAT_CAP_INLINE, -1, -1, true);
+    if (ret < 0)
+      return ret;
+  }
 
   int have;
   int r = get_caps(in, CEPH_CAP_FILE_RD, CEPH_CAP_FILE_CACHE, &have, -1);
@@ -5650,15 +5680,31 @@ int Client::_read(Fh *f, int64_t offset, uint64_t size, bufferlist *bl)
     movepos = true;
   }
 
-  if (!conf->client_debug_force_sync_read &&

src/client/Client.cc int Client::_read(Fh *f, int64_t offset, uint64_t size, bufferlist *bl) · line 5691

Quoted 10 lines
src/client/Client.cc +9 -1
-      (cct->_conf->client_oc && (have & CEPH_CAP_FILE_CACHE))) {
+  unsigned int inlinesize = 0;
+  if (in->inline_version != CEPH_INLINE_DISABLED) {
+    if (offset < in->inline_data.length()) {
+      inlinesize = in->inline_data.length() - offset;
+      if (inlinesize > size)
+        inlinesize = size;
+      in->inline_data.copy(offset, inlinesize, *bl);
+    }
+  }

It might be simpler to support either all-inline or no-inline, and not a combination of some data inline and some data on the OSD. It's not clear to me what the value of that scenario is, and it complicates the implementation.

Quoted 195 lines
src/client/Client.cc +102 -15
+
+  if (size > inlinesize) {
+    bufferlist blread;
+    int64_t bloffset = offset + inlinesize;
+    uint64_t blsize = size - inlinesize;
+    if (!conf->client_debug_force_sync_read &&
+        (cct->_conf->client_oc && (have & CEPH_CAP_FILE_CACHE))) {
 
-    if (f->flags & O_RSYNC) {
-      _flush_range(in, offset, size);
+      if (f->flags & O_RSYNC) {
+        _flush_range(in, bloffset, blsize);
+      }
+      r = _read_async(f, bloffset, blsize, &blread);
+    } else {
+      r = _read_sync(f, bloffset, blsize, &blread);
     }
-    r = _read_async(f, offset, size, bl);
-  } else {
-    r = _read_sync(f, offset, size, bl);
+    bl->claim_append(blread);
   }
 
   // don't move pointer if the read failed
@@ -5935,22 +5981,91 @@ int Client::_write(Fh *f, int64_t offset, uint64_t size, const char *buf)
   // time it.
   utime_t start = ceph_clock_now(cct);
 
-  // copy into fresh buffer (since our write may be resub, async)
-  bufferptr bp;
-  if (size > 0) bp = buffer::copy(buf, size);
-  bufferlist bl;
-  bl.push_back( bp );
-
   utime_t lat;
   uint64_t totalwritten;
   uint64_t endoff = offset + size;
   int have;
-  int r = get_caps(in, CEPH_CAP_FILE_WR, CEPH_CAP_FILE_BUFFER, &have, endoff);
+  int want;
+  if (in->inline_version != CEPH_INLINE_DISABLED) {
+    want = 0;
+    if (offset < CEPH_INLINE_SIZE)
+      want |= CEPH_CAP_FILE_CACHE;
+    if (offset + size > CEPH_INLINE_SIZE)
+      want |= CEPH_CAP_FILE_BUFFER;
+  } else {
+    want = CEPH_CAP_FILE_BUFFER;
+  }
+  int r = get_caps(in, CEPH_CAP_FILE_WR, want, &have, endoff);
   if (r < 0)
     return r;
 
   ldout(cct, 10) << " snaprealm " << *in->snaprealm << dendl;
 
+  bufferlist inlinebl, osdbl;
+  if (size > 0) {
+    // copy into fresh buffer (since our write may be resub, async)
+    bufferptr bp(buf, size);
+    if ((in->inline_version != CEPH_INLINE_DISABLED) &&
+        (want & CEPH_CAP_FILE_CACHE)) {
+
+      if (want & CEPH_CAP_FILE_BUFFER) {
+        bufferptr inlinebp(bp, 0, CEPH_INLINE_SIZE - offset);
+        inlinebl.push_back(inlinebp);
+        bufferptr osdbp(bp, CEPH_INLINE_SIZE - offset, size + offset - CEPH_INLINE_SIZE);
+        osdbl.push_back(osdbp);
+      } else {
+        inlinebl.push_back(bp);
+      }
+
+      if (have & CEPH_CAP_FILE_CACHE) {
+        bufferlist bl;
+
+        uint32_t len = in->inline_data.length();
+        if (offset < len) {
+          bl.substr_of(in->inline_data, 0, offset);
+        } else {
+          bl.append(in->inline_data);
+          if (offset > len)
+            bl.append_zero(offset - len);
+        }
+        bl.append(inlinebl);
+        if (bl.length() < len)
+          in->inline_data.copy(bl.length(), len - bl.length(), bl);
+
+        if (in->inline_version >= CEPH_INLINE_MIGRATION) {
+          ldout(cct, 10) << " migrate data." << dendl;
+          bl.append(osdbl);
+          osdbl.claim(bl);
+        } else {
+          in->inline_data.claim(bl);
+        }
+      } else {
+        encode((uint32_t)offset, in->inline_commit_data);
+        encode(inlinebl, in->inline_commit_data);
+      }
+
+      if ((in->inline_version < CEPH_INLINE_MIGRATION) ||
+          !(have & CEPH_CAP_FILE_CACHE)) {
+        mark_caps_dirty(in, CEPH_CAP_FILE_WR | CEPH_CAP_FILE_BUFFER);
+        check_caps(in, true);
+      }
+
+      if (!(have & CEPH_CAP_FILE_CACHE)) {
+        in->inline_commit_data.clear();
+      }
+    } else {
+      osdbl.push_back(bp);
+    }
+  }
+
+  uint64_t osdsize = osdbl.length();
+  int64_t osdoffset = offset + size - osdsize;
+  if (osdoffset < 0)
+    osdoffset = 0;
+
+  if (!osdsize)
+    goto skip_osd;
+
   if (cct->_conf->client_oc && (have & CEPH_CAP_FILE_BUFFER)) {
     // do buffered write
     if (!in->oset.dirty_or_tx)
@@ -5960,7 +6075,7 @@ int Client::_write(Fh *f, int64_t offset, uint64_t size, const char *buf)
 
     // async, caching, non-blocking.
     r = objectcacher->file_write(&in->oset, &in->layout, in->snaprealm->get_snap_context(),
-			         offset, size, bl, ceph_clock_now(cct), 0,
+			         osdoffset, osdsize, osdbl, ceph_clock_now(cct), 0,
 			         client_lock);
 
     put_cap_ref(in, CEPH_CAP_FILE_BUFFER);
@@ -5972,7 +6087,7 @@ int Client::_write(Fh *f, int64_t offset, uint64_t size, const char *buf)
     // O_DSYNC == O_SYNC on linux < 2.6.33
     // O_SYNC = __O_SYNC | O_DSYNC on linux >= 2.6.33
     if ((f->flags & O_SYNC) || (f->flags & O_DSYNC)) {
-      _flush_range(in, offset, size);
+      _flush_range(in, osdoffset, osdsize);
     }
   } else {
     // simple, non-atomic sync write
@@ -5986,7 +6101,7 @@ int Client::_write(Fh *f, int64_t offset, uint64_t size, const char *buf)
     get_cap_ref(in, CEPH_CAP_FILE_BUFFER);  // released by onsafe callback
 
     r = filer->write_trunc(in->ino, &in->layout, in->snaprealm->get_snap_context(),
-			   offset, size, bl, ceph_clock_now(cct), 0,
+			   osdoffset, osdsize, osdbl, ceph_clock_now(cct), 0,
 			   in->truncate_size, in->truncate_seq,
 			   onfinish, onsafe);
     if (r < 0)
@@ -6001,6 +6116,15 @@ int Client::_write(Fh *f, int64_t offset, uint64_t size, const char *buf)
   }
 
   // if we get here, write was successful, update client metadata
+skip_osd:
+  if ((have & CEPH_CAP_FILE_CACHE) &&
+      (in->inline_version >= CEPH_INLINE_MIGRATION)) {
+    ldout(cct, 10) << " disable inline." << dendl;
+    in->inline_version = CEPH_INLINE_DISABLED;
+    in->inline_data.clear();
+    mark_caps_dirty(in, CEPH_CAP_FILE_WR | CEPH_CAP_FILE_BUFFER);
+    check_caps(in, true);
+  }
 
   // time
   lat = ceph_clock_now(cct);
src/client/Inode.h +6 -0
index b33c38e..455fc37 100644
@@ -111,6 +111,11 @@ class Inode {
   version_t version;           // auth only
   version_t xattr_version;
 
+  // inline data
+  bufferlist inline_data;
+  version_t  inline_version;
+  bufferlist inline_commit_data;
+
   bool is_symlink() const { return (mode & S_IFMT) == S_IFLNK; }
   bool is_dir()     const { return (mode & S_IFMT) == S_IFDIR; }
   bool is_file()    const { return (mode & S_IFMT) == S_IFREG; }
@@ -205,6 +210,7 @@ class Inode {
       rdev(0), mode(0), uid(0), gid(0), nlink(0),
       size(0), truncate_seq(1), truncate_size(-1),
       time_warp_seq(0), max_size(0), version(0), xattr_version(0),
+      inline_version(0),
       flags(0),
       dir_hashed(false), dir_replicated(false), auth_cap(NULL),
       dirty_caps(0), flushing_caps(0), flushing_cap_seq(0), shared_gen(0), cache_gen(0),
src/include/ceph_fs.h +0 -0
index 6c41d14..bd81687 100644

src/include/ceph_fs.h struct ceph_mds_reply_inode { · line 474

Quoted 4 lines
src/include/ceph_fs.h +1 -0
@@ -471,6 +471,7 @@ struct ceph_mds_reply_inode {
 	struct ceph_file_layout layout;
 	struct ceph_timespec ctime, mtime, atime;
 	__le32 time_warp_seq;
+	__le32 inline_version;

I would go with __le64 here.

More importantly, though, we need to make this change backward compatible, which means we can't modify ceph_mds_reply_indoe directly (at least not without keeping the old struct definition around too). This is probably a good opportunity to move from the struct-based message format definition to the encode/decode style (as we've recently done with MOSDOp[Reply]). (This will need to get fixed up before this can be merged, but let's get the rest of this implementation right first... so don't worry about it yet.)

src/include/ceph_fs.h struct ceph_filelock { · line 527

Quoted 9 lines
src/include/ceph_fs.h +2 -0
 	__le64 size, max_size, truncate_size;
 	__le32 truncate_seq;
 	__le32 mode, uid, gid;
@@ -522,6 +523,10 @@ struct ceph_filelock {
 
 int ceph_flags_to_mode(int flags);
 
+/* inline data state */
+#define CEPH_INLINE_DISABLED   ((__u32)-1)

again, __u64

Quoted 14 lines
src/include/ceph_fs.h +3 -0
+#define CEPH_INLINE_MIGRATION  (CEPH_INLINE_DISABLED >> 1)
+#define CEPH_INLINE_SIZE       (1 << 8)
 
 /* capability bits */
 #define CEPH_CAP_PIN         1  /* no specific capabilities beyond the pin */
@@ -580,6 +585,7 @@ int ceph_flags_to_mode(int flags);
 #define CEPH_STAT_CAP_MTIME    CEPH_CAP_FILE_SHARED
 #define CEPH_STAT_CAP_SIZE     CEPH_CAP_FILE_SHARED
 #define CEPH_STAT_CAP_ATIME    CEPH_CAP_FILE_SHARED  /* fixme */
+#define CEPH_STAT_CAP_INLINE   CEPH_CAP_FILE_SHARED
 #define CEPH_STAT_CAP_XATTR    CEPH_CAP_XATTR_SHARED
 #define CEPH_STAT_CAP_INODE_ALL (CEPH_CAP_PIN |			\
 				 CEPH_CAP_AUTH_SHARED |	\

src/include/ceph_fs.h struct ceph_mds_caps { · line 668

Quoted 6 lines
src/include/ceph_fs.h +3 -0
@@ -657,6 +663,9 @@ struct ceph_mds_caps {
 	struct ceph_timespec mtime, atime, ctime;
 	struct ceph_file_layout layout;
 	__le32 time_warp_seq;
+
+	/* ilnine data */
+	__le32 inline_version;

64

Quoted 252 lines
src/include/ceph_fs.h +0 -0
 } __attribute__ ((packed));
 
 /* cap release msg head */
src/mds/CInode.cc +22 -0
index 781ed72..3999078 100644
@@ -2706,6 +2706,17 @@ int CInode::encode_inodestat(bufferlist& bl, Session *session,
   e.rfiles = i->rstat.rfiles;
   e.rsubdirs = i->rstat.rsubdirs;
 
+  // inline data
+  bufferlist inline_data;
+  if (!cap || (cap->client_inline_version < i->inline_version)) {
+    e.inline_version = i->inline_version;
+    inline_data = i->inline_data;
+  }
+  if (cap && (cap->client_inline_version < i->inline_version)) {
+    cap->client_inline_version = i->inline_version;
+    cap->server_inline_version = i->inline_version;
+  }
+
   // auth
   i = pauth ? pi:oi;
   e.mode = i->mode;
@@ -2738,6 +2749,7 @@ int CInode::encode_inodestat(bufferlist& bl, Session *session,
     bytes += (sizeof(__u32) + sizeof(__u32)) * dirfragtree._splits.size();
     bytes += sizeof(__u32) + symlink.length();
     bytes += sizeof(__u32) + xbl.length();
+    bytes += sizeof(__u32) + inline_data.length();
     if (bytes > max_bytes)
       return -ENOSPC;
   }
@@ -2833,6 +2845,7 @@ int CInode::encode_inodestat(bufferlist& bl, Session *session,
     ::encode(i->dir_layout, bl);
   }
   ::encode(xbl, bl);
+  ::encode(inline_data, bl);
 
   return valid;
 }
@@ -2865,6 +2878,15 @@ void CInode::encode_cap_message(MClientCaps *m, Capability *cap)
   i->atime.encode_timeval(&m->head.atime);
   m->head.time_warp_seq = i->time_warp_seq;
 
+  if ((cap->pending() & CEPH_CAP_FILE_CACHE) &&
+      (i->inline_version > cap->client_inline_version)) {
+    dout(10) << " push updated inline data version " << i->inline_version << dendl;
+    m->head.inline_version = i->inline_version;
+    m->inline_data = i->inline_data;
+    cap->client_inline_version = i->inline_version;
+    cap->server_inline_version = i->inline_version;
+  }
+  
   // max_size is min of projected, actual.
   uint64_t oldms = oi->client_ranges.count(client) ? oi->client_ranges[client].range.last : 0;
   uint64_t newms = pi->client_ranges.count(client) ? pi->client_ranges[client].range.last : 0;
src/mds/Capability.h +3 -0
index 54d2312..aa8fbb9 100644
@@ -207,6 +207,8 @@ private:
 public:
   snapid_t client_follows;
   version_t client_xattr_version;
+  version_t client_inline_version;
+  version_t server_inline_version;
 
   xlist<Capability*>::item item_session_caps;
   xlist<Capability*>::item item_snaprealm_caps;
@@ -221,6 +223,7 @@ public:
     mseq(0),
     suppress(0), stale(false),
     client_follows(0), client_xattr_version(0),
+    client_inline_version(0), server_inline_version(0),
     item_session_caps(this), item_snaprealm_caps(this) {
     g_num_cap++;
     g_num_capa++;
src/mds/Locker.cc +48 -0
index c5ddb92..a45a4db 100644
@@ -2844,6 +2844,54 @@ bool Locker::_do_cap_update(CInode *in, Capability *cap,
 
   _update_cap_fields(in, dirty, m, pi);
 
+  if ((dirty & CEPH_CAP_FILE_WR) && 
+      (dirty & CEPH_CAP_FILE_BUFFER) && 
+      in->inode.is_file()) {
+    if (!m->get_inline_version()) {
+      bufferlist::iterator p = m->inline_data.begin();
+
+      uint32_t offset = 0;
+      bufferlist inlinebl;
+      if (!p.end())
+        decode(offset, p);
+      if (!p.end())
+        decode(inlinebl, p);
+
+      if (offset + inlinebl.length() > 0) {
+        bufferlist bl;
+
+        uint32_t len = pi->inline_data.length();
+        if (offset < len) {
+          bl.substr_of(pi->inline_data, 0, offset);
+        } else {
+          bl.append(pi->inline_data);
+          if (offset > len)
+            bl.append_zero(offset - len);
+        }
+        bl.append(inlinebl);
+        if (bl.length() < len)
+          pi->inline_data.copy(bl.length(), len - bl.length(), bl);
+
+        pi->inline_data.claim(bl);
+        pi->inline_version++;
+        if ((pi->size > CEPH_INLINE_SIZE) && (pi->inline_version < CEPH_INLINE_MIGRATION))
+          pi->inline_version = CEPH_INLINE_MIGRATION;
+      }
+    } else {
+      if (cap && 
+          (m->get_inline_version() >= cap->client_inline_version) &&
+          (cap->server_inline_version == pi->inline_version)) {
+        pi->inline_data = m->inline_data;
+        version_t newversion = pi->inline_version + 1;
+        if (m->get_inline_version() > newversion)
+          newversion = m->get_inline_version();
+        if ((pi->size > CEPH_INLINE_SIZE) && (newversion < CEPH_INLINE_MIGRATION))
+          newversion = CEPH_INLINE_MIGRATION;
+        pi->inline_version = cap->server_inline_version = newversion;
+      }
+    }
+  }
+
   if (change_max) {
     dout(7) << "  max_size " << old_max << " -> " << new_max
 	    << " for " << *in << dendl;
src/mds/mdstypes.cc +4 -0
index b1ce640..bb56122 100644
@@ -227,6 +227,8 @@ void inode_t::encode(bufferlist &bl) const
   ::encode(mtime, bl);
   ::encode(atime, bl);
   ::encode(time_warp_seq, bl);
+  ::encode(inline_version, bl);
+  ::encode(inline_data, bl);
   ::encode(client_ranges, bl);
 
   ::encode(dirstat, bl);
@@ -273,6 +275,8 @@ void inode_t::decode(bufferlist::iterator &p)
   ::decode(mtime, p);
   ::decode(atime, p);
   ::decode(time_warp_seq, p);
+  ::decode(inline_version, p);
+  ::decode(inline_data, p);
   if (struct_v >= 3) {
     ::decode(client_ranges, p);
   } else {
src/mds/mdstypes.h +3 -0
index aa9d165..7e8a69a 100644
@@ -334,6 +334,8 @@ struct inode_t {
   utime_t    mtime;   // file data modify time.
   utime_t    atime;   // file data access time.
   uint32_t   time_warp_seq;  // count of (potential) mtime/atime timewarps (i.e., utimes())
+  bufferlist inline_data;
+  version_t  inline_version;
 
   map<client_t,client_writeable_range_t> client_ranges;  // client(s) can write to these ranges
 
@@ -355,6 +357,7 @@ struct inode_t {
 	      size(0), truncate_seq(0), truncate_size(0), truncate_from(0),
 	      truncate_pending(0),
 	      time_warp_seq(0),
+	      inline_version(1),
 	      version(0), file_data_version(0), xattr_version(0), last_renamed_version(0) { 
     clear_layout();
     memset(&dir_layout, 0, sizeof(dir_layout));
src/messages/MClientCaps.h +6 -0
index 117f241..aab28d2 100644
@@ -29,6 +29,7 @@ class MClientCaps : public Message {
   bufferlist snapbl;
   bufferlist xattrbl;
   bufferlist flockbl;
+  bufferlist inline_data;
 
   int      get_caps() { return head.caps; }
   int      get_wanted() { return head.wanted; }
@@ -49,6 +50,7 @@ class MClientCaps : public Message {
   utime_t get_mtime() { return utime_t(head.mtime); }
   utime_t get_atime() { return utime_t(head.atime); }
   __u32 get_time_warp_seq() { return head.time_warp_seq; }
+  __u32 get_inline_version() { return head.inline_version; }
 
   ceph_file_layout& get_layout() { return head.layout; }
 
@@ -151,6 +153,8 @@ public:
     // conditionally decode flock metadata
     if (header.version >= 2)
       ::decode(flockbl, p);
+
+    ::decode(inline_data, p);
   }
   void encode_payload(uint64_t features) {
     head.snap_trace_len = snapbl.length();
@@ -166,6 +170,8 @@ public:
     } else {
       header.version = 1;  // old
     }
+
+    ::encode(inline_data, payload);
   }
 };
 
src/messages/MClientReply.h +4 -0
index 896245f..b15e843 100644
@@ -108,6 +108,8 @@ struct InodeStat {
   uint64_t truncate_size;
   utime_t ctime, mtime, atime;
   version_t time_warp_seq;
+  bufferlist inline_data;
+  version_t inline_version;
 
   frag_info_t dirstat;
   nest_info_t rstat;
@@ -144,6 +146,7 @@ struct InodeStat {
     mtime.decode_timeval(&e.mtime);
     atime.decode_timeval(&e.atime);
     time_warp_seq = e.time_warp_seq;
+    inline_version = e.inline_version;
     mode = e.mode;
     uid = e.uid;
     gid = e.gid;
@@ -174,6 +177,7 @@ struct InodeStat {
 
     xattr_version = e.xattr_version;
     ::decode(xattrbl, p);
+    ::decode(inline_data, p);
   }
 
   // see CInode::encode_inodestat for encoder.
Signature · 1 line
1.7.9.5
author
#2 lore raw

RFC 1/1 Ceph: Kernel client part of inline data support

In reply to Li Wang

This patch implements the kernel client part of inline data support, the algorithm is described below.

This is a preliminarly implementation based on Linux kernel 3.8.3.

State:
CEPH_INLINE_MIGRATION: The file size has exceeded the threshold of inline, but MDS has the newest inline data
CEPH_INLINE_DISABLED: The file is not inlined, and MDS does not have the inline data

Client:
Open, lookup, getattr, handle_cap_grant etc,
MDS send inline data together with inode metadata to client

Read side:

if (hold CEPH_CAP_FILE_CACHE capability) // ceph_readpage()/ceph_readpages()
if (state < CEPH_INLINE_MIGRATION)
copy inline data from inode buffer into page cache
else
if (state == CEPH_INLINE_MIGRATION)
read the data from the OSD
replace the head of the first page with the inline data from inode buffer
else // ceph_sync_read()
if (state != CEPH_INLINE_DISABLED)
send GETATTR message to MDS to fetch inline data into inode buffer copy the inline data from inode buffer to user buffer directly if (state == CEPH_INLINE_MIGRATION and pos+len>CEPH_INLINE_SIZE)
continue to read the remaning data from OSD to user buffer

Write side:

if (hold CEPH_CAP_FILE_CACHE capability)
if (state < CEPH_INLINE_MIGRATION) // ceph_write_end()
if (pos < CEPH_INLINE_SIZE)
if (pos + len > CEPH_INLINE_SIZE)
let state = CEPH_INLINE_DISABLED
else
let state = CEPH_INLINE_MIGRATION
else if (state == CEPH_INLINE_MIGRATION)
if (pos < CEPH_INLINE_SIZE)
let state = CEPH_INLINE_DISABLED;

if (state < CEPH_INLINE_MIGRATION) // ceph_writepage/ceph_writepages_start()
copy data from page cache into inode buffer
mark cap and inode dirty to send inode buffer to MDS
else
do the normal write to OSD
else // ceph_sync_write()
if (state != CEPH_INLINE_DISABLED)
if (pos < CEPH_INLINE_SIZE)
copy the written data fit into [pos, min(pos+len, CEPH_INLINE_SIZE)) from user buffer directly to inode buffer let dirty_data_only=true, record the write pos as well as length // leave MDS to merge
mark cap and inode dirty to send (maybe part of) written data to MDS
if (pos + len >= CEPH_INLINE_SIZE)
let state = CEPH_INLINE_MIGRATION
write the remaining data to OSD
else
do the normal write to OSD

---
 fs/ceph/addr.c               |  186 ++++++++++++++++++++++++++++++++++--------
 fs/ceph/caps.c               |   61 ++++++++++++--
 fs/ceph/file.c               |   90 +++++++++++++++++++-
 fs/ceph/inode.c              |   19 ++++-
 fs/ceph/mds_client.c         |   14 ++--
 fs/ceph/mds_client.h         |    2 +
 fs/ceph/super.h              |   14 ++++
 include/linux/ceph/ceph_fs.h |    4 +
 net/ceph/messenger.c         |    2 +-
 9 files changed, 342 insertions(+), 50 deletions(-)
fs/ceph/addr.c +151 -35
index 064d1a6..033396c 100644
@@ -204,6 +204,18 @@ static int readpage_nounlock(struct file *filp, struct page *page)
 
 	dout("readpage inode %p file %p page %p index %lu\n",
 	     inode, filp, page, page->index);
+
+	if (ci->i_inline_data.version < CEPH_INLINE_MIGRATION && ci->i_inline_data.length) {
+		void *virt = kmap(page);
+		memcpy(virt, ci->i_inline_data.data, ci->i_inline_data.length);
+		kunmap(page);
+		zero_user_segment(page, ci->i_inline_data.length, PAGE_CACHE_SIZE);
+		flush_dcache_page(page);
+		SetPageUptodate(page);
+		err = 0;
+		goto out;
+	}
+	
 	err = ceph_osdc_readpages(osdc, ceph_vino(inode), &ci->i_layout,
 				  (u64) page_offset(page), &len,
 				  ci->i_truncate_seq, ci->i_truncate_size,
@@ -217,6 +229,13 @@ static int readpage_nounlock(struct file *filp, struct page *page)
 		/* zero fill remainder of page */
 		zero_user_segment(page, err, PAGE_CACHE_SIZE);
 	}
+
+	if (ci->i_inline_data.version == CEPH_INLINE_MIGRATION && ci->i_inline_data.length) {
+		void *virt = kmap(page);
+		memcpy(virt, ci->i_inline_data.data, ci->i_inline_data.length);
+		kunmap(page);
+		flush_dcache_page(page);
+	}
 	SetPageUptodate(page);
 
 out:
@@ -252,6 +271,15 @@ static void finish_read(struct ceph_osd_request *req, struct ceph_msg *msg)
 	for (i = 0; i < req->r_num_pages; i++, bytes -= PAGE_CACHE_SIZE) {
 		struct page *page = req->r_pages[i];
 
+		struct ceph_inode_info *ci = ceph_inode(inode);
+		if (ci->i_inline_data.version == CEPH_INLINE_MIGRATION && page->index == 0) {
+			if (ci->i_inline_data.length) {
+				void *virt = kmap(page);
+				memcpy(virt, ci->i_inline_data.data, ci->i_inline_data.length);
+				kunmap(page);
+			}
+		}
+
 		if (bytes < (int)PAGE_CACHE_SIZE) {
 			/* zero (remainder of) page */
 			int s = bytes < 0 ? 0 : bytes;
@@ -372,9 +400,28 @@ static int ceph_readpages(struct file *file, struct address_space *mapping,
 {
 	struct inode *inode = file->f_dentry->d_inode;
 	struct ceph_fs_client *fsc = ceph_inode_to_client(inode);
+	struct ceph_inode_info *ci = ceph_inode(inode);
 	int rc = 0;
 	int max = 0;
 
+	if (ci->i_inline_data.version < CEPH_INLINE_MIGRATION) {
+		struct page *page = list_entry(page_list->prev, struct page, lru);
+		if (ci->i_inline_data.length) {
+			void *virt = kmap(page);
+			memcpy(virt, ci->i_inline_data.data, ci->i_inline_data.length);
+			kfree(tem);
+			kunmap(page);
+		}
+		zero_user_segment(page, ci->i_inline_data.length, PAGE_CACHE_SIZE);
+		flush_dcache_page(page);
+		SetPageUptodate(page);
+		list_del(&page->lru);		
+		add_to_page_cache_lru(page, &inode->i_data, page->index, GFP_NOFS);
+		unlock_page(page);
+		rc = 1;
+		goto out;
+	}
+
 	if (fsc->mount_options->rsize >= PAGE_CACHE_SIZE)
 		max = (fsc->mount_options->rsize + PAGE_CACHE_SIZE - 1)
 			>> PAGE_SHIFT;
@@ -488,12 +535,31 @@ static int writepage_nounlock(struct page *page, struct writeback_control *wbc)
 		set_bdi_congested(&fsc->backing_dev_info, BLK_RW_ASYNC);
 
 	set_page_writeback(page);
+	
+	if (ci->i_inline_data.version < CEPH_INLINE_MIGRATION) {
+			if (ci->i_inline_data.data == NULL)
+				ci->i_inline_data.data = kmalloc(CEPH_INLINE_SIZE, GFP_NOFS);
+			ci->i_inline_data.length = inode->i_size < CEPH_INLINE_SIZE?inode->i_size:CEPH_INLINE_SIZE;
+			char *virt = kmap(page);
+			memcpy(ci->i_inline_data.data, virt, ci->i_inline_data.length);
+			kunmap(page);
+			spin_lock(&ci->i_ceph_lock);
+			int dirty = __ceph_mark_dirty_caps(ci, CEPH_CAP_FILE_WR | CEPH_CAP_FILE_BUFFER);
+			spin_unlock(&ci->i_ceph_lock);
+			if (dirty)
+				__mark_inode_dirty(inode, dirty);
+			goto written;
+	}
+	
 	err = ceph_osdc_writepages(osdc, ceph_vino(inode),
 				   &ci->i_layout, snapc,
 				   page_off, len,
 				   ci->i_truncate_seq, ci->i_truncate_size,
 				   &inode->i_mtime,
 				   &page, 1, 0, 0, true);
+	
+	written:
+	
 	if (err < 0) {
 		dout("writepage setting page/mapping error %d %p\n", err, page);
 		SetPageError(page);
@@ -669,8 +735,9 @@ static int ceph_writepages_start(struct address_space *mapping,
 	unsigned wsize = 1 << inode->i_blkbits;
 	struct ceph_osd_request *req = NULL;
 	int do_sync;
-	u64 snap_size = 0;
-
+	u64 snap_size = 0;	
+	bool written = false;
+	
 	/*
 	 * Include a 'sync' in the OSD request if this is a data
 	 * integrity write (e.g., O_SYNC write or fsync()), or if our
@@ -744,7 +811,7 @@ retry:
 		struct ceph_osd_request_head *reqhead;
 		struct ceph_osd_op *op;
 		long writeback_stat;
-
+		
 		next = 0;
 		locked_pages = 0;
 		max_pages = max_pages_ever;
@@ -761,7 +828,8 @@ get_more_pages:
 		dout("pagevec_lookup_tag got %d\n", pvec_pages);
 		if (!pvec_pages && !locked_pages)
 			break;
-		for (i = 0; i < pvec_pages && locked_pages < max_pages; i++) {
+		for (i = 0; i < pvec_pages && locked_pages < max_pages; i++) {			
+			written = false;
 			page = pvec.pages[i];
 			dout("? %p idx %lu\n", page, page->index);
 			if (locked_pages == 0)
@@ -823,12 +891,38 @@ get_more_pages:
 				break;
 			}
 
+			if (ci->i_inline_data.version < CEPH_INLINE_MIGRATION && page->index == 0) {
+				if (ci->i_inline_data.data == NULL)
+					ci->i_inline_data.data = kmalloc(CEPH_INLINE_SIZE, GFP_NOFS);
+				char *virt = kmap(page);
+				ci->i_inline_data.length = inode->i_size < CEPH_INLINE_SIZE?inode->i_size:CEPH_INLINE_SIZE;
+				memcpy(ci->i_inline_data.data, virt, ci->i_inline_data.length);
+				kunmap(page);
+				spin_lock(&ci->i_ceph_lock);
+				int dirty = __ceph_mark_dirty_caps(ci, CEPH_CAP_FILE_WR | CEPH_CAP_FILE_BUFFER);
+				spin_unlock(&ci->i_ceph_lock);
+				if (dirty)
+					__mark_inode_dirty(inode, dirty);
+				ceph_put_snap_context(page_snap_context(page));
+				page->private = 0;
+				ClearPagePrivate(page);
+				SetPageUptodate(page);
+				unsigned issued = ceph_caps_issued(ci);
+				if ((issued & (CEPH_CAP_FILE_CACHE|CEPH_CAP_FILE_LAZYIO)) == 0)
+					generic_error_remove_page(inode->i_mapping, page);
+				unlock_page(page);				
+				ceph_put_wrbuffer_cap_refs(ci, 1, snapc);
+				written = true;
+				rc = 0;
+			}
+
 			/* ok */
 			if (locked_pages == 0) {
 				/* prepare async write request */
 				offset = (u64) page_offset(page);
 				len = wsize;
-				req = ceph_osdc_new_request(&fsc->client->osdc,
+				if (written == false) {
+					req = ceph_osdc_new_request(&fsc->client->osdc,
 					    &ci->i_layout,
 					    ceph_vino(inode),
 					    offset, &len,
@@ -840,35 +934,40 @@ get_more_pages:
 					    ci->i_truncate_size,
 					    &inode->i_mtime, true, 1, 0);
 
-				if (IS_ERR(req)) {
-					rc = PTR_ERR(req);
-					unlock_page(page);
-					break;
-				}
+					if (IS_ERR(req)) {
+						rc = PTR_ERR(req);
+						unlock_page(page);
+						break;
+					}
 
-				max_pages = req->r_num_pages;
+					max_pages = req->r_num_pages;
 
-				alloc_page_vec(fsc, req);
-				req->r_callback = writepages_finish;
-				req->r_inode = inode;
-			}
+					alloc_page_vec(fsc, req);
+					req->r_callback = writepages_finish;
+					req->r_inode = inode;
+					} else { 
+						max_pages = calc_pages_for(0, len);
+					}
+				}
 
 			/* note position of first page in pvec */
 			if (first < 0)
 				first = i;
 			dout("%p will write page %p idx %lu\n",
 			     inode, page, page->index);
+			
 
-			writeback_stat =
+			if (written == false) {
+				writeback_stat =
 			       atomic_long_inc_return(&fsc->writeback_count);
 			if (writeback_stat > CONGESTION_ON_THRESH(
 				    fsc->mount_options->congestion_kb)) {
 				set_bdi_congested(&fsc->backing_dev_info,
 						  BLK_RW_ASYNC);
 			}
-
-			set_page_writeback(page);
-			req->r_pages[locked_pages] = page;
+				set_page_writeback(page);
+				req->r_pages[locked_pages] = page;
+			}
 			locked_pages++;
 			next = page->index + 1;
 		}
@@ -897,31 +996,33 @@ get_more_pages:
 			pvec.nr -= i-first;
 		}
 
+		if (written == false) {
 		/* submit the write */
-		offset = req->r_pages[0]->index << PAGE_CACHE_SHIFT;
-		len = min((snap_size ? snap_size : i_size_read(inode)) - offset,
+			offset = req->r_pages[0]->index << PAGE_CACHE_SHIFT;
+			len = min((snap_size ? snap_size : i_size_read(inode)) - offset,
 			  (u64)locked_pages << PAGE_CACHE_SHIFT);
-		dout("writepages got %d pages at %llu~%llu\n",
+			dout("writepages got %d pages at %llu~%llu\n",
 		     locked_pages, offset, len);
 
-		/* revise final length, page count */
-		req->r_num_pages = locked_pages;
-		reqhead = req->r_request->front.iov_base;
-		op = (void *)(reqhead + 1);
-		op->extent.length = cpu_to_le64(len);
-		op->payload_len = cpu_to_le32(len);
-		req->r_request->hdr.data_len = cpu_to_le32(len);
-
-		rc = ceph_osdc_start_request(&fsc->client->osdc, req, true);
-		BUG_ON(rc);
+			/* revise final length, page count */
+			req->r_num_pages = locked_pages;
+			reqhead = req->r_request->front.iov_base;
+			op = (void *)(reqhead + 1);
+			op->extent.length = cpu_to_le64(len);
+			op->payload_len = cpu_to_le32(len);
+			req->r_request->hdr.data_len = cpu_to_le32(len);
+
+			rc = ceph_osdc_start_request(&fsc->client->osdc, req, true);
+			BUG_ON(rc);
+		}		
 		req = NULL;
-
+		
 		/* continue? */
 		index = next;
 		wbc->nr_to_write -= locked_pages;
 		if (wbc->nr_to_write <= 0)
-			done = 1;
-
+			done = 1;		
+		
 release_pvec_pages:
 		dout("pagevec_release on %d pages (%p)\n", (int)pvec.nr,
 		     pvec.nr ? pvec.pages[0] : NULL);
@@ -945,6 +1046,7 @@ release_pvec_pages:
 out:
 	if (req)
 		ceph_osdc_put_request(req);
+	
 	ceph_put_snap_context(snapc);
 	dout("writepages done, rc = %d\n", rc);
 	return rc;
@@ -1164,6 +1266,20 @@ static int ceph_write_end(struct file *file, struct address_space *mapping,
 	if (pos+copied > inode->i_size)
 		check_cap = ceph_inode_set_size(inode, pos+copied);
 
+	if (ci->i_inline_data.version < CEPH_INLINE_MIGRATION) {
+		if (pos >= CEPH_INLINE_SIZE) {
+			ci->i_inline_data.version = CEPH_INLINE_MIGRATION;
+		} else {
+			if (pos + copied > CEPH_INLINE_SIZE) {
+				ci->i_inline_data.version = CEPH_INLINE_DISABLED;
+			}
+		}
+	}
+	if (ci->i_inline_data.version == CEPH_INLINE_MIGRATION) {
+		if (pos < CEPH_INLINE_SIZE)
+				ci->i_inline_data.version = CEPH_INLINE_DISABLED;
+	}
+	
 	if (!PageUptodate(page))
 		SetPageUptodate(page);
 
fs/ceph/caps.c +54 -7

111 lines not on this page · raw message

fs/ceph/file.c +89 -1

120 lines not on this page · raw message

fs/ceph/inode.c +18 -1
index 2971eaa..0259be1 100644
@@ -376,6 +376,12 @@ struct inode *ceph_alloc_inode(struct super_block *sb)
 
 	INIT_WORK(&ci->i_vmtruncate_work, ceph_vmtruncate_work);
 
+	ci->i_inline_data.version = 1;
+	ci->i_inline_data.length = 0;
+	ci->i_inline_data.data = NULL;
+	ci->i_inline_data.dirty_data_only = false;
+	ci->i_inline_data.offset = 0;
+	
 	return &ci->vfs_inode;
 }
 
@@ -629,6 +635,17 @@ static int fill_inode(struct inode *inode,
 					  le32_to_cpu(info->truncate_seq),
 					  le64_to_cpu(info->truncate_size),
 					  le64_to_cpu(info->size));
+	
+	u32 inline_version = le32_to_cpu(info->inline_version);
+	if (inline_version) {
+		ci->i_inline_data.version = le32_to_cpu(info->inline_version);
+		ci->i_inline_data.length = le32_to_cpu(iinfo->inline_len);
+		if (ci->i_inline_data.length) {
+			ci->i_inline_data.data = kmalloc(CEPH_INLINE_SIZE, GFP_NOFS);
+			memcpy(ci->i_inline_data.data, iinfo->inline_data, ci->i_inline_data.length);			
+		}
+	}
+	
 	ceph_fill_file_time(inode, issued,
 			    le32_to_cpu(info->time_warp_seq),
 			    &ctime, &mtime, &atime);
@@ -944,7 +961,7 @@ int ceph_fill_trace(struct super_block *sb, struct ceph_mds_request *req,
 	struct ceph_fs_client *fsc = ceph_sb_to_client(sb);
 	int i = 0;
 	int err = 0;
-
+	
 	dout("fill_trace %p is_dentry %d is_target %d\n", req,
 	     rinfo->head->is_dentry, rinfo->head->is_target);
 
fs/ceph/mds_client.c +9 -5
index 9165eb8..ff96d51 100644
@@ -70,9 +70,9 @@ static int parse_reply_info_in(void **p, void *end,
 	*p += sizeof(struct ceph_mds_reply_inode) +
 		sizeof(*info->in->fragtree.splits) *
 		le32_to_cpu(info->in->fragtree.nsplits);
-
+	
 	ceph_decode_32_safe(p, end, info->symlink_len, bad);
-	ceph_decode_need(p, end, info->symlink_len, bad);
+	ceph_decode_need(p, end, info->symlink_len, bad);	
 	info->symlink = *p;
 	*p += info->symlink_len;
 
@@ -82,10 +82,14 @@ static int parse_reply_info_in(void **p, void *end,
 	else
 		memset(&info->dir_layout, 0, sizeof(info->dir_layout));
 
-	ceph_decode_32_safe(p, end, info->xattr_len, bad);
-	ceph_decode_need(p, end, info->xattr_len, bad);
+	ceph_decode_32_safe(p, end, info->xattr_len, bad);	
+	ceph_decode_need(p, end, info->xattr_len, bad);	
 	info->xattr_data = *p;
 	*p += info->xattr_len;
+	ceph_decode_32_safe(p, end, info->inline_len, bad);
+	ceph_decode_need(p, end, info->inline_len, bad);
+	info->inline_data = *p;
+	*p += info->inline_len;
 	return 0;
 bad:
 	return err;
@@ -273,7 +277,7 @@ static int parse_reply_info(struct ceph_msg *msg,
 	ceph_decode_32_safe(&p, end, len, bad);
 	if (len > 0) {
 		ceph_decode_need(&p, end, len, bad);
-		err = parse_reply_info_extra(&p, p+len, info, features);
+		err = parse_reply_info_extra(&p, p+len, info, features);		
 		if (err < 0)
 			goto out_bad;
 	}
fs/ceph/mds_client.h +2 -0
index dd26846..846759b 100644
@@ -41,6 +41,8 @@ struct ceph_mds_reply_info_in {
 	char *symlink;
 	u32 xattr_len;
 	char *xattr_data;
+	u32 inline_len;
+	char *inline_data;
 };
 
 /*
fs/ceph/super.h +14 -0
index 66ebe72..cfb5ad6 100644
@@ -245,6 +245,18 @@ struct ceph_inode_xattrs_info {
 	u64 version, index_version;
 };
 
+#define CEPH_INLINE_SIZE       (1 << 8)
+#define CEPH_INLINE_DISABLED   ((__u32)-1)
+#define CEPH_INLINE_MIGRATION  (CEPH_INLINE_DISABLED >> 1)
+
+struct ceph_inline_data_info {
+	u32 version;
+	u32 length;
+	char *data;
+	bool dirty_data_only;
+	u32 offset;
+};
+
 /*
  * Ceph inode.
  */
@@ -331,6 +343,8 @@ struct ceph_inode_info {
 
 	struct work_struct i_vmtruncate_work;
 
+	struct ceph_inline_data_info i_inline_data;
+
 	struct inode vfs_inode; /* at end */
 };
 
include/linux/ceph/ceph_fs.h +4 -0
index cf6f4d9..6554d77 100644
@@ -457,6 +457,7 @@ struct ceph_mds_reply_inode {
 	struct ceph_file_layout layout;
 	struct ceph_timespec ctime, mtime, atime;
 	__le32 time_warp_seq;
+	__le32 inline_version;
 	__le64 size, max_size, truncate_size;
 	__le32 truncate_seq;
 	__le32 mode, uid, gid;
@@ -563,6 +564,7 @@ int ceph_flags_to_mode(int flags);
 #define CEPH_STAT_CAP_MTIME    CEPH_CAP_FILE_SHARED
 #define CEPH_STAT_CAP_SIZE     CEPH_CAP_FILE_SHARED
 #define CEPH_STAT_CAP_ATIME    CEPH_CAP_FILE_SHARED  /* fixme */
+#define CEPH_STAT_CAP_INLINE   CEPH_CAP_FILE_SHARED
 #define CEPH_STAT_CAP_XATTR    CEPH_CAP_XATTR_SHARED
 #define CEPH_STAT_CAP_INODE_ALL (CEPH_CAP_PIN |			\
 				 CEPH_CAP_AUTH_SHARED |	\
@@ -640,6 +642,8 @@ struct ceph_mds_caps {
 	struct ceph_timespec mtime, atime, ctime;
 	struct ceph_file_layout layout;
 	__le32 time_warp_seq;
+
+	__le32 inline_version;
 } __attribute__ ((packed));
 
 /* cap release msg head */
net/ceph/messenger.c +1 -1
index 5ccf87e..a0e836d 100644
@@ -1914,7 +1914,7 @@ static int read_partial_message(struct ceph_connection *con)
 	}
 
 	/* (page) data */
-	while (con->in_msg_pos.data_pos < data_len) {
+    	while (con->in_msg_pos.data_pos < data_len) {	
 		if (m->pages) {
 			ret = read_partial_message_pages(con, m->pages,
 						 data_len, do_datacrc);
Signature · 1 line
1.7.9.5