DAOS-13216 dfuse: Add a pre-read feature for non-cached files.

src/client/dfuse/dfuse.h

@@ -89,15 +89,59 @@ dfuse_launch_fuse(struct dfuse_info *dfuse_info, struct fuse_args *args);
 
 struct dfuse_inode_entry;
 
+/* Preread.
+ *
+ * DFuse can start a pre-read of the file on open, then when reads do occur they can happen directly
+ * from the buffer. For 'linear reads' of a file this means that the read can be triggered sooner
+ * and performed as one dfs request. Make use of the pre-read code to only use this for trivial
+ * reads, if a file is not read linearly or it's written to then back off to the regular behavior,
+ * which will likely use the kernel cache.
+ *
+ * Pre-read is enabled when:
+ * Caching is enabled
+ * The file is not cached
+ * The file is small enough to fit in one buffer (1mb)
+ * The previous file from the same directory was read linearly.
+ * Similar to the READDIR_PLUS_AUTO logic this feature is enabled bassed on the I/O pattern of the
+ * most recent access to the parent directory, general I/O workloads or interception library use are
+ * unlikely to trigger this code however something that is reading the entire contents of a
+ * directory tree should.
+ *
+ * This works by creating a new descriptor which is pointed to by the open handle, on open dfuse
+ * decides if it will use pre-read and if so allocate a new descriptor, add it to the open handle
+ * and then once it's replied to the open immediately issue a read. The new descriptor includes a
+ * lock which is locked by open before it replies to the kernel request and unlocked by the dfs read
+ * callback. Read requests then take the lock to ensure the dfs read is complete and reply directly
+ * with the data in the buffer.
+ *
+ * This works up to the buffer size, the pre-read tries to read the expected file size is smaller
+ * then dfuse will detect this and back off to regular read, however it will not detect if the file
+ * has grown in size.
+ *
+ * A dfuse_event is hung off this new descriptor and these come from the same pool as regular reads,
+ * this buffer is kept as long as it's needed but released as soon as possible, either on error or
+ * when EOF is returned to the kernel. If it's still present on release then it's freed then.
+ */
+struct dfuse_read_ahead {
+ pthread_mutex_t dra_lock;
+ struct dfuse_event *dra_ev;
+ int dra_rc;
+};
+
 /** what is returned as the handle for fuse fuse_file_info on create/open/opendir */
 struct dfuse_obj_hdl {
  /** pointer to dfs_t */
  dfs_t *doh_dfs;
  /** the DFS object handle. Not created for directories. */
  dfs_obj_t *doh_obj;
+
+ struct dfuse_read_ahead *doh_readahead;
+
  /** the inode entry for the file */
  struct dfuse_inode_entry *doh_ie;
 
+ struct dfuse_inode_entry *doh_parent_dir;
+
  /** readdir handle. */
  struct dfuse_readdir_hdl *doh_rd;
 
@@ -335,9 +379,11 @@ struct dfuse_event {
  struct dfuse_inode_entry *de_ie;
  };
  off_t de_req_position; /**< The file position requested by fuse */
- size_t de_req_len;
+ union {
+ size_t de_req_len;
+ size_t de_readahead_len;
+ };
  void (*de_complete_cb)(struct dfuse_event *ev);
-
  struct stat de_attr;
 };
 
@@ -680,6 +726,8 @@ struct fuse_lowlevel_ops dfuse_ops;
 #define DFUSE_REPLY_ENTRY(inode, req, entry) \
  do { \
  int __rc; \
+ DFUSE_TRA_DEBUG(inode, "Returning entry inode %#lx mode %#o size %#zx", \
+ (entry).attr.st_ino, (entry).attr.st_mode, (entry).attr.st_size); \
  if ((entry).attr_timeout > 0) { \
  (inode)->ie_stat = (entry).attr; \
  dfuse_mcache_set_time(inode); \
@@ -793,6 +841,13 @@ struct dfuse_inode_entry {
 
  /** File has been unlinked from daos */
  bool ie_unlinked;
+
+ /** Last file closed in this directory was read linearly. Directories only.
+ *
+ * Set on close() of a file in the directory to the value of linear_read from the fh.
+ * Checked on open of a file to determine if pre-caching is used.
+ */
+ ATOMIC bool ie_linear_read;
 };
 
 static inline struct dfuse_inode_entry *
@@ -847,21 +902,21 @@ dfuse_cache_evict_dir(struct dfuse_info *dfuse_info, struct dfuse_inode_entry *i
 void
 dfuse_mcache_set_time(struct dfuse_inode_entry *ie);
 
-/* Set the cache as invalid */
+/* Set the metadata cache as invalid */
 void
 dfuse_mcache_evict(struct dfuse_inode_entry *ie);
 
-/* Check the cache setting against a given timeout, and return time left */
+/* Check the metadata cache setting against a given timeout, and return time left */
 bool
 dfuse_mcache_get_valid(struct dfuse_inode_entry *ie, double max_age, double *timeout);
 
 /* Data caching functions */
 
-/* Mark the cache as up-to-date from now */
+/* Mark the data cache as up-to-date from now */
 void
 dfuse_dcache_set_time(struct dfuse_inode_entry *ie);
 
-/* Set the cache as invalid */
+/* Set the data cache as invalid */
 void
 dfuse_dcache_evict(struct dfuse_inode_entry *ie);
 
@@ -873,6 +928,9 @@ dfuse_cache_evict(struct dfuse_inode_entry *ie);
 bool
 dfuse_dcache_get_valid(struct dfuse_inode_entry *ie, double max_age);
 
+void
+dfuse_pre_read(struct dfuse_info *dfuse_info, struct dfuse_obj_hdl *oh);
+
 int
 check_for_uns_ep(struct dfuse_info *dfuse_info, struct dfuse_inode_entry *ie, char *attr,
  daos_size_t len);

src/client/dfuse/dfuse_core.c

@@ -1171,7 +1171,7 @@ dfuse_read_event_reset(void *arg)
  int rc;
 
  if (ev->de_iov.iov_buf == NULL) {
- D_ALLOC(ev->de_iov.iov_buf, DFUSE_MAX_READ);
+ D_ALLOC_NZ(ev->de_iov.iov_buf, DFUSE_MAX_READ);
  if (ev->de_iov.iov_buf == NULL)
  return false;
 
@@ -1195,7 +1195,7 @@ dfuse_write_event_reset(void *arg)
  int rc;
 
  if (ev->de_iov.iov_buf == NULL) {
- D_ALLOC(ev->de_iov.iov_buf, DFUSE_MAX_READ);
+ D_ALLOC_NZ(ev->de_iov.iov_buf, DFUSE_MAX_READ);
  if (ev->de_iov.iov_buf == NULL)
  return false;
 

src/client/dfuse/ops/create.c

@@ -111,6 +111,8 @@ dfuse_cb_create(fuse_req_t req, struct dfuse_inode_entry *parent, const char *na
 
  DFUSE_TRA_DEBUG(parent, "Parent:%#lx " DF_DE, parent->ie_stat.st_ino, DP_DE(name));
 
+ atomic_store_relaxed(&parent->ie_linear_read, false);
+
  /* O_LARGEFILE should always be set on 64 bit systems, and in fact is
  * defined to 0 so IOF defines LARGEFILE to the value that O_LARGEFILE
  * would otherwise be using and check that is set.

src/client/dfuse/ops/open.c

@@ -15,6 +15,7 @@ dfuse_cb_open(fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi)
  struct dfuse_obj_hdl *oh;
  struct fuse_file_info fi_out = {0};
  int rc;
+ bool prefetch = false;
 
  ie = dfuse_inode_lookup(dfuse_info, ino);
  if (!ie) {
@@ -29,6 +30,7 @@ dfuse_cb_open(fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi)
  DFUSE_TRA_UP(oh, ie, "open handle");
 
  dfuse_open_handle_init(dfuse_info, oh, ie);
+ oh->doh_parent_dir = dfuse_inode_lookup(dfuse_info, ie->ie_parent);
 
  /* Upgrade fd permissions from O_WRONLY to O_RDWR if wb caching is
  * enabled so the kernel can do read-modify-write
@@ -52,10 +54,16 @@ dfuse_cb_open(fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi)
  if (fi->flags & O_DIRECT)
  fi_out.direct_io = 1;
 
- if (atomic_load_relaxed(&ie->ie_open_count) > 0) {
- fi_out.keep_cache = 1;
- } else if (dfuse_dcache_get_valid(ie, ie->ie_dfs->dfc_data_timeout)) {
+ /* If the file is already open or (potentially) in cache then allow any existing
+ * kernel cache to be used. If not then use pre-read.
+ * This should mean that pre-read is only used on the first read, and on files
+ * which pre-existed in the container.
+ */
+ if (atomic_load_relaxed(&ie->ie_open_count) > 0 ||
+ dfuse_dcache_get_valid(ie, ie->ie_dfs->dfc_data_timeout)) {
  fi_out.keep_cache = 1;
+ } else {
+ prefetch = true;
  }
  } else {
  fi_out.direct_io = 1;
@@ -84,9 +92,23 @@ dfuse_cb_open(fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi)
 
  atomic_fetch_add_relaxed(&ie->ie_open_count, 1);
 
+ /* Enable this for files up to the max read size. */
+ if (prefetch && oh->doh_parent_dir &&
+ atomic_load_relaxed(&oh->doh_parent_dir->ie_linear_read) && ie->ie_stat.st_size > 0 &&
+ ie->ie_stat.st_size <= DFUSE_MAX_READ) {
+ D_ALLOC_PTR(oh->doh_readahead);
+ if (oh->doh_readahead) {
+ D_MUTEX_INIT(&oh->doh_readahead->dra_lock, 0);
+ D_MUTEX_LOCK(&oh->doh_readahead->dra_lock);
+ }
+ }
+
  dfuse_inode_decref(dfuse_info, ie);
  DFUSE_REPLY_OPEN(oh, req, &fi_out);
 
+ if (oh->doh_readahead)
+ dfuse_pre_read(dfuse_info, oh);
+
  return;
 err:
  dfuse_inode_decref(dfuse_info, ie);
@@ -108,6 +130,26 @@ dfuse_cb_release(fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi)
 
  DFUSE_TRA_DEBUG(oh, "Closing %d", oh->doh_caching);
 
+ if (oh->doh_readahead) {
+ struct dfuse_event *ev;
+
+ /* Grab this lock first to ensure that the read cb has been completed. The
+ * callback might register an error and release ev so do not read it's value
+ * until after this has completed.
+ */
+ D_MUTEX_LOCK(&oh->doh_readahead->dra_lock);
+ D_MUTEX_UNLOCK(&oh->doh_readahead->dra_lock);
+
+ ev = oh->doh_readahead->dra_ev;
+
+ D_MUTEX_DESTROY(&oh->doh_readahead->dra_lock);
+ if (ev) {
+ daos_event_fini(&ev->de_ev);
+ d_slab_release(ev->de_eqt->de_read_slab, ev);
+ }
+ D_FREE(oh->doh_readahead);
+ }
+
  /* If the file was read from then set the data cache time for future use, however if the
  * file was written to then evict the metadata cache.
  * The problem here is that if the file was written to then the contents will be in the
@@ -121,8 +163,9 @@ dfuse_cb_release(fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi)
  if (atomic_load_relaxed(&oh->doh_write_count) != 0) {
  if (oh->doh_caching) {
  if (il_calls == 0) {
- DFUSE_TRA_DEBUG(oh, "Evicting metadata cache");
+ DFUSE_TRA_DEBUG(oh, "Evicting metadata cache, setting data cache");
  dfuse_mcache_evict(oh->doh_ie);
+ dfuse_dcache_set_time(oh->doh_ie);
  } else {
  DFUSE_TRA_DEBUG(oh, "Evicting cache");
  dfuse_cache_evict(oh->doh_ie);
@@ -151,7 +194,18 @@ dfuse_cb_release(fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi)
  DFUSE_REPLY_ZERO(oh, req);
  else
  DFUSE_REPLY_ERR_RAW(oh, req, rc);
+ if (oh->doh_parent_dir) {
+ bool use_linear_read = false;
 
+ if (oh->doh_linear_read && oh->doh_linear_read_eof)
+ use_linear_read = true;
+
+ DFUSE_TRA_DEBUG(oh->doh_parent_dir, "Setting linear_read to %d", use_linear_read);
+
+ atomic_store_relaxed(&oh->doh_parent_dir->ie_linear_read, use_linear_read);
+
+ dfuse_inode_decref(dfuse_info, oh->doh_parent_dir);
+ }
  if (oh->doh_evict_on_close) {
  rc = fuse_lowlevel_notify_inval_entry(dfuse_info->di_session, oh->doh_ie->ie_parent,
  oh->doh_ie->ie_name,