DAOS-14073 dfuse: Move writeback caching from kernel to dfuse.

src/client/dfuse/dfuse_fuseops.c

@@ -53,54 +53,48 @@ dfuse_show_flags(void *handle, unsigned int in)
 		DFUSE_TRA_WARNING(handle, "Unknown flags %#x", in);
 }
 
-/* Called on filesystem init.  It has the ability to both observe configuration
- * options, but also to modify them.  As we do not use the FUSE command line
- * parsing this is where we apply tunables.
+/* Called on filesystem init.  It has the ability to both observe configuration options, but also to
+ * modify them.  As we do not use the FUSE command line parsing this is where we apply tunables.
  */
 static void
 dfuse_fuse_init(void *arg, struct fuse_conn_info *conn)
 {
-	struct dfuse_info *fs_handle = arg;
+	struct dfuse_info *dfuse_info = arg;
 
-	DFUSE_TRA_INFO(fs_handle, "Fuse configuration");
+	DFUSE_TRA_INFO(dfuse_info, "Fuse configuration");
 
-	DFUSE_TRA_INFO(fs_handle, "Proto %d %d", conn->proto_major, conn->proto_minor);
+	DFUSE_TRA_INFO(dfuse_info, "Proto %d %d", conn->proto_major, conn->proto_minor);
 
 	/* These are requests dfuse makes to the kernel, but are then capped by the kernel itself,
-	 * for max_read zero means "as large as possible" which is what we want, but then dfuse
-	 * does not know how large to pre-allocate any buffers.
+	 * for max_read zero means "as large as possible" which is what we want, but then dfuse does
+	 * not know how large to pre-allocate any buffers.
 	 */
-	DFUSE_TRA_INFO(fs_handle, "max read %#x", conn->max_read);
-	DFUSE_TRA_INFO(fs_handle, "max write %#x", conn->max_write);
-	DFUSE_TRA_INFO(fs_handle, "readahead %#x", conn->max_readahead);
+	DFUSE_TRA_INFO(dfuse_info, "max read %#x", conn->max_read);
+	DFUSE_TRA_INFO(dfuse_info, "max write %#x", conn->max_write);
+	DFUSE_TRA_INFO(dfuse_info, "readahead %#x", conn->max_readahead);
 
 #if HAVE_CACHE_READDIR
-	DFUSE_TRA_INFO(fs_handle, "kernel readdir cache support compiled in");
+	DFUSE_TRA_INFO(dfuse_info, "kernel readdir cache support compiled in");
 #else
-	DFUSE_TRA_INFO(fs_handle, "no support for kernel readdir cache available");
+	DFUSE_TRA_INFO(dfuse_info, "no support for kernel readdir cache available");
 #endif
 
-	DFUSE_TRA_INFO(fs_handle, "Capability supported by kernel %#x", conn->capable);
+	DFUSE_TRA_INFO(dfuse_info, "Capability supported by kernel %#x", conn->capable);
 
-	dfuse_show_flags(fs_handle, conn->capable);
+	dfuse_show_flags(dfuse_info, conn->capable);
 
-	DFUSE_TRA_INFO(fs_handle, "Capability requested %#x", conn->want);
+	DFUSE_TRA_INFO(dfuse_info, "Capability requested %#x", conn->want);
 
 	conn->want |= FUSE_CAP_READDIRPLUS;
 	conn->want |= FUSE_CAP_READDIRPLUS_AUTO;
-
-	conn->time_gran = 1;
-
-	if (fs_handle->di_wb_cache)
-		conn->want |= FUSE_CAP_WRITEBACK_CACHE;
-
-	dfuse_show_flags(fs_handle, conn->want);
-
+	conn->time_gran            = 1;
 	conn->max_background       = 16;
 	conn->congestion_threshold = 8;
 
-	DFUSE_TRA_INFO(fs_handle, "max_background %d", conn->max_background);
-	DFUSE_TRA_INFO(fs_handle, "congestion_threshold %d", conn->congestion_threshold);
+	dfuse_show_flags(dfuse_info, conn->want);
+
+	DFUSE_TRA_INFO(dfuse_info, "max_background %d", conn->max_background);
+	DFUSE_TRA_INFO(dfuse_info, "congestion_threshold %d", conn->congestion_threshold);
 }
 
 void

src/client/dfuse/ops/write.c

@@ -10,10 +10,12 @@
 static void
 dfuse_cb_write_complete(struct dfuse_event *ev)
 {
-	if (ev->de_ev.ev_error == 0)
-		DFUSE_REPLY_WRITE(ev->de_oh, ev->de_req, ev->de_len);
-	else
-		DFUSE_REPLY_ERR_RAW(ev->de_oh, ev->de_req, ev->de_ev.ev_error);
+	if (ev->de_req) {
+		if (ev->de_ev.ev_error == 0)
+			DFUSE_REPLY_WRITE(ev->de_oh, ev->de_req, ev->de_len);
+		else
+			DFUSE_REPLY_ERR_RAW(ev->de_oh, ev->de_req, ev->de_ev.ev_error);
+	}
 	daos_event_fini(&ev->de_ev);
 	d_slab_release(ev->de_eqt->de_write_slab, ev);
 }
@@ -22,24 +24,27 @@ void
 dfuse_cb_write(fuse_req_t req, fuse_ino_t ino, struct fuse_bufvec *bufv, off_t position,
 	       struct fuse_file_info *fi)
 {
-	struct dfuse_obj_hdl  *oh         = (struct dfuse_obj_hdl *)fi->fh;
-	struct dfuse_info     *dfuse_info = fuse_req_userdata(req);
-	const struct fuse_ctx *fc         = fuse_req_ctx(req);
-	size_t                 len        = fuse_buf_size(bufv);
-	struct fuse_bufvec     ibuf       = FUSE_BUFVEC_INIT(len);
-	struct dfuse_eq       *eqt;
-	int                    rc;
-	struct dfuse_event    *ev;
-	uint64_t               eqt_idx;
+	struct dfuse_obj_hdl *oh         = (struct dfuse_obj_hdl *)fi->fh;
+	struct dfuse_info    *dfuse_info = fuse_req_userdata(req);
+	size_t                len        = fuse_buf_size(bufv);
+	struct fuse_bufvec    ibuf       = FUSE_BUFVEC_INIT(len);
+	struct dfuse_eq      *eqt;
+	int                   rc;
+	struct dfuse_event   *ev;
+	uint64_t              eqt_idx;
+	bool                  wb_cache = false;
 
 	oh->doh_linear_read = false;
 
 	eqt_idx = atomic_fetch_add_relaxed(&dfuse_info->di_eqt_idx, 1);
 
 	eqt = &dfuse_info->di_eqt[eqt_idx % dfuse_info->di_eq_count];
 
-	DFUSE_TRA_DEBUG(oh, "%#zx-%#zx requested flags %#x pid=%d", position, position + len - 1,
-			bufv->buf[0].flags, fc->pid);
+	if (oh->doh_ie->ie_dfs->dfc_data_timeout != 0 && dfuse_info->di_wb_cache)
+		wb_cache = true;
+
+	DFUSE_TRA_DEBUG(oh, "%#zx-%#zx requested flags %#x", position, position + len - 1,
+			bufv->buf[0].flags);
 
 	/* Evict the metadata cache here so the lookup doesn't return stale size/time info */
 	if (atomic_fetch_add_relaxed(&oh->doh_write_count, 1) == 0) {
@@ -64,7 +69,10 @@ dfuse_cb_write(fuse_req_t req, fuse_ino_t ino, struct fuse_bufvec *bufv, off_t p
 
 	ev->de_oh          = oh;
 	ev->de_iov.iov_len = len;
-	ev->de_req         = req;
+	if (wb_cache)
+		ev->de_req = 0;
+	else
+		ev->de_req = req;
 	ev->de_len         = len;
 	ev->de_complete_cb = dfuse_cb_write_complete;
 
@@ -91,6 +99,9 @@ dfuse_cb_write(fuse_req_t req, fuse_ino_t ino, struct fuse_bufvec *bufv, off_t p
 	if (rc != 0)
 		D_GOTO(err, rc);
 
+	if (wb_cache)
+		DFUSE_REPLY_WRITE(oh, req, len);
+
 	/* Send a message to the async thread to wake it up and poll for events */
 	sem_post(&eqt->de_sem);