LU-4198 clio: turn on lockless for some kind of IO

[fs/lustre-release.git] / lustre / include / cl_object.h

diff --git a/lustre/include/cl_object.h b/lustre/include/cl_object.h
index 9f9d2e5..a855df3 100644 (file)
--- a/lustre/include/cl_object.h
+++ b/lustre/include/cl_object.h
@@ -290,8 +290,6 @@ struct cl_layout {
        struct lu_buf   cl_buf;
        /** size of layout in lov_mds_md format. */
        size_t          cl_size;
-       /** size of DoM component if exists or zero otherwise */
-       u64             cl_dom_comp_size;
        /** Layout generation. */
        u32             cl_layout_gen;
        /** whether layout is a composite one */
@@ -420,6 +418,13 @@ struct cl_object_operations {
        void (*coo_req_attr_set)(const struct lu_env *env,
                                 struct cl_object *obj,
                                 struct cl_req_attr *attr);
+       /**
+        * Flush \a obj data corresponding to \a lock. Used for DoM
+        * locks in llite's cancelling blocking ast callback.
+        */
+       int (*coo_object_flush)(const struct lu_env *env,
+                               struct cl_object *obj,
+                               struct ldlm_lock *lock);
 };
 
 /**
@@ -756,6 +761,8 @@ struct cl_page {
        struct lu_ref_link       cp_queue_ref;
        /** Assigned if doing a sync_io */
        struct cl_sync_io       *cp_sync_io;
+       /** layout_entry + stripe index, composed using lov_comp_index() */
+       unsigned int            cp_lov_index;
 };
 
 /**
@@ -1463,20 +1470,22 @@ struct cl_io_slice {
 };
 
 typedef void (*cl_commit_cbt)(const struct lu_env *, struct cl_io *,
-                             struct cl_page *);
+                             struct pagevec *);
 
 struct cl_read_ahead {
        /* Maximum page index the readahead window will end.
         * This is determined DLM lock coverage, RPC and stripe boundary.
         * cra_end is included. */
-       pgoff_t cra_end;
+       pgoff_t         cra_end_idx;
        /* optimal RPC size for this read, by pages */
-       unsigned long cra_rpc_size;
+       unsigned long   cra_rpc_pages;
        /* Release callback. If readahead holds resources underneath, this
         * function should be called to release it. */
-       void    (*cra_release)(const struct lu_env *env, void *cbdata);
+       void            (*cra_release)(const struct lu_env *env, void *cbdata);
        /* Callback data for cra_release routine */
-       void    *cra_cbdata;
+       void            *cra_cbdata;
+       /* whether lock is in contention */
+       bool            cra_contention;
 };
 
 static inline void cl_read_ahead_release(const struct lu_env *env,
@@ -1904,7 +1913,17 @@ struct cl_io {
        /**
         * Set if IO is triggered by async workqueue readahead.
         */
-                            ci_async_readahead:1;
+                            ci_async_readahead:1,
+       /**
+        * Ignore lockless and do normal locking for this io.
+        */
+                            ci_ignore_lockless:1,
+       /**
+        * Set if we've tried all mirrors for this read IO, if it's not set,
+        * the read IO will check to-be-read OSCs' status, and make fast-switch
+        * another mirror if some of the OSTs are not healthy.
+        */
+                            ci_tried_all_mirrors:1;
        /**
         * How many times the read has retried before this one.
         * Set by the top level and consumed by the LOV.
@@ -2104,6 +2123,9 @@ int cl_object_fiemap(const struct lu_env *env, struct cl_object *obj,
 int cl_object_layout_get(const struct lu_env *env, struct cl_object *obj,
                         struct cl_layout *cl);
 loff_t cl_object_maxbytes(struct cl_object *obj);
+int cl_object_flush(const struct lu_env *env, struct cl_object *obj,
+                   struct ldlm_lock *lock);
+
 
 /**
  * Returns true, iff \a o0 and \a o1 are slices of the same object.
@@ -2461,6 +2483,22 @@ void cl_req_attr_set(const struct lu_env *env, struct cl_object *obj,
 /** \defgroup cl_sync_io cl_sync_io
  * @{ */
 
+struct cl_sync_io;
+
+typedef void (cl_sync_io_end_t)(const struct lu_env *, struct cl_sync_io *);
+
+void cl_sync_io_init_notify(struct cl_sync_io *anchor, int nr,
+                           cl_sync_io_end_t *end);
+
+int  cl_sync_io_wait(const struct lu_env *env, struct cl_sync_io *anchor,
+                    long timeout);
+void cl_sync_io_note(const struct lu_env *env, struct cl_sync_io *anchor,
+                    int ioret);
+static inline void cl_sync_io_init(struct cl_sync_io *anchor, int nr)
+{
+       cl_sync_io_init_notify(anchor, nr, NULL);
+}
+
 /**
  * Anchor for synchronous transfer. This is allocated on a stack by thread
  * doing synchronous transfer, and a pointer to this structure is set up in
@@ -2475,18 +2513,9 @@ struct cl_sync_io {
        /** completion to be signaled when transfer is complete. */
        wait_queue_head_t       csi_waitq;
        /** callback to invoke when this IO is finished */
-       void                    (*csi_end_io)(const struct lu_env *,
-                                             struct cl_sync_io *);
+       cl_sync_io_end_t       *csi_end_io;
 };
 
-void cl_sync_io_init(struct cl_sync_io *anchor, int nr,
-                    void (*end)(const struct lu_env *, struct cl_sync_io *));
-int  cl_sync_io_wait(const struct lu_env *env, struct cl_sync_io *anchor,
-                    long timeout);
-void cl_sync_io_note(const struct lu_env *env, struct cl_sync_io *anchor,
-                    int ioret);
-void cl_sync_io_end(const struct lu_env *env, struct cl_sync_io *anchor);
-
 /** @} cl_sync_io */
 
 /** \defgroup cl_env cl_env