From 2f103489f6148d7fc12425dc9d0e3b0c5f8e9055 Mon Sep 17 00:00:00 2001 From: Mikhal Pershin Date: Fri, 11 Dec 2015 13:18:17 +0300 Subject: [PATCH] LU-3285 mdc: add IO stats in mdc Add IO statistic into MDC like in OSC Signed-off-by: Mikhal Pershin Change-Id: I2763ef56fe5dac5c7f04309ce81bbed7b71af37d Reviewed-on: https://review.whamcloud.com/28019 Reviewed-by: Jinshan Xiong Reviewed-by: Andreas Dilger --- lustre/include/lustre_dlm.h | 33 +++++ lustre/include/lustre_osc.h | 3 + lustre/ldlm/ldlm_lockd.c | 38 +----- lustre/ldlm/ldlm_request.c | 22 ++++ lustre/mdc/lproc_mdc.c | 315 ++++++++++++++++++++++++++++++++++++++++++-- lustre/mdc/mdc_request.c | 1 + lustre/mdt/mdt_handler.c | 35 +++-- lustre/obdclass/genops.c | 2 + lustre/ofd/ofd_dlm.c | 5 + lustre/osc/osc_cache.c | 2 + lustre/osc/osc_internal.h | 2 - lustre/osc/osc_page.c | 1 + 12 files changed, 401 insertions(+), 58 deletions(-) diff --git a/lustre/include/lustre_dlm.h b/lustre/include/lustre_dlm.h index 5f1dc20..1c6a8d8 100644 --- a/lustre/include/lustre_dlm.h +++ b/lustre/include/lustre_dlm.h @@ -1490,8 +1490,41 @@ void ldlm_namespace_put(struct ldlm_namespace *ns); int ldlm_proc_setup(void); #ifdef CONFIG_PROC_FS void ldlm_proc_cleanup(void); + +static inline void ldlm_svc_get_eopc(const struct ldlm_request *dlm_req, + struct lprocfs_stats *srv_stats) +{ + int lock_type = 0, op = 0; + + lock_type = dlm_req->lock_desc.l_resource.lr_type; + + switch (lock_type) { + case LDLM_PLAIN: + op = PTLRPC_LAST_CNTR + LDLM_PLAIN_ENQUEUE; + break; + case LDLM_EXTENT: + op = PTLRPC_LAST_CNTR + LDLM_EXTENT_ENQUEUE; + break; + case LDLM_FLOCK: + op = PTLRPC_LAST_CNTR + LDLM_FLOCK_ENQUEUE; + break; + case LDLM_IBITS: + op = PTLRPC_LAST_CNTR + LDLM_IBITS_ENQUEUE; + break; + default: + op = 0; + break; + } + + if (op != 0) + lprocfs_counter_incr(srv_stats, op); + + return; +} #else static inline void ldlm_proc_cleanup(void) {} +static inline void ldlm_svc_get_eopc(const struct ldlm_request *dlm_req, + struct lprocfs_stats *srv_stats) {} #endif /* resource.c - internal */ diff --git a/lustre/include/lustre_osc.h b/lustre/include/lustre_osc.h index f9777bb..d2a3d8d 100644 --- a/lustre/include/lustre_osc.h +++ b/lustre/include/lustre_osc.h @@ -565,6 +565,8 @@ void osc_lru_add_batch(struct client_obd *cli, struct list_head *list); void osc_page_submit(const struct lu_env *env, struct osc_page *opg, enum cl_req_type crt, int brw_flags); int lru_queue_work(const struct lu_env *env, void *data); +long osc_lru_shrink(const struct lu_env *env, struct client_obd *cli, + long target, bool force); /* osc_cache.c */ int osc_cancel_async_page(const struct lu_env *env, struct osc_page *ops); @@ -591,6 +593,7 @@ int osc_cache_wait_range(const struct lu_env *env, struct osc_object *obj, pgoff_t start, pgoff_t end); int osc_io_unplug0(const struct lu_env *env, struct client_obd *cli, struct osc_object *osc, int async); +void osc_wake_cache_waiters(struct client_obd *cli); static inline int osc_io_unplug_async(const struct lu_env *env, struct client_obd *cli, diff --git a/lustre/ldlm/ldlm_lockd.c b/lustre/ldlm/ldlm_lockd.c index 2396a6c..383b391 100644 --- a/lustre/ldlm/ldlm_lockd.c +++ b/lustre/ldlm/ldlm_lockd.c @@ -1185,40 +1185,6 @@ struct ldlm_lock *ldlm_request_lock(struct ptlrpc_request *req) } EXPORT_SYMBOL(ldlm_request_lock); -static void ldlm_svc_get_eopc(const struct ldlm_request *dlm_req, - struct lprocfs_stats *srv_stats) -{ - int lock_type = 0, op = 0; - - lock_type = dlm_req->lock_desc.l_resource.lr_type; - - switch (lock_type) { - case LDLM_PLAIN: - op = PTLRPC_LAST_CNTR + LDLM_PLAIN_ENQUEUE; - break; - case LDLM_EXTENT: - if (dlm_req->lock_flags & LDLM_FL_HAS_INTENT) - op = PTLRPC_LAST_CNTR + LDLM_GLIMPSE_ENQUEUE; - else - op = PTLRPC_LAST_CNTR + LDLM_EXTENT_ENQUEUE; - break; - case LDLM_FLOCK: - op = PTLRPC_LAST_CNTR + LDLM_FLOCK_ENQUEUE; - break; - case LDLM_IBITS: - op = PTLRPC_LAST_CNTR + LDLM_IBITS_ENQUEUE; - break; - default: - op = 0; - break; - } - - if (op) - lprocfs_counter_incr(srv_stats, op); - - return; -} - /** * Main server-side entry point into LDLM for enqueue. This is called by ptlrpc * service threads to carry out client lock enqueueing requests. @@ -1244,7 +1210,9 @@ int ldlm_handle_enqueue0(struct ldlm_namespace *ns, LASSERT(req->rq_export); - if (ptlrpc_req2svc(req)->srv_stats != NULL) + /* for intent enqueue the stat will be updated inside intent policy */ + if (ptlrpc_req2svc(req)->srv_stats != NULL && + !(dlm_req->lock_flags & LDLM_FL_HAS_INTENT)) ldlm_svc_get_eopc(dlm_req, ptlrpc_req2svc(req)->srv_stats); if (req->rq_export && req->rq_export->exp_nid_stats && diff --git a/lustre/ldlm/ldlm_request.c b/lustre/ldlm/ldlm_request.c index 2d0835f..72f0049 100644 --- a/lustre/ldlm/ldlm_request.c +++ b/lustre/ldlm/ldlm_request.c @@ -976,6 +976,28 @@ int ldlm_cli_enqueue(struct obd_export *exp, struct ptlrpc_request **reqp, body->lock_flags = ldlm_flags_to_wire(*flags); body->lock_handle[0] = *lockh; + /* extended LDLM opcodes in client stats */ + if (exp->exp_obd->obd_svc_stats != NULL) { + bool glimpse = *flags & LDLM_FL_HAS_INTENT; + + /* OST glimpse has no intent buffer */ + if (req_capsule_has_field(&req->rq_pill, &RMF_LDLM_INTENT, + RCL_CLIENT)) { + struct ldlm_intent *it; + + it = req_capsule_client_get(&req->rq_pill, + &RMF_LDLM_INTENT); + glimpse = (it && (it->opc == IT_GLIMPSE)); + } + + if (!glimpse) + ldlm_svc_get_eopc(body, exp->exp_obd->obd_svc_stats); + else + lprocfs_counter_incr(exp->exp_obd->obd_svc_stats, + PTLRPC_LAST_CNTR + + LDLM_GLIMPSE_ENQUEUE); + } + if (async) { LASSERT(reqp != NULL); RETURN(0); diff --git a/lustre/mdc/lproc_mdc.c b/lustre/mdc/lproc_mdc.c index f9818e3..ff148f1 100644 --- a/lustre/mdc/lproc_mdc.c +++ b/lustre/mdc/lproc_mdc.c @@ -35,6 +35,8 @@ #include #include #include +#include +#include #include "mdc_internal.h" @@ -75,6 +77,161 @@ static ssize_t mdc_active_seq_write(struct file *file, } LPROC_SEQ_FOPS(mdc_active); +static int mdc_max_dirty_mb_seq_show(struct seq_file *m, void *v) +{ + struct obd_device *dev = m->private; + struct client_obd *cli = &dev->u.cli; + long val; + int mult; + + spin_lock(&cli->cl_loi_list_lock); + val = cli->cl_dirty_max_pages; + spin_unlock(&cli->cl_loi_list_lock); + + mult = 1 << (20 - PAGE_SHIFT); + return lprocfs_seq_read_frac_helper(m, val, mult); +} + +static ssize_t mdc_max_dirty_mb_seq_write(struct file *file, + const char __user *buffer, + size_t count, loff_t *off) +{ + struct seq_file *sfl = file->private_data; + struct obd_device *dev = sfl->private; + struct client_obd *cli = &dev->u.cli; + __s64 pages_number; + int rc; + + rc = lprocfs_str_with_units_to_s64(buffer, count, &pages_number, 'M'); + if (rc) + return rc; + + pages_number >>= PAGE_SHIFT; + + if (pages_number <= 0 || + pages_number >= OSC_MAX_DIRTY_MB_MAX << (20 - PAGE_SHIFT) || + pages_number > totalram_pages / 4) /* 1/4 of RAM */ + return -ERANGE; + + spin_lock(&cli->cl_loi_list_lock); + cli->cl_dirty_max_pages = pages_number; + osc_wake_cache_waiters(cli); + spin_unlock(&cli->cl_loi_list_lock); + + return count; +} +LPROC_SEQ_FOPS(mdc_max_dirty_mb); + +static int mdc_cached_mb_seq_show(struct seq_file *m, void *v) +{ + struct obd_device *dev = m->private; + struct client_obd *cli = &dev->u.cli; + int shift = 20 - PAGE_SHIFT; + + seq_printf(m, "used_mb: %ld\n" + "busy_cnt: %ld\n" + "reclaim: %llu\n", + (atomic_long_read(&cli->cl_lru_in_list) + + atomic_long_read(&cli->cl_lru_busy)) >> shift, + atomic_long_read(&cli->cl_lru_busy), + cli->cl_lru_reclaim); + + return 0; +} + +/* shrink the number of caching pages to a specific number */ +static ssize_t +mdc_cached_mb_seq_write(struct file *file, const char __user *buffer, + size_t count, loff_t *off) +{ + struct seq_file *sfl = file->private_data; + struct obd_device *dev = sfl->private; + struct client_obd *cli = &dev->u.cli; + __s64 pages_number; + long rc; + char kernbuf[128]; + + if (count >= sizeof(kernbuf)) + return -EINVAL; + + if (copy_from_user(kernbuf, buffer, count)) + return -EFAULT; + kernbuf[count] = 0; + + buffer += lprocfs_find_named_value(kernbuf, "used_mb:", &count) - + kernbuf; + rc = lprocfs_str_with_units_to_s64(buffer, count, &pages_number, 'M'); + if (rc) + return rc; + + pages_number >>= PAGE_SHIFT; + + if (pages_number < 0) + return -ERANGE; + + rc = atomic_long_read(&cli->cl_lru_in_list) - pages_number; + if (rc > 0) { + struct lu_env *env; + __u16 refcheck; + + env = cl_env_get(&refcheck); + if (!IS_ERR(env)) { + (void)osc_lru_shrink(env, cli, rc, true); + cl_env_put(env, &refcheck); + } + } + + return count; +} +LPROC_SEQ_FOPS(mdc_cached_mb); + +static int mdc_contention_seconds_seq_show(struct seq_file *m, void *v) +{ + struct obd_device *obd = m->private; + struct osc_device *od = obd2osc_dev(obd); + + seq_printf(m, "%u\n", od->od_contention_time); + return 0; +} + +static ssize_t mdc_contention_seconds_seq_write(struct file *file, + const char __user *buffer, + size_t count, loff_t *off) +{ + struct seq_file *sfl = file->private_data; + struct obd_device *obd = sfl->private; + struct osc_device *od = obd2osc_dev(obd); + int rc; + __s64 val; + + rc = lprocfs_str_to_s64(buffer, count, &val); + if (rc) + return rc; + if (val < 0 || val > INT_MAX) + return -ERANGE; + + od->od_contention_time = val; + + return count; +} +LPROC_SEQ_FOPS(mdc_contention_seconds); + +static int mdc_unstable_stats_seq_show(struct seq_file *m, void *v) +{ + struct obd_device *dev = m->private; + struct client_obd *cli = &dev->u.cli; + long pages; + int mb; + + pages = atomic_long_read(&cli->cl_unstable_count); + mb = (pages * PAGE_SIZE) >> 20; + + seq_printf(m, "unstable_pages: %20ld\n" + "unstable_mb: %10d\n", pages, mb); + return 0; +} +LPROC_SEQ_FOPS_RO(mdc_unstable_stats); + static int mdc_max_rpcs_in_flight_seq_show(struct seq_file *m, void *v) { struct obd_device *dev = m->private; @@ -125,11 +282,11 @@ static ssize_t mdc_max_mod_rpcs_in_flight_seq_write(struct file *file, const char __user *buffer, size_t count, loff_t *off) { - struct obd_device *dev = - ((struct seq_file *)file->private_data)->private; + struct obd_device *dev; __s64 val; int rc; + dev = ((struct seq_file *)file->private_data)->private; rc = lprocfs_str_to_s64(buffer, count, &val); if (rc) return rc; @@ -145,13 +302,6 @@ static ssize_t mdc_max_mod_rpcs_in_flight_seq_write(struct file *file, } LPROC_SEQ_FOPS(mdc_max_mod_rpcs_in_flight); -static int mdc_rpc_stats_seq_show(struct seq_file *seq, void *v) -{ - struct obd_device *dev = seq->private; - - return obd_mod_rpc_stats_seq_show(&dev->u.cli, seq); -} - static ssize_t mdc_rpc_stats_seq_write(struct file *file, const char __user *buf, size_t len, loff_t *off) @@ -162,10 +312,144 @@ static ssize_t mdc_rpc_stats_seq_write(struct file *file, lprocfs_oh_clear(&cli->cl_mod_rpcs_hist); + lprocfs_oh_clear(&cli->cl_read_rpc_hist); + lprocfs_oh_clear(&cli->cl_write_rpc_hist); + lprocfs_oh_clear(&cli->cl_read_page_hist); + lprocfs_oh_clear(&cli->cl_write_page_hist); + lprocfs_oh_clear(&cli->cl_read_offset_hist); + lprocfs_oh_clear(&cli->cl_write_offset_hist); + return len; } + +#define pct(a, b) (b ? a * 100 / b : 0) +static int mdc_rpc_stats_seq_show(struct seq_file *seq, void *v) +{ + struct obd_device *dev = seq->private; + struct client_obd *cli = &dev->u.cli; + unsigned long read_tot = 0, write_tot = 0, read_cum, write_cum; + int i; + + obd_mod_rpc_stats_seq_show(&dev->u.cli, seq); + + spin_lock(&cli->cl_loi_list_lock); + + seq_printf(seq, "\nread RPCs in flight: %d\n", + cli->cl_r_in_flight); + seq_printf(seq, "write RPCs in flight: %d\n", + cli->cl_w_in_flight); + seq_printf(seq, "pending write pages: %d\n", + atomic_read(&cli->cl_pending_w_pages)); + seq_printf(seq, "pending read pages: %d\n", + atomic_read(&cli->cl_pending_r_pages)); + + seq_printf(seq, "\n\t\t\tread\t\t\twrite\n"); + seq_printf(seq, "pages per rpc rpcs %% cum %% |"); + seq_printf(seq, " rpcs %% cum %%\n"); + + read_tot = lprocfs_oh_sum(&cli->cl_read_page_hist); + write_tot = lprocfs_oh_sum(&cli->cl_write_page_hist); + + read_cum = 0; + write_cum = 0; + for (i = 0; i < OBD_HIST_MAX; i++) { + unsigned long r = cli->cl_read_page_hist.oh_buckets[i]; + unsigned long w = cli->cl_write_page_hist.oh_buckets[i]; + + read_cum += r; + write_cum += w; + seq_printf(seq, "%d:\t\t%10lu %3lu %3lu | %10lu %3lu %3lu\n", + 1 << i, r, pct(r, read_tot), + pct(read_cum, read_tot), w, + pct(w, write_tot), + pct(write_cum, write_tot)); + if (read_cum == read_tot && write_cum == write_tot) + break; + } + + seq_printf(seq, "\n\t\t\tread\t\t\twrite\n"); + seq_printf(seq, "rpcs in flight rpcs %% cum %% |"); + seq_printf(seq, " rpcs %% cum %%\n"); + + read_tot = lprocfs_oh_sum(&cli->cl_read_rpc_hist); + write_tot = lprocfs_oh_sum(&cli->cl_write_rpc_hist); + + read_cum = 0; + write_cum = 0; + for (i = 0; i < OBD_HIST_MAX; i++) { + unsigned long r = cli->cl_read_rpc_hist.oh_buckets[i]; + unsigned long w = cli->cl_write_rpc_hist.oh_buckets[i]; + + read_cum += r; + write_cum += w; + seq_printf(seq, "%d:\t\t%10lu %3lu %3lu | %10lu %3lu %3lu\n", + i, r, pct(r, read_tot), pct(read_cum, read_tot), w, + pct(w, write_tot), pct(write_cum, write_tot)); + if (read_cum == read_tot && write_cum == write_tot) + break; + } + + seq_printf(seq, "\n\t\t\tread\t\t\twrite\n"); + seq_printf(seq, "offset rpcs %% cum %% |"); + seq_printf(seq, " rpcs %% cum %%\n"); + + read_tot = lprocfs_oh_sum(&cli->cl_read_offset_hist); + write_tot = lprocfs_oh_sum(&cli->cl_write_offset_hist); + + read_cum = 0; + write_cum = 0; + for (i = 0; i < OBD_HIST_MAX; i++) { + unsigned long r = cli->cl_read_offset_hist.oh_buckets[i]; + unsigned long w = cli->cl_write_offset_hist.oh_buckets[i]; + + read_cum += r; + write_cum += w; + seq_printf(seq, "%d:\t\t%10lu %3lu %3lu | %10lu %3lu %3lu\n", + (i == 0) ? 0 : 1 << (i - 1), + r, pct(r, read_tot), pct(read_cum, read_tot), + w, pct(w, write_tot), pct(write_cum, write_tot)); + if (read_cum == read_tot && write_cum == write_tot) + break; + } + spin_unlock(&cli->cl_loi_list_lock); + + return 0; +} +#undef pct LPROC_SEQ_FOPS(mdc_rpc_stats); +static int mdc_stats_seq_show(struct seq_file *seq, void *v) +{ + struct timeval now; + struct obd_device *dev = seq->private; + struct osc_stats *stats = &obd2osc_dev(dev)->od_stats; + + do_gettimeofday(&now); + + seq_printf(seq, "snapshot_time: %lu.%lu (secs.usecs)\n", + now.tv_sec, now.tv_usec); + seq_printf(seq, "lockless_write_bytes\t\t%llu\n", + stats->os_lockless_writes); + seq_printf(seq, "lockless_read_bytes\t\t%llu\n", + stats->os_lockless_reads); + seq_printf(seq, "lockless_truncate\t\t%llu\n", + stats->os_lockless_truncates); + return 0; +} + +static ssize_t mdc_stats_seq_write(struct file *file, + const char __user *buf, + size_t len, loff_t *off) +{ + struct seq_file *seq = file->private_data; + struct obd_device *dev = seq->private; + struct osc_stats *stats = &obd2osc_dev(dev)->od_stats; + + memset(stats, 0, sizeof(*stats)); + return len; +} +LPROC_SEQ_FOPS(mdc_stats); + LPROC_SEQ_FOPS_WR_ONLY(mdc, ping); LPROC_SEQ_FOPS_RO_TYPE(mdc, connect_flags); @@ -192,9 +476,15 @@ struct lprocfs_vars lprocfs_mdc_obd_vars[] = { { .name = "max_rpcs_in_flight", .fops = &mdc_max_rpcs_in_flight_fops }, { .name = "max_mod_rpcs_in_flight", - .fops = &mdc_max_mod_rpcs_in_flight_fops }, + .fops = &mdc_max_mod_rpcs_in_flight_fops }, + { .name = "max_dirty_mb", + .fops = &mdc_max_dirty_mb_fops }, + { .name = "mdc_cached_mb", + .fops = &mdc_cached_mb_fops }, { .name = "timeouts", .fops = &mdc_timeouts_fops }, + { .name = "contention_seconds", + .fops = &mdc_contention_seconds_fops }, { .name = "import", .fops = &mdc_import_fops }, { .name = "state", @@ -205,6 +495,11 @@ struct lprocfs_vars lprocfs_mdc_obd_vars[] = { .fops = &mdc_rpc_stats_fops }, { .name = "active", .fops = &mdc_active_fops }, + { .name = "unstable_stats", + .fops = &mdc_unstable_stats_fops }, + { .name = "mdc_stats", + .fops = &mdc_stats_fops }, { NULL } }; + #endif /* CONFIG_PROC_FS */ diff --git a/lustre/mdc/mdc_request.c b/lustre/mdc/mdc_request.c index 76e0247..411552c 100644 --- a/lustre/mdc/mdc_request.c +++ b/lustre/mdc/mdc_request.c @@ -2511,6 +2511,7 @@ int mdc_setup(struct obd_device *obd, struct lustre_cfg *cfg) lprocfs_obd_setup(obd, false); lprocfs_alloc_md_stats(obd, 0); #endif + sptlrpc_lprocfs_cliobd_attach(obd); ptlrpc_lprocfs_register_obd(obd); diff --git a/lustre/mdt/mdt_handler.c b/lustre/mdt/mdt_handler.c index 7bd6531..2791ad3 100644 --- a/lustre/mdt/mdt_handler.c +++ b/lustre/mdt/mdt_handler.c @@ -3983,6 +3983,18 @@ static int mdt_intent_opc(enum ldlm_intent_flags itopc, RETURN(rc); } +static void mdt_ptlrpc_stats_update(struct ptlrpc_request *req, + enum ldlm_intent_flags it_opc) +{ + struct lprocfs_stats *srv_stats = ptlrpc_req2svc(req)->srv_stats; + + /* update stats when IT code is known */ + if (srv_stats != NULL) + lprocfs_counter_incr(srv_stats, + PTLRPC_LAST_CNTR + (it_opc == IT_GLIMPSE ? + LDLM_GLIMPSE_ENQUEUE : LDLM_IBITS_ENQUEUE)); +} + static int mdt_intent_policy(struct ldlm_namespace *ns, struct ldlm_lock **lockp, void *req_cookie, enum ldlm_mode mode, __u64 flags, void *data) @@ -4009,17 +4021,18 @@ static int mdt_intent_policy(struct ldlm_namespace *ns, if (req->rq_reqmsg->lm_bufcount > DLM_INTENT_IT_OFF) { req_capsule_extend(pill, &RQF_LDLM_INTENT_BASIC); - it = req_capsule_client_get(pill, &RMF_LDLM_INTENT); - if (it != NULL) { - rc = mdt_intent_opc(it->opc, info, lockp, flags); - if (rc == 0) - rc = ELDLM_OK; - - /* Lock without inodebits makes no sense and will oops - * later in ldlm. Let's check it now to see if we have - * ibits corrupted somewhere in mdt_intent_opc(). - * The case for client miss to set ibits has been - * processed by others. */ + it = req_capsule_client_get(pill, &RMF_LDLM_INTENT); + if (it != NULL) { + mdt_ptlrpc_stats_update(req, it->opc); + rc = mdt_intent_opc(it->opc, info, lockp, flags); + if (rc == 0) + rc = ELDLM_OK; + + /* Lock without inodebits makes no sense and will oops + * later in ldlm. Let's check it now to see if we have + * ibits corrupted somewhere in mdt_intent_opc(). + * The case for client miss to set ibits has been + * processed by others. */ LASSERT(ergo(ldesc->l_resource.lr_type == LDLM_IBITS, ldesc->l_policy_data.l_inodebits.bits != 0)); } else { diff --git a/lustre/obdclass/genops.c b/lustre/obdclass/genops.c index f5f17c4..6799c0c 100644 --- a/lustre/obdclass/genops.c +++ b/lustre/obdclass/genops.c @@ -2085,6 +2085,8 @@ int obd_set_max_rpcs_in_flight(struct client_obd *cli, __u32 max) spin_lock(&cli->cl_loi_list_lock); old = cli->cl_max_rpcs_in_flight; cli->cl_max_rpcs_in_flight = max; + client_adjust_max_dirty(cli); + diff = max - old; /* We increase the max_rpcs_in_flight, then wakeup some waiters. */ diff --git a/lustre/ofd/ofd_dlm.c b/lustre/ofd/ofd_dlm.c index a96a91d..76e2bd7 100644 --- a/lustre/ofd/ofd_dlm.c +++ b/lustre/ofd/ofd_dlm.c @@ -235,6 +235,11 @@ int ofd_intent_policy(struct ldlm_namespace *ns, struct ldlm_lock **lockp, struct ldlm_glimpse_work *pos, *tmp; ENTRY; + /* update stats for intent in intent policy */ + if (ptlrpc_req2svc(req)->srv_stats != NULL) + lprocfs_counter_incr(ptlrpc_req2svc(req)->srv_stats, + PTLRPC_LAST_CNTR + LDLM_GLIMPSE_ENQUEUE); + INIT_LIST_HEAD(&arg.gl_list); arg.no_glimpse_ast = false; arg.error = 0; diff --git a/lustre/osc/osc_cache.c b/lustre/osc/osc_cache.c index 814af07..f35d7bf 100644 --- a/lustre/osc/osc_cache.c +++ b/lustre/osc/osc_cache.c @@ -1706,6 +1706,7 @@ wakeup: EXIT; } +EXPORT_SYMBOL(osc_wake_cache_waiters); static int osc_max_rpc_in_flight(struct client_obd *cli, struct osc_object *osc) { @@ -2532,6 +2533,7 @@ int osc_queue_async_io(const struct lu_env *env, struct cl_io *io, list_add_tail(&oap->oap_pending_item, &ext->oe_pages); osc_object_unlock(osc); } + RETURN(rc); } diff --git a/lustre/osc/osc_internal.h b/lustre/osc/osc_internal.h index 4fdfb13..16b8666 100644 --- a/lustre/osc/osc_internal.h +++ b/lustre/osc/osc_internal.h @@ -79,8 +79,6 @@ int osc_ladvise_base(struct obd_export *exp, struct obdo *oa, int osc_process_config_base(struct obd_device *obd, struct lustre_cfg *cfg); int osc_build_rpc(const struct lu_env *env, struct client_obd *cli, struct list_head *ext_list, int cmd); -long osc_lru_shrink(const struct lu_env *env, struct client_obd *cli, - long target, bool force); unsigned long osc_lru_reserve(struct client_obd *cli, unsigned long npages); void osc_lru_unreserve(struct client_obd *cli, unsigned long npages); diff --git a/lustre/osc/osc_page.c b/lustre/osc/osc_page.c index d53725c..6813f12 100644 --- a/lustre/osc/osc_page.c +++ b/lustre/osc/osc_page.c @@ -685,6 +685,7 @@ long osc_lru_shrink(const struct lu_env *env, struct client_obd *cli, } RETURN(count > 0 ? count : rc); } +EXPORT_SYMBOL(osc_lru_shrink); /** * Reclaim LRU pages by an IO thread. The caller wants to reclaim at least -- 1.8.3.1