When an anonymous fd is closed by user daemon, if there is a new read
request for this file comes up, the anonymous fd should be re-opened
to handle that read request rather than fail it directly.
1. Introduce reopening state for objects that are closed but have
inflight/subsequent read requests.
2. No longer flush READ requests but only CLOSE requests when anonymous
fd is closed.
3. Enqueue the reopen work to workqueue, thus user daemon could get rid
of daemon_read context and handle that request smoothly. Otherwise,
the user daemon will send a reopen request and wait for itself to
process the request.
Signed-off-by: Jia Zhu <zhujia...@bytedance.com>
Reviewed-by: Xin Yin <yinxi...@bytedance.com>
---
fs/cachefiles/internal.h | 3 ++
fs/cachefiles/ondemand.c | 99 ++++++++++++++++++++++++++++------------
2 files changed, 73 insertions(+), 29 deletions(-)
diff --git a/fs/cachefiles/internal.h b/fs/cachefiles/internal.h
index f6cc9a89b6d4..a9f45972945d 100644
--- a/fs/cachefiles/internal.h
+++ b/fs/cachefiles/internal.h
@@ -48,9 +48,11 @@ struct cachefiles_volume {
enum cachefiles_object_state {
CACHEFILES_ONDEMAND_OBJSTATE_close, /* Anonymous fd closed by daemon or
initial state */
CACHEFILES_ONDEMAND_OBJSTATE_open, /* Anonymous fd associated with
object is available */
+ CACHEFILES_ONDEMAND_OBJSTATE_reopening, /* Object that was closed and
is being reopened. */
};
struct cachefiles_ondemand_info {
+ struct work_struct work;
int ondemand_id;
enum cachefiles_object_state state;
struct cachefiles_object *object;
@@ -337,6 +339,7 @@ cachefiles_ondemand_set_object_##_state(struct
cachefiles_object *object) \
CACHEFILES_OBJECT_STATE_FUNCS(open);
CACHEFILES_OBJECT_STATE_FUNCS(close);
+CACHEFILES_OBJECT_STATE_FUNCS(reopening);
#else
static inline ssize_t cachefiles_ondemand_daemon_read(struct cachefiles_cache
*cache,
char __user *_buffer, size_t buflen)
diff --git a/fs/cachefiles/ondemand.c b/fs/cachefiles/ondemand.c
index 54581d59847a..69bf5446cc9c 100644
--- a/fs/cachefiles/ondemand.c
+++ b/fs/cachefiles/ondemand.c
@@ -18,14 +18,10 @@ static int cachefiles_ondemand_fd_release(struct inode
*inode,
info->ondemand_id = CACHEFILES_ONDEMAND_ID_CLOSED;
cachefiles_ondemand_set_object_close(object);
- /*
- * Flush all pending READ requests since their completion depends on
- * anon_fd.
- */
- xas_for_each(&xas, req, ULONG_MAX) {
+ /* Only flush CACHEFILES_REQ_NEW marked req to avoid race with
daemon_read */
+ xas_for_each_marked(&xas, req, ULONG_MAX, CACHEFILES_REQ_NEW) {
if (req->msg.object_id == object_id &&
- req->msg.opcode == CACHEFILES_OP_READ) {
- req->error = -EIO;
+ req->msg.opcode == CACHEFILES_OP_CLOSE) {
complete(&req->done);
xas_store(&xas, NULL);
}
@@ -179,6 +175,7 @@ int cachefiles_ondemand_copen(struct cachefiles_cache
*cache, char *args)
trace_cachefiles_ondemand_copen(req->object, id, size);
cachefiles_ondemand_set_object_open(req->object);
+ wake_up_all(&cache->daemon_pollwq);
out:
complete(&req->done);
@@ -238,6 +235,36 @@ static int cachefiles_ondemand_get_fd(struct
cachefiles_req *req)
return ret;
}
+static void ondemand_object_worker(struct work_struct *work)
+{
+ struct cachefiles_object *object =
+ ((struct cachefiles_ondemand_info *)work)->object;
+
+ cachefiles_ondemand_init_object(object);
+}
+
+/*
+ * Reopen the closed object with associated read request.
+ * Skip read requests whose related object are reopening.
+ */
+static bool cachefiles_ondemand_skip_req(struct cachefiles_req *req)
+{
+ struct cachefiles_ondemand_info *info = req->object->private;
+
+ if (!req || req->msg.opcode != CACHEFILES_OP_READ)
+ return false;
+
+ if (info->state == CACHEFILES_ONDEMAND_OBJSTATE_close) {
+ cachefiles_ondemand_set_object_reopening(req->object);
+ queue_work(fscache_wq, &info->work);
+ return true;
+ } else if (info->state == CACHEFILES_ONDEMAND_OBJSTATE_reopening) {
+ return true;
+ }
+
+ return false;
+}
+
ssize_t cachefiles_ondemand_daemon_read(struct cachefiles_cache *cache,
char __user *_buffer, size_t buflen)
{
@@ -247,6 +274,7 @@ ssize_t cachefiles_ondemand_daemon_read(struct
cachefiles_cache *cache,
size_t n;
int ret = 0;
XA_STATE(xas, &cache->reqs, cache->req_id_next);
+ unsigned long xa_max = ULONG_MAX;
/*
* Cyclically search for a request that has not ever been processed,
@@ -254,12 +282,18 @@ ssize_t cachefiles_ondemand_daemon_read(struct
cachefiles_cache *cache,
* request distribution fair.
*/
xa_lock(&cache->reqs);
- req = xas_find_marked(&xas, UINT_MAX, CACHEFILES_REQ_NEW);
- if (!req && cache->req_id_next > 0) {
- xas_set(&xas, 0);
- req = xas_find_marked(&xas, cache->req_id_next - 1,
CACHEFILES_REQ_NEW);
+retry:
+ xas_for_each_marked(&xas, req, xa_max, CACHEFILES_REQ_NEW) {
+ if (cachefiles_ondemand_skip_req(req))
+ continue;
+ break;
}
if (!req) {
+ if (cache->req_id_next > 0 && xa_max == ULONG_MAX) {
+ xas_set(&xas, 0);
+ xa_max = cache->req_id_next - 1;
+ goto retry;
+ }
xa_unlock(&cache->reqs);
return 0;
}
@@ -277,14 +311,18 @@ ssize_t cachefiles_ondemand_daemon_read(struct
cachefiles_cache *cache,
xa_unlock(&cache->reqs);
id = xas.xa_index;
- msg->msg_id = id;
if (msg->opcode == CACHEFILES_OP_OPEN) {
ret = cachefiles_ondemand_get_fd(req);
- if (ret)
+ if (ret) {
+ cachefiles_ondemand_set_object_close(req->object);
goto error;
+ }
}
+ msg->msg_id = id;
+ msg->object_id = req->object->private->ondemand_id;
+
if (copy_to_user(_buffer, msg, n) != 0) {
ret = -EFAULT;
goto err_put_fd;
@@ -317,19 +355,23 @@ static int cachefiles_ondemand_send_req(struct
cachefiles_object *object,
void *private)
{
struct cachefiles_cache *cache = object->volume->cache;
- struct cachefiles_req *req;
+ struct cachefiles_req *req = NULL;
XA_STATE(xas, &cache->reqs, 0);
int ret;
if (!test_bit(CACHEFILES_ONDEMAND_MODE, &cache->flags))
return 0;
- if (test_bit(CACHEFILES_DEAD, &cache->flags))
- return -EIO;
+ if (test_bit(CACHEFILES_DEAD, &cache->flags)) {
+ ret = -EIO;
+ goto out;
+ }
req = kzalloc(sizeof(*req) + data_len, GFP_KERNEL);
- if (!req)
- return -ENOMEM;
+ if (!req) {
+ ret = -ENOMEM;
+ goto out;
+ }
req->object = object;
init_completion(&req->done);
@@ -367,7 +409,7 @@ static int cachefiles_ondemand_send_req(struct
cachefiles_object *object,
/* coupled with the barrier in cachefiles_flush_reqs() */
smp_mb();
- if (opcode != CACHEFILES_OP_OPEN &&
+ if (opcode == CACHEFILES_OP_CLOSE &&
!cachefiles_ondemand_object_is_open(object)) {
WARN_ON_ONCE(object->private->ondemand_id == 0);
xas_unlock(&xas);
@@ -392,8 +434,16 @@ static int cachefiles_ondemand_send_req(struct
cachefiles_object *object,
wake_up_all(&cache->daemon_pollwq);
wait_for_completion(&req->done);
ret = req->error;
+ kfree(req);
+ return ret;
out:
kfree(req);
+ /* Reset the object to close state in error handling path.
+ * If error occurs after creating the anonymous fd,
+ * cachefiles_ondemand_fd_release() will set object to close.
+ */
+ if (opcode == CACHEFILES_OP_OPEN)
+ cachefiles_ondemand_set_object_close(req->object);
return ret;
}
@@ -445,7 +495,6 @@ static int cachefiles_ondemand_init_close_req(struct
cachefiles_req *req,
if (!cachefiles_ondemand_object_is_open(object))
return -ENOENT;
- req->msg.object_id = object->private->ondemand_id;
trace_cachefiles_ondemand_close(object, &req->msg);
return 0;
}
@@ -461,16 +510,7 @@ static int cachefiles_ondemand_init_read_req(struct
cachefiles_req *req,
struct cachefiles_object *object = req->object;
struct cachefiles_read *load = (void *)req->msg.data;
struct cachefiles_read_ctx *read_ctx = private;
- int object_id = object->private->ondemand_id;
-
- /* Stop enqueuing requests when daemon has closed anon_fd. */
- if (!cachefiles_ondemand_object_is_open(object)) {
- WARN_ON_ONCE(object_id == 0);
- pr_info_once("READ: anonymous fd closed prematurely.\n");
- return -EIO;
- }
- req->msg.object_id = object_id;
load->off = read_ctx->off;
load->len = read_ctx->len;
trace_cachefiles_ondemand_read(object, &req->msg, load);
@@ -519,6 +559,7 @@ int cachefiles_ondemand_init_obj_info(struct
cachefiles_object *object,
return -ENOMEM;
object->private->object = object;
+ INIT_WORK(&object->private->work, ondemand_object_worker);
return 0;
}
--
2.20.1
--
Linux-cachefs mailing list
Linux-cachefs@redhat.com
https://listman.redhat.com/mailman/listinfo/linux-cachefs
