From 1a7929fd4c030ee76cb5cbc57a82a8cb2a2fb291 Mon Sep 17 00:00:00 2001 From: Patrick Farrell Date: Sun, 24 Sep 2023 17:12:26 -0400 Subject: [PATCH] LU-13814 osc: rename osc_async_page osc_async_page isn't for async IO - it's for all data IO. Rename it osc_transfer_page so the name fits the usage. Test-Parameters: trivial Test-Parameters: forjanitoronly Signed-off-by: Patrick Farrell Change-Id: I930aae585763f95d9085bea179765a0431bccf52 --- lustre/include/lustre_osc.h | 66 ++++++------ lustre/mdc/mdc_dev.c | 2 +- lustre/osc/osc_cache.c | 243 ++++++++++++++++++++++---------------------- lustre/osc/osc_internal.h | 2 - lustre/osc/osc_io.c | 44 ++++---- lustre/osc/osc_object.c | 2 +- lustre/osc/osc_page.c | 46 ++++----- lustre/osc/osc_request.c | 78 +++++++------- 8 files changed, 244 insertions(+), 239 deletions(-) diff --git a/lustre/include/lustre_osc.h b/lustre/include/lustre_osc.h index 69d8cc3..f7c75e4 100644 --- a/lustre/include/lustre_osc.h +++ b/lustre/include/lustre_osc.h @@ -54,7 +54,13 @@ * @{ */ -enum oap_async_flags { +struct osc_quota_info { + /** linkage for quota hash table */ + struct hlist_node oqi_hash; + __u32 oqi_id; +}; + +enum otp_flags { ASYNC_READY = 0x1, /* ap_make_ready will not be called before * this page is added to an rpc */ ASYNC_URGENT = 0x2, /* page must be put into RPC before return */ @@ -62,37 +68,37 @@ enum oap_async_flags { to give the caller a chance to update or cancel the size of the io */ ASYNC_HP = 0x8, - OAP_ASYNC_MAX, - OAP_ASYNC_BITS = 4 + OTP_ASYNC_MAX, + OTP_ASYNC_BITS = 4 }; -struct osc_async_page { - struct list_head oap_pending_item; - struct list_head oap_rpc_item; +struct osc_transfer_page { + struct list_head otp_pending_item; + struct list_head otp_rpc_item; - loff_t oap_obj_off; + loff_t otp_obj_off; - struct osc_object *oap_obj; + struct osc_object *otp_obj; - struct brw_page oap_brw_page; + struct brw_page otp_brw_page; - unsigned int oap_page_off:PAGE_SHIFT, - oap_cmd:OBD_BRW_WRITE, - oap_async_flags:OAP_ASYNC_BITS, + unsigned int otp_page_off:PAGE_SHIFT, + otp_cmd:OBD_BRW_WRITE, + otp_flags:OTP_ASYNC_BITS, /** * Set if the page must be transferred with OBD_BRW_SRVLOCK. */ - oap_srvlock:1; + otp_srvlock:1; } __attribute__((packed)); -#define oap_page oap_brw_page.bp_page -#define oap_count oap_brw_page.bp_count -#define oap_brw_flags oap_brw_page.bp_flag +#define otp_page otp_brw_page.bp_page +#define otp_count otp_brw_page.bp_count +#define otp_brw_flags otp_brw_page.bp_flag -static inline struct osc_async_page *brw_page2oap(struct brw_page *pga) +static inline struct osc_transfer_page *brw_page2otp(struct brw_page *pga) { - BUILD_BUG_ON(OAP_ASYNC_MAX - 1 >= (1 << OAP_ASYNC_BITS)); - return container_of(pga, struct osc_async_page, oap_brw_page); + BUILD_BUG_ON(OTP_ASYNC_MAX - 1 >= (1 << OTP_ASYNC_BITS)); + return container_of(pga, struct osc_transfer_page, otp_brw_page); } struct osc_device { @@ -501,7 +507,7 @@ struct osc_page { /** * Page queues used by osc to detect when RPC can be formed. */ - struct osc_async_page ops_oap; + struct osc_transfer_page ops_otp; /** * Boolean, true iff page is under transfer. Used for sanity checking. */ @@ -525,7 +531,7 @@ struct osc_brw_async_args { s32 aa_resends; struct brw_page **aa_ppga; struct client_obd *aa_cli; - struct list_head aa_oaps; + struct list_head aa_otps; struct list_head aa_exts; struct ptlrpc_request *aa_request; }; @@ -832,29 +838,29 @@ static inline struct osc_page *cl2osc_page(const struct cl_page_slice *slice) return container_of_safe(slice, struct osc_page, ops_cl); } -static inline struct osc_page *oap2osc(struct osc_async_page *oap) +static inline struct osc_page *otp2osc(struct osc_transfer_page *otp) { - return container_of_safe(oap, struct osc_page, ops_oap); + return container_of_safe(otp, struct osc_page, ops_otp); } static inline pgoff_t osc_index(struct osc_page *opg) { - return opg->ops_oap.oap_obj_off >> PAGE_SHIFT; + return opg->ops_otp.otp_obj_off >> PAGE_SHIFT; } static inline struct osc_object *osc_page_object(struct osc_page *ops) { - return ops->ops_oap.oap_obj; + return ops->ops_otp.otp_obj; } -static inline struct cl_page *oap2cl_page(struct osc_async_page *oap) +static inline struct cl_page *otp2cl_page(struct osc_transfer_page *otp) { - return oap2osc(oap)->ops_cl.cpl_page; + return otp2osc(otp)->ops_cl.cpl_page; } -static inline struct osc_page *oap2osc_page(struct osc_async_page *oap) +static inline struct osc_page *otp2osc_page(struct osc_transfer_page *otp) { - return (struct osc_page *)container_of(oap, struct osc_page, ops_oap); + return (struct osc_page *)container_of(otp, struct osc_page, ops_otp); } static inline struct osc_page * @@ -967,7 +973,7 @@ struct osc_extent { unsigned int oe_grants; /** # of dirty pages in this extent */ unsigned int oe_nr_pages; - /** list of pending oap pages. Pages in this list are NOT sorted. */ + /** list of pending otp pages. Pages in this list are NOT sorted. */ struct list_head oe_pages; /* tracking structure for dio pages */ struct osc_dio_pages oe_odp; diff --git a/lustre/mdc/mdc_dev.c b/lustre/mdc/mdc_dev.c index 3d9187f..9cb0715 100644 --- a/lustre/mdc/mdc_dev.c +++ b/lustre/mdc/mdc_dev.c @@ -1424,7 +1424,7 @@ static void mdc_req_attr_set(const struct lu_env *env, struct cl_object *obj, struct osc_page *opg; opg = osc_cl_page_osc(attr->cra_page, cl2osc(obj)); - if (!opg->ops_oap.oap_srvlock) { + if (!opg->ops_otp.otp_srvlock) { int rc; rc = mdc_get_lock_handle(env, cl2osc(obj), diff --git a/lustre/osc/osc_cache.c b/lustre/osc/osc_cache.c index 2a755c5..8ef433d 100644 --- a/lustre/osc/osc_cache.c +++ b/lustre/osc/osc_cache.c @@ -47,15 +47,15 @@ static void osc_update_pending(struct osc_object *obj, int cmd, int delta); static int osc_extent_wait(const struct lu_env *env, struct osc_extent *ext, enum osc_extent_state state); static void osc_completion(const struct lu_env *env, struct osc_object *osc, - struct osc_async_page *oap, enum cl_req_type crt, + struct osc_transfer_page *otp, enum cl_req_type crt, int rc); static void osc_dio_completion(const struct lu_env *env, struct osc_object *osc, struct cl_dio_pages *cdp, enum cl_req_type crt, int page_count, int brw_flags, int rc); -static int osc_make_ready(const struct lu_env *env, struct osc_async_page *oap, - int cmd); +static int osc_make_ready(const struct lu_env *env, + struct osc_transfer_page *otp, int cmd); static int osc_refresh_count(const struct lu_env *env, struct osc_object *osc, - struct osc_async_page *oap, int cmd); + struct osc_transfer_page *otp, int cmd); static int osc_io_unplug_async(const struct lu_env *env, struct client_obd *cli, struct osc_object *osc); static void osc_free_grant(struct client_obd *cli, unsigned int nr_pages, @@ -181,7 +181,7 @@ static int osc_extent_sanity_check0(struct osc_extent *ext, const char *func, const int line) { struct osc_object *obj = ext->oe_obj; - struct osc_async_page *oap; + struct osc_transfer_page *otp; size_t page_count; int rc = 0; @@ -253,8 +253,8 @@ static int osc_extent_sanity_check0(struct osc_extent *ext, GOTO(out, rc = 0); page_count = 0; - list_for_each_entry(oap, &ext->oe_pages, oap_pending_item) { - pgoff_t index = osc_index(oap2osc(oap)); + list_for_each_entry(otp, &ext->oe_pages, otp_pending_item) { + pgoff_t index = osc_index(otp2osc(otp)); ++page_count; if (index > ext->oe_end || index < ext->oe_start) GOTO(out, rc = 110); @@ -836,8 +836,8 @@ int osc_extent_finish(const struct lu_env *env, struct osc_extent *ext, { struct client_obd *cli = osc_cli(ext->oe_obj); struct osc_object *osc = ext->oe_obj; - struct osc_async_page *oap; - struct osc_async_page *tmp; + struct osc_transfer_page *otp; + struct osc_transfer_page *tmp; int nr_pages = ext->oe_nr_pages; int lost_grant = 0; int blocksize = cli->cl_import->imp_obd->obd_osfs.os_bsize ? : 4096; @@ -860,20 +860,20 @@ int osc_extent_finish(const struct lu_env *env, struct osc_extent *ext, if (!ext->oe_dio) osc_lru_add_batch(cli, &ext->oe_pages); - list_for_each_entry_safe(oap, tmp, &ext->oe_pages, - oap_pending_item) { - list_del_init(&oap->oap_rpc_item); - list_del_init(&oap->oap_pending_item); - if (last_off <= oap->oap_obj_off) { - last_off = oap->oap_obj_off; - last_count = oap->oap_count; + list_for_each_entry_safe(otp, tmp, &ext->oe_pages, + otp_pending_item) { + list_del_init(&otp->otp_rpc_item); + list_del_init(&otp->otp_pending_item); + if (last_off <= otp->otp_obj_off) { + last_off = otp->otp_obj_off; + last_count = otp->otp_count; } --ext->oe_nr_pages; if (ext->oe_odp.odp_cdp) continue; else - osc_completion(env, osc, oap, crt, rc); + osc_completion(env, osc, otp, crt, rc); } /* after this, the cl_dio_pages may be freed, so take care not to @@ -968,8 +968,8 @@ static int osc_extent_truncate(struct osc_extent *ext, pgoff_t trunc_index, struct cl_io *io; struct osc_object *obj = ext->oe_obj; struct client_obd *cli = osc_cli(obj); - struct osc_async_page *oap; - struct osc_async_page *tmp; + struct osc_transfer_page *otp; + struct osc_transfer_page *tmp; struct pagevec *pvec; int pages_in_chunk = 0; int ppc_bits = cli->cl_chunkbits - @@ -1002,12 +1002,12 @@ static int osc_extent_truncate(struct osc_extent *ext, pgoff_t trunc_index, GOTO(out, rc); /* discard all pages with index greater than trunc_index */ - list_for_each_entry_safe(oap, tmp, &ext->oe_pages, - oap_pending_item) { - pgoff_t index = osc_index(oap2osc(oap)); - struct cl_page *page = oap2cl_page(oap); + list_for_each_entry_safe(otp, tmp, &ext->oe_pages, + otp_pending_item) { + pgoff_t index = osc_index(otp2osc(otp)); + struct cl_page *page = otp2cl_page(otp); - LASSERT(list_empty(&oap->oap_rpc_item)); + LASSERT(list_empty(&otp->otp_rpc_item)); /* only discard the pages with their index greater than * trunc_index, and ... */ @@ -1020,7 +1020,7 @@ static int osc_extent_truncate(struct osc_extent *ext, pgoff_t trunc_index, continue; } - list_del_init(&oap->oap_pending_item); + list_del_init(&otp->otp_pending_item); cl_page_get(page); lu_ref_add(&page->cp_reference, "truncate", current); @@ -1092,8 +1092,8 @@ out: static int osc_extent_make_ready(const struct lu_env *env, struct osc_extent *ext) { - struct osc_async_page *oap; - struct osc_async_page *last = NULL; + struct osc_transfer_page *otp; + struct osc_transfer_page *last = NULL; struct osc_object *obj = ext->oe_obj; unsigned int page_count = 0; int rc; @@ -1107,22 +1107,22 @@ static int osc_extent_make_ready(const struct lu_env *env, OSC_EXTENT_DUMP(D_CACHE, ext, "make ready\n"); - list_for_each_entry(oap, &ext->oe_pages, oap_pending_item) { + list_for_each_entry(otp, &ext->oe_pages, otp_pending_item) { ++page_count; - if (last == NULL || last->oap_obj_off < oap->oap_obj_off) - last = oap; + if (last == NULL || last->otp_obj_off < otp->otp_obj_off) + last = otp; /* checking ASYNC_READY is race safe */ - if ((oap->oap_async_flags & ASYNC_READY) != 0) + if ((otp->otp_flags & ASYNC_READY) != 0) continue; - rc = osc_make_ready(env, oap, OBD_BRW_WRITE); + rc = osc_make_ready(env, otp, OBD_BRW_WRITE); switch (rc) { case 0: - oap->oap_async_flags |= ASYNC_READY; + otp->otp_flags |= ASYNC_READY; break; case -EALREADY: - LASSERT((oap->oap_async_flags & ASYNC_READY) != 0); + LASSERT((otp->otp_flags & ASYNC_READY) != 0); break; default: LASSERTF(0, "unknown return code: %d\n", rc); @@ -1133,22 +1133,22 @@ static int osc_extent_make_ready(const struct lu_env *env, LASSERT(last != NULL); /* the last page is the only one we need to refresh its count by * the size of file. */ - if (!(last->oap_async_flags & ASYNC_COUNT_STABLE)) { - int last_oap_count = osc_refresh_count(env, obj, last, + if (!(last->otp_flags & ASYNC_COUNT_STABLE)) { + int last_otp_count = osc_refresh_count(env, obj, last, OBD_BRW_WRITE); - LASSERTF(last_oap_count > 0, - "last_oap_count %d\n", last_oap_count); - LASSERT(last->oap_page_off + last_oap_count <= PAGE_SIZE); - last->oap_count = last_oap_count; - last->oap_async_flags |= ASYNC_COUNT_STABLE; + LASSERTF(last_otp_count > 0, + "last_otp_count %d\n", last_otp_count); + LASSERT(last->otp_page_off + last_otp_count <= PAGE_SIZE); + last->otp_count = last_otp_count; + last->otp_flags |= ASYNC_COUNT_STABLE; } /* for the rest of pages, we don't need to call osf_refresh_count() * because it's known they are not the last page */ - list_for_each_entry(oap, &ext->oe_pages, oap_pending_item) { - if (!(oap->oap_async_flags & ASYNC_COUNT_STABLE)) { - oap->oap_count = PAGE_SIZE - oap->oap_page_off; - oap->oap_async_flags |= ASYNC_COUNT_STABLE; + list_for_each_entry(otp, &ext->oe_pages, otp_pending_item) { + if (!(otp->otp_flags & ASYNC_COUNT_STABLE)) { + otp->otp_count = PAGE_SIZE - otp->otp_page_off; + otp->otp_flags |= ASYNC_COUNT_STABLE; } } @@ -1269,10 +1269,10 @@ static inline int osc_is_ready(struct osc_object *osc) list_empty_marker(&(OSC)->oo_reading_exts), \ ##args) -static int osc_make_ready(const struct lu_env *env, struct osc_async_page *oap, - int cmd) +static int osc_make_ready(const struct lu_env *env, + struct osc_transfer_page *otp, int cmd) { - struct cl_page *page = oap2cl_page(oap); + struct cl_page *page = otp2cl_page(otp); int result; LASSERT(cmd == OBD_BRW_WRITE); /* no cached reads */ @@ -1285,10 +1285,10 @@ static int osc_make_ready(const struct lu_env *env, struct osc_async_page *oap, } static int osc_refresh_count(const struct lu_env *env, struct osc_object *osc, - struct osc_async_page *oap, int cmd) + struct osc_transfer_page *otp, int cmd) { - struct osc_page *opg = oap2osc_page(oap); - pgoff_t index = osc_index(oap2osc(oap)); + struct osc_page *opg = otp2osc_page(otp); + pgoff_t index = osc_index(otp2osc(otp)); struct cl_object *obj = osc2cl(osc); struct cl_attr *attr = &osc_env_info(env)->oti_attr; int result; @@ -1348,16 +1348,16 @@ static void osc_dio_completion(const struct lu_env *env, struct osc_object *osc, * async_flag maintenance */ static void osc_completion(const struct lu_env *env, struct osc_object *osc, - struct osc_async_page *oap, enum cl_req_type crt, + struct osc_transfer_page *otp, enum cl_req_type crt, int rc) { - struct osc_page *opg = oap2osc_page(oap); - struct cl_page *page = oap2cl_page(oap); + struct osc_page *opg = otp2osc_page(otp); + struct cl_page *page = otp2cl_page(otp); ENTRY; /* As the transfer for this page is done, clear the flags */ - oap->oap_async_flags = 0; + otp->otp_flags = 0; LASSERTF(equi(page->cp_state == CPS_PAGEIN, crt == CRT_READ), @@ -1524,13 +1524,14 @@ static void osc_free_grant(struct client_obd *cli, unsigned int nr_pages, } /** - * The companion to osc_enter_cache(), called when @oap is no longer part of + * The companion to osc_enter_cache(), called when @otp is no longer part of * the dirty accounting due to error. */ -static void osc_exit_cache(struct client_obd *cli, struct osc_async_page *oap) +static void osc_exit_cache(struct client_obd *cli, + struct osc_transfer_page *otp) { spin_lock(&cli->cl_loi_list_lock); - osc_release_write_grant(cli, &oap->oap_brw_page); + osc_release_write_grant(cli, &otp->otp_brw_page); spin_unlock(&cli->cl_loi_list_lock); } @@ -1539,7 +1540,7 @@ static void osc_exit_cache(struct client_obd *cli, struct osc_async_page *oap) * is available. */ static int osc_enter_cache_try(struct client_obd *cli, - struct osc_async_page *oap, + struct osc_transfer_page *otp, int bytes) { int rc; @@ -1553,7 +1554,7 @@ static int osc_enter_cache_try(struct client_obd *cli, if (cli->cl_dirty_pages < cli->cl_dirty_max_pages) { if (atomic_long_add_return(1, &obd_dirty_pages) <= obd_max_dirty_pages) { - osc_consume_write_grant(cli, &oap->oap_brw_page); + osc_consume_write_grant(cli, &otp->otp_brw_page); rc = 1; goto out; } else @@ -1572,13 +1573,13 @@ out: */ static inline void cli_unlock_and_unplug(const struct lu_env *env, struct client_obd *cli, - struct osc_async_page *oap) + struct osc_transfer_page *otp) { spin_unlock(&cli->cl_loi_list_lock); osc_io_unplug_async(env, cli, NULL); CDEBUG(D_CACHE, "%s: sleeping for cache space for %p\n", - cli_name(cli), oap); + cli_name(cli), otp); } static inline void cli_lock_after_unplug(struct client_obd *cli) @@ -1593,8 +1594,8 @@ static inline void cli_lock_after_unplug(struct client_obd *cli) * The process will be put into sleep if it's already run out of grant. */ static int osc_enter_cache(const struct lu_env *env, struct client_obd *cli, - struct osc_object *osc, struct osc_async_page *oap, - int bytes) + struct osc_object *osc, + struct osc_transfer_page *otp, int bytes) { struct lov_oinfo *loi = osc->oo_oinfo; int rc = -EDQUOT; @@ -1637,10 +1638,10 @@ static int osc_enter_cache(const struct lu_env *env, struct client_obd *cli, */ remain = wait_event_idle_exclusive_timeout_cmd( cli->cl_cache_waiters, - (entered = osc_enter_cache_try(cli, oap, bytes)) || + (entered = osc_enter_cache_try(cli, otp, bytes)) || (cli->cl_dirty_pages == 0 && cli->cl_w_in_flight == 0), timeout, - cli_unlock_and_unplug(env, cli, oap), + cli_unlock_and_unplug(env, cli, otp), cli_lock_after_unplug(cli)); if (entered) { @@ -1760,7 +1761,7 @@ static void on_list(struct list_head *item, struct list_head *list, list_del_init(item); } -/* maintain the osc's cli list membership invariants so that osc_send_oap_rpc +/* maintain the osc's cli list membership invariants so that osc_send_otp_rpc * can find pages to build into rpcs quickly */ static int __osc_list_maint(struct client_obd *cli, struct osc_object *osc) { @@ -2155,7 +2156,7 @@ __must_hold(&cli->cl_loi_list_lock) /* attempt some read/write balancing by alternating between * reads and writes in an object. The makes_rpc checks here * would be redundant if we were getting read/write work items - * instead of objects. we don't want send_oap_rpc to drain a + * instead of objects. we don't want send_otp_rpc to drain a * partial read pending queue when we're given this object to * do io on writes while there are cache waiters */ osc_object_lock(osc); @@ -2223,17 +2224,17 @@ EXPORT_SYMBOL(osc_io_unplug0); int osc_prep_async_page(struct osc_object *osc, struct osc_page *ops, struct cl_page *page, loff_t offset) { - struct osc_async_page *oap = &ops->ops_oap; + struct osc_transfer_page *otp = &ops->ops_otp; ENTRY; if (!page) - return round_up(sizeof(*oap), 8); + return round_up(sizeof(*otp), 8); - oap->oap_obj = osc; - oap->oap_page = page->cp_vmpage; - oap->oap_obj_off = offset; - oap->oap_page_off = 0; - oap->oap_count = PAGE_SIZE; + otp->otp_obj = osc; + otp->otp_page = page->cp_vmpage; + otp->otp_obj_off = offset; + otp->otp_page_off = 0; + otp->otp_count = PAGE_SIZE; LASSERT(!(offset & ~PAGE_MASK)); /* Count of transient (direct i/o) pages is always stable by the time @@ -2241,14 +2242,14 @@ int osc_prep_async_page(struct osc_object *osc, struct osc_page *ops, * cl_page_clip later to set this. */ if (page->cp_type == CPT_TRANSIENT) - oap->oap_async_flags |= ASYNC_COUNT_STABLE|ASYNC_URGENT| + otp->otp_flags |= ASYNC_COUNT_STABLE|ASYNC_URGENT| ASYNC_READY; - INIT_LIST_HEAD(&oap->oap_pending_item); - INIT_LIST_HEAD(&oap->oap_rpc_item); + INIT_LIST_HEAD(&otp->otp_pending_item); + INIT_LIST_HEAD(&otp->otp_rpc_item); - CDEBUG(D_INFO, "oap %p vmpage %p obj off %llu\n", - oap, oap->oap_page, oap->oap_obj_off); + CDEBUG(D_INFO, "otp %p vmpage %p obj off %llu\n", + otp, otp->otp_page, otp->otp_obj_off); RETURN(0); } EXPORT_SYMBOL(osc_prep_async_page); @@ -2259,7 +2260,7 @@ int osc_queue_async_io(const struct lu_env *env, struct cl_io *io, { struct osc_io *oio = osc_env_io(env); struct osc_extent *ext = NULL; - struct osc_async_page *oap = &ops->ops_oap; + struct osc_transfer_page *otp = &ops->ops_otp; struct client_obd *cli = osc_cli(osc); struct pagevec *pvec = &osc_env_info(env)->oti_pagevec; pgoff_t index; @@ -2274,12 +2275,12 @@ int osc_queue_async_io(const struct lu_env *env, struct cl_io *io, if (cli->cl_import == NULL || cli->cl_import->imp_invalid) RETURN(-EIO); - if (!list_empty(&oap->oap_pending_item) || - !list_empty(&oap->oap_rpc_item)) + if (!list_empty(&otp->otp_pending_item) || + !list_empty(&otp->otp_rpc_item)) RETURN(-EBUSY); /* Set the OBD_BRW_SRVLOCK before the page is queued. */ - brw_flags |= ops->ops_oap.oap_srvlock ? OBD_BRW_SRVLOCK : 0; + brw_flags |= ops->ops_otp.otp_srvlock ? OBD_BRW_SRVLOCK : 0; if (io->ci_noquota) { brw_flags |= OBD_BRW_NOQUOTA; cmd |= OBD_BRW_NOQUOTA; @@ -2317,16 +2318,16 @@ int osc_queue_async_io(const struct lu_env *env, struct cl_io *io, RETURN(rc); } - oap->oap_cmd = cmd; + otp->otp_cmd = cmd; /* No need to hold a lock here, * since this page is not in any list yet. */ - oap->oap_async_flags = 0; - oap->oap_brw_flags = brw_flags; + otp->otp_flags = 0; + otp->otp_brw_flags = brw_flags; - OSC_IO_DEBUG(osc, "oap %p page %p added for cmd %d\n", - oap, oap->oap_page, oap->oap_cmd & OBD_BRW_RWMASK); + OSC_IO_DEBUG(osc, "otp %p page %p added for cmd %d\n", + otp, otp->otp_page, otp->otp_cmd & OBD_BRW_RWMASK); - index = osc_index(oap2osc(oap)); + index = osc_index(otp2osc(otp)); /* Add this page into extent by the following steps: * 1. if there exists an active extent for this IO, mostly this page @@ -2344,7 +2345,7 @@ int osc_queue_async_io(const struct lu_env *env, struct cl_io *io, /* it doesn't need any grant to dirty this page */ spin_lock(&cli->cl_loi_list_lock); - rc = osc_enter_cache_try(cli, oap, grants); + rc = osc_enter_cache_try(cli, otp, grants); if (rc == 0) { /* try failed */ grants = 0; need_release = 1; @@ -2394,7 +2395,7 @@ int osc_queue_async_io(const struct lu_env *env, struct cl_io *io, } if (grants == 0) { - rc = osc_enter_cache(env, cli, osc, oap, tmp); + rc = osc_enter_cache(env, cli, osc, otp, tmp); if (rc == 0) grants = tmp; } @@ -2404,7 +2405,7 @@ int osc_queue_async_io(const struct lu_env *env, struct cl_io *io, ext = osc_extent_find(env, osc, index, &tmp); if (IS_ERR(ext)) { LASSERT(tmp == grants); - osc_exit_cache(cli, oap); + osc_exit_cache(cli, otp); rc = PTR_ERR(ext); ext = NULL; } else { @@ -2419,15 +2420,15 @@ int osc_queue_async_io(const struct lu_env *env, struct cl_io *io, if (ext != NULL) { EASSERTF(ext->oe_end >= index && ext->oe_start <= index, ext, "index = %lu.\n", index); - LASSERT((oap->oap_brw_flags & OBD_BRW_FROM_GRANT) != 0); + LASSERT((otp->otp_brw_flags & OBD_BRW_FROM_GRANT) != 0); osc_object_lock(osc); if (ext->oe_nr_pages == 0) - ext->oe_srvlock = ops->ops_oap.oap_srvlock; + ext->oe_srvlock = ops->ops_otp.otp_srvlock; else - LASSERT(ext->oe_srvlock == ops->ops_oap.oap_srvlock); + LASSERT(ext->oe_srvlock == ops->ops_otp.otp_srvlock); ++ext->oe_nr_pages; - list_add_tail(&oap->oap_pending_item, &ext->oe_pages); + list_add_tail(&otp->otp_pending_item, &ext->oe_pages); osc_object_unlock(osc); if (!ext->oe_layout_version) @@ -2440,28 +2441,28 @@ int osc_queue_async_io(const struct lu_env *env, struct cl_io *io, int osc_teardown_async_page(const struct lu_env *env, struct osc_object *obj, struct osc_page *ops) { - struct osc_async_page *oap = &ops->ops_oap; + struct osc_transfer_page *otp = &ops->ops_otp; int rc = 0; ENTRY; - CDEBUG(D_INFO, "teardown oap %p page %p at index %lu.\n", - oap, ops, osc_index(oap2osc(oap))); + CDEBUG(D_INFO, "teardown otp %p page %p at index %lu.\n", + otp, ops, osc_index(otp2osc(otp))); - if (!list_empty(&oap->oap_rpc_item)) { - CDEBUG(D_CACHE, "oap %p is not in cache.\n", oap); + if (!list_empty(&otp->otp_rpc_item)) { + CDEBUG(D_CACHE, "otp %p is not in cache.\n", otp); rc = -EBUSY; - } else if (!list_empty(&oap->oap_pending_item)) { + } else if (!list_empty(&otp->otp_pending_item)) { struct osc_extent *ext = NULL; osc_object_lock(obj); - ext = osc_extent_lookup(obj, osc_index(oap2osc(oap))); + ext = osc_extent_lookup(obj, osc_index(otp2osc(otp))); osc_object_unlock(obj); /* only truncated pages are allowed to be taken out. * See osc_extent_truncate() and osc_cache_truncate_start() * for details. */ if (ext != NULL && ext->oe_state != OES_TRUNC) { OSC_EXTENT_DUMP(D_ERROR, ext, "trunc at %lu.\n", - osc_index(oap2osc(oap))); + osc_index(otp2osc(otp))); rc = -EBUSY; } if (ext != NULL) @@ -2484,7 +2485,7 @@ int osc_flush_async_page(const struct lu_env *env, struct cl_io *io, struct osc_object *obj = osc_page_object(ops); struct cl_page *cp = ops->ops_cl.cpl_page; pgoff_t index = osc_index(ops); - struct osc_async_page *oap = &ops->ops_oap; + struct osc_transfer_page *otp = &ops->ops_otp; bool unplug = false; int rc = 0; ENTRY; @@ -2526,7 +2527,7 @@ int osc_flush_async_page(const struct lu_env *env, struct cl_io *io, if (rc) GOTO(out, rc); - oap->oap_async_flags |= ASYNC_READY|ASYNC_URGENT; + otp->otp_flags |= ASYNC_READY|ASYNC_URGENT; if (current->flags & PF_MEMALLOC) ext->oe_memalloc = 1; @@ -2534,7 +2535,7 @@ int osc_flush_async_page(const struct lu_env *env, struct cl_io *io, ext->oe_urgent = 1; if (ext->oe_state == OES_CACHE) { OSC_EXTENT_DUMP(D_CACHE, ext, - "flush page %p make it urgent.\n", oap); + "flush page %p make it urgent.\n", otp); if (list_empty(&ext->oe_link)) list_add_tail(&ext->oe_link, &obj->oo_urgent_exts); unplug = true; @@ -2557,7 +2558,7 @@ int osc_queue_dio_pages(const struct lu_env *env, struct cl_io *io, { struct client_obd *cli = osc_cli(obj); struct osc_io *oio = osc_env_io(env); - struct osc_async_page *oap; + struct osc_transfer_page *otp; struct osc_extent *ext; struct osc_lock *oscl; struct cl_page *page; @@ -2629,10 +2630,10 @@ int osc_queue_dio_pages(const struct lu_env *env, struct cl_io *io, for (i = from_page; i <= to_page; i++) { page = cdp->cdp_cl_pages[i]; opg = osc_cl_page_osc(page, obj); - oap = &opg->ops_oap; + otp = &opg->ops_otp; osc_consume_write_grant(cli, - &oap->oap_brw_page); + &otp->otp_brw_page); } atomic_long_add(page_count, &obd_dirty_pages); osc_unreserve_grant_nolock(cli, grants, 0); @@ -2680,7 +2681,7 @@ int osc_queue_sync_pages(const struct lu_env *env, struct cl_io *io, struct osc_io *oio = osc_env_io(env); struct client_obd *cli = osc_cli(obj); struct osc_extent *ext; - struct osc_async_page *oap; + struct osc_transfer_page *otp; int page_count = 0; int mppr = cli->cl_max_pages_per_rpc; bool can_merge = true; @@ -2695,8 +2696,8 @@ int osc_queue_sync_pages(const struct lu_env *env, struct cl_io *io, else crt = CRT_WRITE; - list_for_each_entry(oap, list, oap_pending_item) { - struct osc_page *opg = oap2osc_page(oap); + list_for_each_entry(otp, list, otp_pending_item) { + struct osc_page *opg = otp2osc_page(otp); pgoff_t index = osc_index(opg); if (index > end) @@ -2706,17 +2707,17 @@ int osc_queue_sync_pages(const struct lu_env *env, struct cl_io *io, ++page_count; mppr <<= (page_count > mppr); - if (unlikely(oap->oap_count < PAGE_SIZE)) + if (unlikely(otp->otp_count < PAGE_SIZE)) can_merge = false; } ext = osc_extent_alloc(obj); if (ext == NULL) { - struct osc_async_page *tmp; + struct osc_transfer_page *tmp; - list_for_each_entry_safe(oap, tmp, list, oap_pending_item) { - list_del_init(&oap->oap_pending_item); - osc_completion(env, obj, oap, crt, -ENOMEM); + list_for_each_entry_safe(otp, tmp, list, otp_pending_item) { + list_del_init(&otp->otp_pending_item); + osc_completion(env, obj, otp, crt, -ENOMEM); } RETURN(-ENOMEM); } @@ -2748,9 +2749,9 @@ int osc_queue_sync_pages(const struct lu_env *env, struct cl_io *io, CDEBUG(D_CACHE, "requesting %d bytes grant\n", grants); spin_lock(&cli->cl_loi_list_lock); if (osc_reserve_grant(cli, grants) == 0) { - list_for_each_entry(oap, list, oap_pending_item) { + list_for_each_entry(otp, list, otp_pending_item) { osc_consume_write_grant(cli, - &oap->oap_brw_page); + &otp->otp_brw_page); } atomic_long_add(page_count, &obd_dirty_pages); osc_unreserve_grant_nolock(cli, grants, 0); diff --git a/lustre/osc/osc_internal.h b/lustre/osc/osc_internal.h index 361f4f7..eeb8bec 100644 --- a/lustre/osc/osc_internal.h +++ b/lustre/osc/osc_internal.h @@ -32,8 +32,6 @@ #ifndef OSC_INTERNAL_H #define OSC_INTERNAL_H -#define OAP_MAGIC 8675309 - #include #include diff --git a/lustre/osc/osc_io.c b/lustre/osc/osc_io.c index f230ad0..0139c92 100644 --- a/lustre/osc/osc_io.c +++ b/lustre/osc/osc_io.c @@ -170,17 +170,17 @@ int osc_io_submit(const struct lu_env *env, struct cl_io *io, * creation of sub-page-list. */ cl_page_list_for_each_safe(page, tmp, qin) { - struct osc_async_page *oap; + struct osc_transfer_page *otp; LASSERT(top_io != NULL); opg = osc_cl_page_osc(page, osc); - oap = &opg->ops_oap; + otp = &opg->ops_otp; - if (!list_empty(&oap->oap_pending_item) || - !list_empty(&oap->oap_rpc_item)) { - CDEBUG(D_CACHE, "Busy oap %p page %p for submit.\n", - oap, opg); + if (!list_empty(&otp->otp_pending_item) || + !list_empty(&otp->otp_rpc_item)) { + CDEBUG(D_CACHE, "Busy otp %p page %p for submit.\n", + otp, opg); result = -EBUSY; break; } @@ -202,10 +202,10 @@ int osc_io_submit(const struct lu_env *env, struct cl_io *io, } if (!dio) - oap->oap_async_flags = ASYNC_URGENT|ASYNC_READY|ASYNC_COUNT_STABLE; + otp->otp_flags = ASYNC_URGENT|ASYNC_READY|ASYNC_COUNT_STABLE; osc_page_submit(env, opg, crt, brw_flags); - list_add_tail(&oap->oap_pending_item, &list); + list_add_tail(&otp->otp_pending_item, &list); if (page->cp_sync_io != NULL) cl_page_list_move(qout, qin, page); @@ -305,18 +305,18 @@ int osc_dio_submit(const struct lu_env *env, struct cl_io *io, */ for (i = 0; i < cdp->cdp_count; i++) { struct cl_page *page = cdp->cdp_cl_pages[i]; - struct osc_async_page *oap; + struct osc_transfer_page *otp; struct osc_page *opg; LASSERT(top_io != NULL); opg = osc_cl_page_osc(page, osc); - oap = &opg->ops_oap; + otp = &opg->ops_otp; if (from == -1) from = i; osc_dio_page_submit(env, opg, crt, brw_flags); - list_add_tail(&oap->oap_pending_item, &list); + list_add_tail(&otp->otp_pending_item, &list); queued++; total_queued++; @@ -445,21 +445,21 @@ int osc_io_commit_async(const struct lu_env *env, ll_pagevec_init(pvec, 0); while (qin->pl_nr > 0) { - struct osc_async_page *oap; + struct osc_transfer_page *otp; page = cl_page_list_first(qin); opg = osc_cl_page_osc(page, osc); - oap = &opg->ops_oap; + otp = &opg->ops_otp; - if (!list_empty(&oap->oap_rpc_item)) { - CDEBUG(D_CACHE, "Busy oap %p page %p for submit.\n", - oap, opg); + if (!list_empty(&otp->otp_rpc_item)) { + CDEBUG(D_CACHE, "Busy otp %p page %p for submit.\n", + otp, opg); result = -EBUSY; break; } /* The page may be already in dirty cache. */ - if (list_empty(&oap->oap_pending_item)) { + if (list_empty(&otp->otp_pending_item)) { result = osc_page_cache_add(env, osc, opg, io, cb); if (result != 0) break; @@ -628,18 +628,18 @@ static bool trunc_check_cb(const struct lu_env *env, struct cl_io *io, for (i = 0; i < count; i++) { struct osc_page *ops = pvec[i]; struct cl_page *page = ops->ops_cl.cpl_page; - struct osc_async_page *oap; + struct osc_transfer_page *otp; __u64 start = *(__u64 *)cbdata; - oap = &ops->ops_oap; - if (oap->oap_cmd & OBD_BRW_WRITE && - !list_empty(&oap->oap_pending_item)) + otp = &ops->ops_otp; + if (otp->otp_cmd & OBD_BRW_WRITE && + !list_empty(&otp->otp_pending_item)) CL_PAGE_DEBUG(D_ERROR, env, page, "exists %llu/%s.\n", start, current->comm); if (PageLocked(page->cp_vmpage)) CDEBUG(D_CACHE, "page %p index %lu locked for cmd=%d\n", - ops, osc_index(ops), oap->oap_cmd); + ops, osc_index(ops), otp->otp_cmd); } return true; } diff --git a/lustre/osc/osc_object.c b/lustre/osc/osc_object.c index 7f7ab35..50550ec 100644 --- a/lustre/osc/osc_object.c +++ b/lustre/osc/osc_object.c @@ -387,7 +387,7 @@ static void osc_req_attr_set(const struct lu_env *env, struct cl_object *obj, /* if srvlock is set, don't look for a local lock, since we won't use * it and shouldn't note it in the RPC */ - if (flags & OBD_MD_FLHANDLE && !opg->ops_oap.oap_srvlock) { + if (flags & OBD_MD_FLHANDLE && !opg->ops_otp.otp_srvlock) { struct ldlm_lock *lock; lock = osc_dlmlock_at_pgoff(env, cl2osc(obj), osc_index(opg), diff --git a/lustre/osc/osc_page.c b/lustre/osc/osc_page.c index ccc4435..21dc3d0 100644 --- a/lustre/osc/osc_page.c +++ b/lustre/osc/osc_page.c @@ -104,7 +104,7 @@ static int osc_page_print(const struct lu_env *env, void *cookie, lu_printer_t printer) { struct osc_page *opg = cl2osc_page(slice); - struct osc_async_page *oap = &opg->ops_oap; + struct osc_transfer_page *otp = &opg->ops_otp; struct osc_object *obj = osc_page_object(opg); struct client_obd *cli = &osc_export(obj)->exp_obd->u.cli; @@ -116,16 +116,16 @@ static int osc_page_print(const struct lu_env *env, "5< %c %c %c %c | %d %c | %d %c %c>\n", opg, osc_index(opg), /* 1 */ - oap->oap_cmd, - list_empty_marker(&oap->oap_pending_item), - list_empty_marker(&oap->oap_rpc_item), + otp->otp_cmd, + list_empty_marker(&otp->otp_pending_item), + list_empty_marker(&otp->otp_rpc_item), /* 2 */ - oap->oap_obj_off, oap->oap_page_off, oap->oap_count, - oap->oap_async_flags, oap->oap_brw_flags, + otp->otp_obj_off, otp->otp_page_off, otp->otp_count, + otp->otp_flags, otp->otp_brw_flags, cli, obj, /* 3 */ opg->ops_transfer_pinned, - opg->ops_oap.oap_srvlock, + opg->ops_otp.otp_srvlock, /* 4 */ cli->cl_r_in_flight, cli->cl_w_in_flight, cli->cl_max_rpcs_in_flight, @@ -190,13 +190,13 @@ static void osc_page_clip(const struct lu_env *env, int from, int to) { struct osc_page *opg = cl2osc_page(slice); - struct osc_async_page *oap = &opg->ops_oap; + struct osc_transfer_page *otp = &opg->ops_otp; CDEBUG(D_CACHE, "from %d, to %d\n", from, to); - oap->oap_page_off = from; - oap->oap_count = to - from; - oap->oap_async_flags |= ASYNC_COUNT_STABLE; + otp->otp_page_off = from; + otp->otp_count = to - from; + otp->otp_flags |= ASYNC_COUNT_STABLE; } static int osc_page_flush(const struct lu_env *env, @@ -255,7 +255,7 @@ int osc_page_init(const struct lu_env *env, struct cl_io *io, if (result != 0) return result; - opg->ops_oap.oap_srvlock = osc_io_srvlock(oio); + opg->ops_otp.otp_srvlock = osc_io_srvlock(oio); if ((lnet_is_rdma_only_page(cl_page->cp_vmpage) || CFS_FAIL_CHECK(OBD_FAIL_OSC_UNALIGNED_RDMA_ONLY)) && @@ -303,9 +303,9 @@ EXPORT_SYMBOL(osc_page_init); void osc_dio_page_submit(const struct lu_env *env, struct osc_page *opg, enum cl_req_type crt, int brw_flags) { - struct osc_async_page *oap = &opg->ops_oap; + struct osc_transfer_page *otp = &opg->ops_otp; - oap->oap_brw_flags = brw_flags; + otp->otp_brw_flags = brw_flags; } /** @@ -316,17 +316,17 @@ void osc_page_submit(const struct lu_env *env, struct osc_page *opg, enum cl_req_type crt, int brw_flags) { struct osc_object *obj = osc_page_object(opg); - struct osc_async_page *oap = &opg->ops_oap; + struct osc_transfer_page *otp = &opg->ops_otp; struct osc_io *oio = osc_env_io(env); - LASSERT(oap->oap_async_flags & ASYNC_READY); - LASSERT(oap->oap_async_flags & ASYNC_COUNT_STABLE); + LASSERT(otp->otp_flags & ASYNC_READY); + LASSERT(otp->otp_flags & ASYNC_COUNT_STABLE); - oap->oap_cmd = crt == CRT_WRITE ? OBD_BRW_WRITE : OBD_BRW_READ; - oap->oap_brw_flags = OBD_BRW_SYNC | brw_flags; + otp->otp_cmd = crt == CRT_WRITE ? OBD_BRW_WRITE : OBD_BRW_READ; + otp->otp_brw_flags = OBD_BRW_SYNC | brw_flags; if (oio->oi_cap_sys_resource) - oap->oap_brw_flags |= OBD_BRW_SYS_RESOURCE; + otp->otp_brw_flags |= OBD_BRW_SYS_RESOURCE; osc_page_transfer_get(opg, "transfer\0imm"); osc_lru_use(osc_cli(obj), opg); @@ -427,11 +427,11 @@ int lru_queue_work(const struct lu_env *env, void *data) void osc_lru_add_batch(struct client_obd *cli, struct list_head *plist) { LIST_HEAD(lru); - struct osc_async_page *oap; + struct osc_transfer_page *otp; long npages = 0; - list_for_each_entry(oap, plist, oap_pending_item) { - struct osc_page *opg = oap2osc_page(oap); + list_for_each_entry(otp, plist, otp_pending_item) { + struct osc_page *opg = otp2osc_page(otp); if (!opg->ops_in_lru) continue; diff --git a/lustre/osc/osc_request.c b/lustre/osc/osc_request.c index 361efb3..249e484 100644 --- a/lustre/osc/osc_request.c +++ b/lustre/osc/osc_request.c @@ -1526,7 +1526,7 @@ osc_brw_prep_request(int cmd, struct client_obd *cli, struct obdo *oa, ENTRY; if (pga[0]->bp_page) { - clpage = oap2cl_page(brw_page2oap(pga[0])); + clpage = otp2cl_page(brw_page2otp(pga[0])); inode = clpage->cp_inode; if (clpage->cp_type == CPT_TRANSIENT) directio = true; @@ -1594,7 +1594,7 @@ retry_encrypt: map_orig = brwpg->bp_page->mapping; brwpg->bp_page->mapping = inode->i_mapping; index_orig = brwpg->bp_page->index; - clpage = oap2cl_page(brw_page2oap(brwpg)); + clpage = otp2cl_page(brw_page2otp(brwpg)); brwpg->bp_page->index = clpage->cp_page_index; } data_page = @@ -1631,11 +1631,11 @@ retry_encrypt: brwpg->bp_page = data_page; /* there should be no gap in the middle of page array */ if (i == page_count - 1) { - struct osc_async_page *oap = - brw_page2oap(brwpg); + struct osc_transfer_page *otp = + brw_page2otp(brwpg); - oa->o_size = oap->oap_count + - oap->oap_obj_off + oap->oap_page_off; + oa->o_size = otp->otp_count + + otp->otp_obj_off + otp->otp_page_off; } /* len is forced to nunits, and relative offset to 0 * so store the old, clear text info @@ -1709,7 +1709,7 @@ retry_encrypt: } } - if (brw_page2oap(pga[0])->oap_brw_flags & OBD_BRW_RDMA_ONLY) { + if (brw_page2otp(pga[0])->otp_brw_flags & OBD_BRW_RDMA_ONLY) { enable_checksum = false; short_io_size = 0; gpu = 1; @@ -1949,7 +1949,7 @@ no_bulk: aa->aa_ppga = pga; aa->aa_cli = cli; aa->aa_obj = clobj; - INIT_LIST_HEAD(&aa->aa_oaps); + INIT_LIST_HEAD(&aa->aa_otps); *reqp = req; niobuf = req_capsule_client_get(pill, &RMF_NIOBUF_REMOTE); @@ -2319,7 +2319,7 @@ static int osc_brw_fini_request(struct ptlrpc_request *req, int rc) } /* get the inode from the first cl_page */ - clpage = oap2cl_page(brw_page2oap(aa->aa_ppga[0])); + clpage = otp2cl_page(brw_page2otp(aa->aa_ppga[0])); inode = clpage->cp_inode; if (clpage->cp_type == CPT_TRANSIENT && inode) { blockbits = inode->i_blkbits; @@ -2359,7 +2359,7 @@ static int osc_brw_fini_request(struct ptlrpc_request *req, int rc) unsigned int i; clpage = - oap2cl_page(brw_page2oap(brwpg)); + otp2cl_page(brw_page2otp(brwpg)); lblk_num = ((u64)(clpage->cp_page_index) << (PAGE_SHIFT - blockbits)) + @@ -2420,7 +2420,7 @@ static int osc_brw_redo_request(struct ptlrpc_request *request, "request %p != aa_request %p\n", request, aa->aa_request); /* - * New request takes over pga and oaps from old request. + * New request takes over pga and otps from old request. * Note that copying a list_head doesn't work, need to move it... */ aa->aa_resends++; @@ -2438,8 +2438,8 @@ static int osc_brw_redo_request(struct ptlrpc_request *request, new_aa = ptlrpc_req_async_args(new_aa, new_req); - INIT_LIST_HEAD(&new_aa->aa_oaps); - list_splice_init(&aa->aa_oaps, &new_aa->aa_oaps); + INIT_LIST_HEAD(&new_aa->aa_otps); + list_splice_init(&aa->aa_otps, &new_aa->aa_otps); INIT_LIST_HEAD(&new_aa->aa_exts); list_splice_init(&aa->aa_exts, &new_aa->aa_exts); new_aa->aa_resends = aa->aa_resends; @@ -2525,7 +2525,7 @@ static int brw_interpret(const struct lu_env *env, struct osc_brw_async_args *aa = args; struct client_obd *cli = aa->aa_cli; unsigned long transferred = 0; - struct osc_async_page *last; + struct osc_transfer_page *last; struct osc_extent *ext; struct osc_extent *tmp; struct lov_oinfo *loi; @@ -2568,7 +2568,7 @@ static int brw_interpret(const struct lu_env *env, rc = -EIO; } - last = brw_page2oap(aa->aa_ppga[aa->aa_page_count - 1]); + last = brw_page2otp(aa->aa_ppga[aa->aa_page_count - 1]); obj = osc2cl(ext->oe_obj); loi = cl2osc(obj)->oo_oinfo; @@ -2596,8 +2596,8 @@ static int brw_interpret(const struct lu_env *env, } if (lustre_msg_get_opc(req->rq_reqmsg) == OST_WRITE) { - loff_t last_off = last->oap_count + last->oap_obj_off + - last->oap_page_off; + loff_t last_off = last->otp_count + last->otp_obj_off + + last->otp_page_off; /* Change file size if this is an out of quota or * direct IO write and it extends the file size */ @@ -2607,7 +2607,7 @@ static int brw_interpret(const struct lu_env *env, } /* Extend KMS if it's not a lockless write */ if (loi->loi_kms < last_off && - last->oap_srvlock == 0) { + last->otp_srvlock == 0) { attr->cat_kms = last_off; valid |= CAT_KMS; } @@ -2640,7 +2640,7 @@ static int brw_interpret(const struct lu_env *env, rc && req->rq_no_delay ? -EAGAIN : rc); } LASSERT(list_empty(&aa->aa_exts)); - LASSERT(list_empty(&aa->aa_oaps)); + LASSERT(list_empty(&aa->aa_otps)); transferred = (req->rq_bulk == NULL ? /* short io */ aa->aa_requested_nob : @@ -2695,7 +2695,7 @@ int osc_build_rpc(const struct lu_env *env, struct client_obd *cli, struct brw_page **pga = NULL; struct osc_brw_async_args *aa = NULL; struct obdo *oa = NULL; - struct osc_async_page *oap; + struct osc_transfer_page *otp; struct osc_object *obj = NULL; struct cl_req_attr *crattr = NULL; loff_t starting_offset = OBD_OBJECT_EOF; @@ -2740,29 +2740,29 @@ int osc_build_rpc(const struct lu_env *env, struct client_obd *cli, i = 0; list_for_each_entry(ext, ext_list, oe_link) { - list_for_each_entry(oap, &ext->oe_pages, oap_pending_item) { + list_for_each_entry(otp, &ext->oe_pages, otp_pending_item) { if (mem_tight) - oap->oap_brw_flags |= OBD_BRW_MEMALLOC; + otp->otp_brw_flags |= OBD_BRW_MEMALLOC; if (soft_sync) - oap->oap_brw_flags |= OBD_BRW_SOFT_SYNC; - pga[i] = &oap->oap_brw_page; - pga[i]->bp_off = oap->oap_obj_off + oap->oap_page_off; + otp->otp_brw_flags |= OBD_BRW_SOFT_SYNC; + pga[i] = &otp->otp_brw_page; + pga[i]->bp_off = otp->otp_obj_off + otp->otp_page_off; i++; - list_add_tail(&oap->oap_rpc_item, &rpc_list); + list_add_tail(&otp->otp_rpc_item, &rpc_list); if (starting_offset == OBD_OBJECT_EOF || - starting_offset > oap->oap_obj_off) { - starting_offset = oap->oap_obj_off; + starting_offset > otp->otp_obj_off) { + starting_offset = otp->otp_obj_off; } else { - CDEBUG(D_CACHE, "page i:%d, oap->oap_obj_off %llu, oap->oap_page_off %u\n", - i, oap->oap_obj_off, oap->oap_page_off); - LASSERT(oap->oap_page_off == 0); + CDEBUG(D_CACHE, "page i:%d, otp->otp_obj_off %llu, otp->otp_page_off %u\n", + i, otp->otp_obj_off, otp->otp_page_off); + LASSERT(otp->otp_page_off == 0); } - if (ending_offset < oap->oap_obj_off + oap->oap_count) { - ending_offset = oap->oap_obj_off + - oap->oap_count; + if (ending_offset < otp->otp_obj_off + otp->otp_count) { + ending_offset = otp->otp_obj_off + + otp->otp_count; } else { - LASSERT(oap->oap_page_off + oap->oap_count == + LASSERT(otp->otp_page_off + otp->otp_count == PAGE_SIZE); } } @@ -2771,13 +2771,13 @@ int osc_build_rpc(const struct lu_env *env, struct client_obd *cli, } /* first page in the list */ - oap = list_first_entry(&rpc_list, typeof(*oap), oap_rpc_item); + otp = list_first_entry(&rpc_list, typeof(*otp), otp_rpc_item); crattr = &osc_env_info(env)->oti_req_attr; memset(crattr, 0, sizeof(*crattr)); crattr->cra_type = (cmd & OBD_BRW_WRITE) ? CRT_WRITE : CRT_READ; crattr->cra_flags = ~0ULL; - crattr->cra_page = oap2cl_page(oap); + crattr->cra_page = otp2cl_page(otp); crattr->cra_oa = oa; cl_req_attr_set(env, osc2cl(obj), crattr); @@ -2824,8 +2824,8 @@ int osc_build_rpc(const struct lu_env *env, struct client_obd *cli, lustre_msg_set_jobid(req->rq_reqmsg, crattr->cra_jobid); aa = ptlrpc_req_async_args(aa, req); - INIT_LIST_HEAD(&aa->aa_oaps); - list_splice_init(&rpc_list, &aa->aa_oaps); + INIT_LIST_HEAD(&aa->aa_otps); + list_splice_init(&rpc_list, &aa->aa_otps); INIT_LIST_HEAD(&aa->aa_exts); list_splice_init(ext_list, &aa->aa_exts); aa->aa_request = ptlrpc_request_addref(req); -- 1.8.3.1