LU-13799 osc: Always set aio in anchor

[fs/lustre-release.git] / lustre / obdclass / cl_io.c

diff --git a/lustre/obdclass/cl_io.c b/lustre/obdclass/cl_io.c
index d3ce874..29db2c6 100644 (file)
--- a/lustre/obdclass/cl_io.c
+++ b/lustre/obdclass/cl_io.c
@@ -221,8 +221,14 @@ int cl_io_rw_init(const struct lu_env *env, struct cl_io *io,
 }
 EXPORT_SYMBOL(cl_io_rw_init);
 
+#ifdef HAVE_LIST_CMP_FUNC_T
+static int cl_lock_descr_cmp(void *priv,
+                            const struct list_head *a,
+                            const struct list_head *b)
+#else /* !HAVE_LIST_CMP_FUNC_T */
 static int cl_lock_descr_cmp(void *priv,
                             struct list_head *a, struct list_head *b)
+#endif /* HAVE_LIST_CMP_FUNC_T */
 {
        const struct cl_io_lock_link *l0 = list_entry(a, struct cl_io_lock_link,
                                                      cill_linkage);
@@ -922,13 +928,12 @@ EXPORT_SYMBOL(cl_page_list_move_head);
  */
 void cl_page_list_splice(struct cl_page_list *src, struct cl_page_list *dst)
 {
-#ifdef USE_LU_REF
+#ifdef CONFIG_LUSTRE_DEBUG_LU_REF
        struct cl_page *page;
        struct cl_page *tmp;
 
-
        ENTRY;
-       cl_page_list_for_each_safe(page, tmp, list)
+       cl_page_list_for_each_safe(page, tmp, src)
                lu_ref_set_at(&page->cp_reference, &page->cp_queue_ref,
                              "queue", src, dst);
 #else
@@ -1226,7 +1231,7 @@ static void cl_aio_end(const struct lu_env *env, struct cl_sync_io *anchor)
                cl_page_put(env, page);
        }
 
-       if (!is_sync_kiocb(aio->cda_iocb) && !aio->cda_no_aio_complete)
+       if (!aio->cda_no_aio_complete)
                aio_complete(aio->cda_iocb, ret ?: aio->cda_bytes, 0);
 
        EXIT;
@@ -1242,11 +1247,13 @@ struct cl_dio_aio *cl_aio_alloc(struct kiocb *iocb, struct cl_object *obj)
                 * Hold one ref so that it won't be released until
                 * every pages is added.
                 */
-               cl_sync_io_init_notify(&aio->cda_sync, 1, is_sync_kiocb(iocb) ?
-                                      NULL : aio, cl_aio_end);
+               cl_sync_io_init_notify(&aio->cda_sync, 1, aio, cl_aio_end);
                cl_page_list_init(&aio->cda_pages);
                aio->cda_iocb = iocb;
-               aio->cda_no_aio_complete = 0;
+               if (is_sync_kiocb(iocb))
+                       aio->cda_no_aio_complete = 1;
+               else
+                       aio->cda_no_aio_complete = 0;
                cl_object_get(obj);
                aio->cda_obj = obj;
        }
@@ -1296,16 +1303,20 @@ void cl_sync_io_note(const struct lu_env *env, struct cl_sync_io *anchor,
                wake_up_locked(&anchor->csi_waitq);
                if (end_io)
                        end_io(env, anchor);
-               if (anchor->csi_aio)
-                       aio = anchor->csi_aio;
+
+               aio = anchor->csi_aio;
 
                spin_unlock(&anchor->csi_waitq.lock);
 
                /**
-                * If anchor->csi_aio is set, we are responsible for freeing
-                * memory here rather than when cl_sync_io_wait() completes.
+                * For AIO (!is_sync_kiocb), we are responsible for freeing
+                * memory here.  This is because we are the last user of this
+                * aio struct, whereas in other cases, we will call
+                * cl_sync_io_wait to wait after this, and so the memory is
+                * freed after that call.
                 */
-               cl_aio_free(env, aio);
+               if (aio && !is_sync_kiocb(aio->cda_iocb))
+                       cl_aio_free(env, aio);
        }
        EXIT;
 }