X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Fldlm%2Fldlm_pool.c;h=a526f08e7ba572ff81fdd8677ea068213199f6bb;hb=2ec741f46ac31cb566ea17d8ffda122398896102;hp=feb11d0bd05e659af8ec4b4b1b8afac9aff813d5;hpb=d016a086b68ca4af2dcbfefc3917b9291efd8d62;p=fs%2Flustre-release.git diff --git a/lustre/ldlm/ldlm_pool.c b/lustre/ldlm/ldlm_pool.c index feb11d0..a526f08 100644 --- a/lustre/ldlm/ldlm_pool.c +++ b/lustre/ldlm/ldlm_pool.c @@ -1,6 +1,4 @@ -/* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*- - * vim:expandtab:shiftwidth=8:tabstop=8: - * +/* * GPL HEADER START * * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. @@ -29,7 +27,7 @@ * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved. * Use is subject to license terms. * - * Copyright (c) 2011, 2012, Whamcloud, Inc. + * Copyright (c) 2010, 2012, Intel Corporation. */ /* * This file is part of Lustre, http://www.lustre.org/ @@ -99,14 +97,8 @@ #define DEBUG_SUBSYSTEM S_LDLM -#ifdef __KERNEL__ -# include -#else -# include -#endif - +#include #include - #include #include #include "ldlm_internal.h" @@ -116,7 +108,7 @@ /* * 50 ldlm locks for 1MB of RAM. */ -#define LDLM_POOL_HOST_L ((CFS_NUM_CACHEPAGES >> (20 - CFS_PAGE_SHIFT)) * 50) +#define LDLM_POOL_HOST_L ((NUM_CACHEPAGES >> (20 - PAGE_CACHE_SHIFT)) * 50) /* * Maximal possible grant step plan in %. @@ -149,9 +141,7 @@ */ #define LDLM_POOL_SLV_SHIFT (10) -#ifdef __KERNEL__ -extern cfs_proc_dir_entry_t *ldlm_ns_proc_dir; -#endif +extern struct proc_dir_entry *ldlm_ns_proc_dir; static inline __u64 dru(__u64 val, __u32 shift, int round_up) { @@ -225,6 +215,11 @@ static inline int ldlm_pool_t2gsp(unsigned int t) (t >> LDLM_POOL_GSP_STEP_SHIFT)); } +static inline int ldlm_pool_granted(struct ldlm_pool *pl) +{ + return atomic_read(&pl->pl_granted); +} + /** * Recalculates next grant limit on passed \a pl. * @@ -232,17 +227,17 @@ static inline int ldlm_pool_t2gsp(unsigned int t) */ static void ldlm_pool_recalc_grant_plan(struct ldlm_pool *pl) { - int granted, grant_step, limit; + int granted, grant_step, limit; - limit = ldlm_pool_get_limit(pl); - granted = cfs_atomic_read(&pl->pl_granted); + limit = ldlm_pool_get_limit(pl); + granted = ldlm_pool_granted(pl); - grant_step = ldlm_pool_t2gsp(pl->pl_recalc_period); - grant_step = ((limit - granted) * grant_step) / 100; - pl->pl_grant_plan = granted + grant_step; - limit = (limit * 5) >> 2; - if (pl->pl_grant_plan > limit) - pl->pl_grant_plan = limit; + grant_step = ldlm_pool_t2gsp(pl->pl_recalc_period); + grant_step = ((limit - granted) * grant_step) / 100; + pl->pl_grant_plan = granted + grant_step; + limit = (limit * 5) >> 2; + if (pl->pl_grant_plan > limit) + pl->pl_grant_plan = limit; } /** @@ -260,11 +255,11 @@ static void ldlm_pool_recalc_slv(struct ldlm_pool *pl) __u64 grant_usage; __u32 limit; - slv = pl->pl_server_lock_volume; - grant_plan = pl->pl_grant_plan; - limit = ldlm_pool_get_limit(pl); - granted = cfs_atomic_read(&pl->pl_granted); - round_up = granted < limit; + slv = pl->pl_server_lock_volume; + grant_plan = pl->pl_grant_plan; + limit = ldlm_pool_get_limit(pl); + granted = ldlm_pool_granted(pl); + round_up = granted < limit; grant_usage = max_t(int, limit - (granted - grant_plan), 1); @@ -297,22 +292,22 @@ static void ldlm_pool_recalc_slv(struct ldlm_pool *pl) */ static void ldlm_pool_recalc_stats(struct ldlm_pool *pl) { - int grant_plan = pl->pl_grant_plan; - __u64 slv = pl->pl_server_lock_volume; - int granted = cfs_atomic_read(&pl->pl_granted); - int grant_rate = cfs_atomic_read(&pl->pl_grant_rate); - int cancel_rate = cfs_atomic_read(&pl->pl_cancel_rate); - - lprocfs_counter_add(pl->pl_stats, LDLM_POOL_SLV_STAT, - slv); - lprocfs_counter_add(pl->pl_stats, LDLM_POOL_GRANTED_STAT, - granted); - lprocfs_counter_add(pl->pl_stats, LDLM_POOL_GRANT_RATE_STAT, - grant_rate); - lprocfs_counter_add(pl->pl_stats, LDLM_POOL_GRANT_PLAN_STAT, - grant_plan); - lprocfs_counter_add(pl->pl_stats, LDLM_POOL_CANCEL_RATE_STAT, - cancel_rate); + int grant_plan = pl->pl_grant_plan; + __u64 slv = pl->pl_server_lock_volume; + int granted = ldlm_pool_granted(pl); + int grant_rate = atomic_read(&pl->pl_grant_rate); + int cancel_rate = atomic_read(&pl->pl_cancel_rate); + + lprocfs_counter_add(pl->pl_stats, LDLM_POOL_SLV_STAT, + slv); + lprocfs_counter_add(pl->pl_stats, LDLM_POOL_GRANTED_STAT, + granted); + lprocfs_counter_add(pl->pl_stats, LDLM_POOL_GRANT_RATE_STAT, + grant_rate); + lprocfs_counter_add(pl->pl_stats, LDLM_POOL_GRANT_PLAN_STAT, + grant_plan); + lprocfs_counter_add(pl->pl_stats, LDLM_POOL_CANCEL_RATE_STAT, + cancel_rate); } /** @@ -331,9 +326,9 @@ static void ldlm_srv_pool_push_slv(struct ldlm_pool *pl) */ obd = ldlm_pl2ns(pl)->ns_obd; LASSERT(obd != NULL); - cfs_write_lock(&obd->obd_pool_lock); + write_lock(&obd->obd_pool_lock); obd->obd_pool_slv = pl->pl_server_lock_volume; - cfs_write_unlock(&obd->obd_pool_lock); + write_unlock(&obd->obd_pool_lock); } /** @@ -350,12 +345,12 @@ static int ldlm_srv_pool_recalc(struct ldlm_pool *pl) if (recalc_interval_sec < pl->pl_recalc_period) RETURN(0); - cfs_spin_lock(&pl->pl_lock); - recalc_interval_sec = cfs_time_current_sec() - pl->pl_recalc_time; - if (recalc_interval_sec < pl->pl_recalc_period) { - cfs_spin_unlock(&pl->pl_lock); - RETURN(0); - } + spin_lock(&pl->pl_lock); + recalc_interval_sec = cfs_time_current_sec() - pl->pl_recalc_time; + if (recalc_interval_sec < pl->pl_recalc_period) { + spin_unlock(&pl->pl_lock); + RETURN(0); + } /* * Recalc SLV after last period. This should be done * _before_ recalculating new grant plan. @@ -375,8 +370,8 @@ static int ldlm_srv_pool_recalc(struct ldlm_pool *pl) pl->pl_recalc_time = cfs_time_current_sec(); lprocfs_counter_add(pl->pl_stats, LDLM_POOL_TIMING_STAT, recalc_interval_sec); - cfs_spin_unlock(&pl->pl_lock); - RETURN(0); + spin_unlock(&pl->pl_lock); + RETURN(0); } /** @@ -388,24 +383,24 @@ static int ldlm_srv_pool_recalc(struct ldlm_pool *pl) * locks smaller in next 10h. */ static int ldlm_srv_pool_shrink(struct ldlm_pool *pl, - int nr, unsigned int gfp_mask) + int nr, gfp_t gfp_mask) { - __u32 limit; + __u32 limit; - /* - * VM is asking how many entries may be potentially freed. - */ - if (nr == 0) - return cfs_atomic_read(&pl->pl_granted); + /* + * VM is asking how many entries may be potentially freed. + */ + if (nr == 0) + return ldlm_pool_granted(pl); - /* - * Client already canceled locks but server is already in shrinker - * and can't cancel anything. Let's catch this race. - */ - if (cfs_atomic_read(&pl->pl_granted) == 0) - RETURN(0); + /* + * Client already canceled locks but server is already in shrinker + * and can't cancel anything. Let's catch this race. + */ + if (ldlm_pool_granted(pl) == 0) + RETURN(0); - cfs_spin_lock(&pl->pl_lock); + spin_lock(&pl->pl_lock); /* * We want shrinker to possibly cause cancellation of @nr locks from @@ -430,13 +425,13 @@ static int ldlm_srv_pool_shrink(struct ldlm_pool *pl, * Make sure that pool informed obd of last SLV changes. */ ldlm_srv_pool_push_slv(pl); - cfs_spin_unlock(&pl->pl_lock); + spin_unlock(&pl->pl_lock); - /* - * We did not really free any memory here so far, it only will be - * freed later may be, so that we return 0 to not confuse VM. - */ - return 0; + /* + * We did not really free any memory here so far, it only will be + * freed later may be, so that we return 0 to not confuse VM. + */ + return 0; } /** @@ -449,9 +444,9 @@ static int ldlm_srv_pool_setup(struct ldlm_pool *pl, int limit) obd = ldlm_pl2ns(pl)->ns_obd; LASSERT(obd != NULL && obd != LP_POISON); LASSERT(obd->obd_type != LP_POISON); - cfs_write_lock(&obd->obd_pool_lock); + write_lock(&obd->obd_pool_lock); obd->obd_pool_limit = limit; - cfs_write_unlock(&obd->obd_pool_lock); + write_unlock(&obd->obd_pool_lock); ldlm_pool_set_limit(pl, limit); return 0; @@ -470,10 +465,10 @@ static void ldlm_cli_pool_pop_slv(struct ldlm_pool *pl) */ obd = ldlm_pl2ns(pl)->ns_obd; LASSERT(obd != NULL); - cfs_read_lock(&obd->obd_pool_lock); + read_lock(&obd->obd_pool_lock); pl->pl_server_lock_volume = obd->obd_pool_slv; ldlm_pool_set_limit(pl, obd->obd_pool_limit); - cfs_read_unlock(&obd->obd_pool_lock); + read_unlock(&obd->obd_pool_lock); } /** @@ -482,19 +477,20 @@ static void ldlm_cli_pool_pop_slv(struct ldlm_pool *pl) static int ldlm_cli_pool_recalc(struct ldlm_pool *pl) { time_t recalc_interval_sec; + int ret; ENTRY; recalc_interval_sec = cfs_time_current_sec() - pl->pl_recalc_time; if (recalc_interval_sec < pl->pl_recalc_period) RETURN(0); - cfs_spin_lock(&pl->pl_lock); - /* - * Check if we need to recalc lists now. - */ - recalc_interval_sec = cfs_time_current_sec() - pl->pl_recalc_time; - if (recalc_interval_sec < pl->pl_recalc_period) { - cfs_spin_unlock(&pl->pl_lock); + spin_lock(&pl->pl_lock); + /* + * Check if we need to recalc lists now. + */ + recalc_interval_sec = cfs_time_current_sec() - pl->pl_recalc_time; + if (recalc_interval_sec < pl->pl_recalc_period) { + spin_unlock(&pl->pl_lock); RETURN(0); } @@ -502,17 +498,13 @@ static int ldlm_cli_pool_recalc(struct ldlm_pool *pl) * Make sure that pool knows last SLV and Limit from obd. */ ldlm_cli_pool_pop_slv(pl); - - pl->pl_recalc_time = cfs_time_current_sec(); - lprocfs_counter_add(pl->pl_stats, LDLM_POOL_TIMING_STAT, - recalc_interval_sec); - cfs_spin_unlock(&pl->pl_lock); + spin_unlock(&pl->pl_lock); /* * Do not cancel locks in case lru resize is disabled for this ns. */ if (!ns_connect_lru_resize(ldlm_pl2ns(pl))) - RETURN(0); + GOTO(out, ret = 0); /* * In the time of canceling locks on client we do not need to maintain @@ -520,8 +512,20 @@ static int ldlm_cli_pool_recalc(struct ldlm_pool *pl) * It may be called when SLV has changed much, this is why we do not * take into account pl->pl_recalc_time here. */ - RETURN(ldlm_cancel_lru(ldlm_pl2ns(pl), 0, LDLM_SYNC, - LDLM_CANCEL_LRUR)); + ret = ldlm_cancel_lru(ldlm_pl2ns(pl), 0, LCF_ASYNC, + LDLM_CANCEL_LRUR); + +out: + spin_lock(&pl->pl_lock); + /* + * Time of LRU resizing might be longer than period, + * so update after LRU resizing rather than before it. + */ + pl->pl_recalc_time = cfs_time_current_sec(); + lprocfs_counter_add(pl->pl_stats, LDLM_POOL_TIMING_STAT, + recalc_interval_sec); + spin_unlock(&pl->pl_lock); + RETURN(ret); } /** @@ -530,10 +534,10 @@ static int ldlm_cli_pool_recalc(struct ldlm_pool *pl) * passed \a pl according to \a nr and \a gfp_mask. */ static int ldlm_cli_pool_shrink(struct ldlm_pool *pl, - int nr, unsigned int gfp_mask) + int nr, gfp_t gfp_mask) { struct ldlm_namespace *ns; - int canceled = 0, unused; + int unused; ns = ldlm_pl2ns(pl); @@ -548,22 +552,14 @@ static int ldlm_cli_pool_shrink(struct ldlm_pool *pl, */ ldlm_cli_pool_pop_slv(pl); - cfs_spin_lock(&ns->ns_lock); - unused = ns->ns_nr_unused; - cfs_spin_unlock(&ns->ns_lock); - - if (nr) { - canceled = ldlm_cancel_lru(ns, nr, LDLM_ASYNC, - LDLM_CANCEL_SHRINK); - } -#ifdef __KERNEL__ - /* - * Return the number of potentially reclaimable locks. - */ - return ((unused - canceled) / 100) * sysctl_vfs_cache_pressure; -#else - return unused - canceled; -#endif + spin_lock(&ns->ns_lock); + unused = ns->ns_nr_unused; + spin_unlock(&ns->ns_lock); + + if (nr == 0) + return (unused / 100) * sysctl_vfs_cache_pressure; + else + return ldlm_cancel_lru(ns, nr, LCF_ASYNC, LDLM_CANCEL_SHRINK); } struct ldlm_pool_ops ldlm_srv_pool_ops = { @@ -590,40 +586,42 @@ int ldlm_pool_recalc(struct ldlm_pool *pl) if (recalc_interval_sec <= 0) goto recalc; - cfs_spin_lock(&pl->pl_lock); - recalc_interval_sec = cfs_time_current_sec() - pl->pl_recalc_time; - if (recalc_interval_sec > 0) { - /* - * Update pool statistics every 1s. - */ - ldlm_pool_recalc_stats(pl); - - /* - * Zero out all rates and speed for the last period. - */ - cfs_atomic_set(&pl->pl_grant_rate, 0); - cfs_atomic_set(&pl->pl_cancel_rate, 0); - } - cfs_spin_unlock(&pl->pl_lock); + spin_lock(&pl->pl_lock); + if (recalc_interval_sec > 0) { + /* + * Update pool statistics every 1s. + */ + ldlm_pool_recalc_stats(pl); + + /* + * Zero out all rates and speed for the last period. + */ + atomic_set(&pl->pl_grant_rate, 0); + atomic_set(&pl->pl_cancel_rate, 0); + } + spin_unlock(&pl->pl_lock); recalc: if (pl->pl_ops->po_recalc != NULL) { count = pl->pl_ops->po_recalc(pl); lprocfs_counter_add(pl->pl_stats, LDLM_POOL_RECALC_STAT, count); - return count; } - - return 0; + recalc_interval_sec = pl->pl_recalc_time - cfs_time_current_sec() + + pl->pl_recalc_period; + if (recalc_interval_sec <= 0) { + /* Prevent too frequent recalculation. */ + recalc_interval_sec = 1; + } + + return recalc_interval_sec; } -EXPORT_SYMBOL(ldlm_pool_recalc); /** * Pool shrink wrapper. Will call either client or server pool recalc callback * depending what pool \a pl is used. */ -int ldlm_pool_shrink(struct ldlm_pool *pl, int nr, - unsigned int gfp_mask) +int ldlm_pool_shrink(struct ldlm_pool *pl, int nr, gfp_t gfp_mask) { int cancel = 0; @@ -658,156 +656,133 @@ int ldlm_pool_setup(struct ldlm_pool *pl, int limit) } EXPORT_SYMBOL(ldlm_pool_setup); -#ifdef __KERNEL__ -static int lprocfs_rd_pool_state(char *page, char **start, off_t off, - int count, int *eof, void *data) +static int lprocfs_pool_state_seq_show(struct seq_file *m, void *unused) { - int granted, grant_rate, cancel_rate, grant_step; - int nr = 0, grant_speed, grant_plan, lvf; - struct ldlm_pool *pl = data; - __u64 slv, clv; - __u32 limit; + int granted, grant_rate, cancel_rate, grant_step; + int grant_speed, grant_plan, lvf; + struct ldlm_pool *pl = m->private; + __u64 slv, clv; + __u32 limit; + + spin_lock(&pl->pl_lock); + slv = pl->pl_server_lock_volume; + clv = pl->pl_client_lock_volume; + limit = ldlm_pool_get_limit(pl); + grant_plan = pl->pl_grant_plan; + granted = ldlm_pool_granted(pl); + grant_rate = atomic_read(&pl->pl_grant_rate); + cancel_rate = atomic_read(&pl->pl_cancel_rate); + grant_speed = grant_rate - cancel_rate; + lvf = atomic_read(&pl->pl_lock_volume_factor); + grant_step = ldlm_pool_t2gsp(pl->pl_recalc_period); + spin_unlock(&pl->pl_lock); + + seq_printf(m, "LDLM pool state (%s):\n" + " SLV: "LPU64"\n" + " CLV: "LPU64"\n" + " LVF: %d\n", + pl->pl_name, slv, clv, lvf); + + if (ns_is_server(ldlm_pl2ns(pl))) { + seq_printf(m, " GSP: %d%%\n" + " GP: %d\n", + grant_step, grant_plan); + } + seq_printf(m, " GR: %d\n" " CR: %d\n" " GS: %d\n" + " G: %d\n" " L: %d\n", + grant_rate, cancel_rate, grant_speed, + granted, limit); + return 0; +} +LPROC_SEQ_FOPS_RO(lprocfs_pool_state); - cfs_spin_lock(&pl->pl_lock); - slv = pl->pl_server_lock_volume; - clv = pl->pl_client_lock_volume; - limit = ldlm_pool_get_limit(pl); - grant_plan = pl->pl_grant_plan; - granted = cfs_atomic_read(&pl->pl_granted); - grant_rate = cfs_atomic_read(&pl->pl_grant_rate); - cancel_rate = cfs_atomic_read(&pl->pl_cancel_rate); - grant_speed = grant_rate - cancel_rate; - lvf = cfs_atomic_read(&pl->pl_lock_volume_factor); - grant_step = ldlm_pool_t2gsp(pl->pl_recalc_period); - cfs_spin_unlock(&pl->pl_lock); - - nr += snprintf(page + nr, count - nr, "LDLM pool state (%s):\n", - pl->pl_name); - nr += snprintf(page + nr, count - nr, " SLV: "LPU64"\n", slv); - nr += snprintf(page + nr, count - nr, " CLV: "LPU64"\n", clv); - nr += snprintf(page + nr, count - nr, " LVF: %d\n", lvf); - - if (ns_is_server(ldlm_pl2ns(pl))) { - nr += snprintf(page + nr, count - nr, " GSP: %d%%\n", - grant_step); - nr += snprintf(page + nr, count - nr, " GP: %d\n", - grant_plan); - } - nr += snprintf(page + nr, count - nr, " GR: %d\n", - grant_rate); - nr += snprintf(page + nr, count - nr, " CR: %d\n", - cancel_rate); - nr += snprintf(page + nr, count - nr, " GS: %d\n", - grant_speed); - nr += snprintf(page + nr, count - nr, " G: %d\n", - granted); - nr += snprintf(page + nr, count - nr, " L: %d\n", - limit); - return nr; -} - -static int lprocfs_rd_grant_speed(char *page, char **start, off_t off, - int count, int *eof, void *data) -{ - struct ldlm_pool *pl = data; - int grant_speed; - - cfs_spin_lock(&pl->pl_lock); - /* serialize with ldlm_pool_recalc */ - grant_speed = cfs_atomic_read(&pl->pl_grant_rate) - - cfs_atomic_read(&pl->pl_cancel_rate); - cfs_spin_unlock(&pl->pl_lock); - return lprocfs_rd_uint(page, start, off, count, eof, &grant_speed); -} - -LDLM_POOL_PROC_READER(grant_plan, int); -LDLM_POOL_PROC_READER(recalc_period, int); -LDLM_POOL_PROC_WRITER(recalc_period, int); +static int lprocfs_grant_speed_seq_show(struct seq_file *m, void *unused) +{ + struct ldlm_pool *pl = m->private; + int grant_speed; + + spin_lock(&pl->pl_lock); + /* serialize with ldlm_pool_recalc */ + grant_speed = atomic_read(&pl->pl_grant_rate) - + atomic_read(&pl->pl_cancel_rate); + spin_unlock(&pl->pl_lock); + return lprocfs_uint_seq_show(m, &grant_speed); +} -static int ldlm_pool_proc_init(struct ldlm_pool *pl) +LDLM_POOL_PROC_READER_SEQ_SHOW(grant_plan, int); +LPROC_SEQ_FOPS_RO(lprocfs_grant_plan); + +LDLM_POOL_PROC_READER_SEQ_SHOW(recalc_period, int); +LDLM_POOL_PROC_WRITER(recalc_period, int); +static ssize_t lprocfs_recalc_period_seq_write(struct file *file, + const char __user *buf, + size_t len, loff_t *off) { - struct ldlm_namespace *ns = ldlm_pl2ns(pl); - struct proc_dir_entry *parent_ns_proc; - struct lprocfs_vars pool_vars[2]; - char *var_name = NULL; - int rc = 0; - ENTRY; + struct seq_file *seq = file->private_data; + + return lprocfs_wr_recalc_period(file, buf, len, seq->private); +} +LPROC_SEQ_FOPS(lprocfs_recalc_period); - OBD_ALLOC(var_name, MAX_STRING_SIZE + 1); - if (!var_name) - RETURN(-ENOMEM); +LPROC_SEQ_FOPS_RO_TYPE(ldlm_pool, u64); +LPROC_SEQ_FOPS_RO_TYPE(ldlm_pool, atomic); +LPROC_SEQ_FOPS_RW_TYPE(ldlm_pool_rw, atomic); - parent_ns_proc = lprocfs_srch(ldlm_ns_proc_dir, - ldlm_ns_name(ns)); - if (parent_ns_proc == NULL) { - CERROR("%s: proc entry is not initialized\n", - ldlm_ns_name(ns)); - GOTO(out_free_name, rc = -EINVAL); - } - pl->pl_proc_dir = lprocfs_register("pool", parent_ns_proc, - NULL, NULL); - if (IS_ERR(pl->pl_proc_dir)) { - CERROR("LProcFS failed in ldlm-pool-init\n"); - rc = PTR_ERR(pl->pl_proc_dir); - GOTO(out_free_name, rc); - } +LPROC_SEQ_FOPS_RO(lprocfs_grant_speed); - var_name[MAX_STRING_SIZE] = '\0'; - memset(pool_vars, 0, sizeof(pool_vars)); - pool_vars[0].name = var_name; - - snprintf(var_name, MAX_STRING_SIZE, "server_lock_volume"); - pool_vars[0].data = &pl->pl_server_lock_volume; - pool_vars[0].read_fptr = lprocfs_rd_u64; - lprocfs_add_vars(pl->pl_proc_dir, pool_vars, 0); - - snprintf(var_name, MAX_STRING_SIZE, "limit"); - pool_vars[0].data = &pl->pl_limit; - pool_vars[0].read_fptr = lprocfs_rd_atomic; - pool_vars[0].write_fptr = lprocfs_wr_atomic; - lprocfs_add_vars(pl->pl_proc_dir, pool_vars, 0); - - snprintf(var_name, MAX_STRING_SIZE, "granted"); - pool_vars[0].data = &pl->pl_granted; - pool_vars[0].read_fptr = lprocfs_rd_atomic; - lprocfs_add_vars(pl->pl_proc_dir, pool_vars, 0); - - snprintf(var_name, MAX_STRING_SIZE, "grant_speed"); - pool_vars[0].data = pl; - pool_vars[0].read_fptr = lprocfs_rd_grant_speed; - lprocfs_add_vars(pl->pl_proc_dir, pool_vars, 0); - - snprintf(var_name, MAX_STRING_SIZE, "cancel_rate"); - pool_vars[0].data = &pl->pl_cancel_rate; - pool_vars[0].read_fptr = lprocfs_rd_atomic; - lprocfs_add_vars(pl->pl_proc_dir, pool_vars, 0); - - snprintf(var_name, MAX_STRING_SIZE, "grant_rate"); - pool_vars[0].data = &pl->pl_grant_rate; - pool_vars[0].read_fptr = lprocfs_rd_atomic; - lprocfs_add_vars(pl->pl_proc_dir, pool_vars, 0); - - snprintf(var_name, MAX_STRING_SIZE, "grant_plan"); - pool_vars[0].data = pl; - pool_vars[0].read_fptr = lprocfs_rd_grant_plan; - lprocfs_add_vars(pl->pl_proc_dir, pool_vars, 0); - - snprintf(var_name, MAX_STRING_SIZE, "recalc_period"); - pool_vars[0].data = pl; - pool_vars[0].read_fptr = lprocfs_rd_recalc_period; - pool_vars[0].write_fptr = lprocfs_wr_recalc_period; - lprocfs_add_vars(pl->pl_proc_dir, pool_vars, 0); - - snprintf(var_name, MAX_STRING_SIZE, "lock_volume_factor"); - pool_vars[0].data = &pl->pl_lock_volume_factor; - pool_vars[0].read_fptr = lprocfs_rd_atomic; - pool_vars[0].write_fptr = lprocfs_wr_atomic; - lprocfs_add_vars(pl->pl_proc_dir, pool_vars, 0); - - snprintf(var_name, MAX_STRING_SIZE, "state"); - pool_vars[0].data = pl; - pool_vars[0].read_fptr = lprocfs_rd_pool_state; - lprocfs_add_vars(pl->pl_proc_dir, pool_vars, 0); +static int ldlm_pool_proc_init(struct ldlm_pool *pl) +{ + struct ldlm_namespace *ns = ldlm_pl2ns(pl); + struct proc_dir_entry *parent_ns_proc; + struct lprocfs_seq_vars pool_vars[2]; + char *var_name = NULL; + int rc = 0; + ENTRY; + + OBD_ALLOC(var_name, MAX_STRING_SIZE + 1); + if (!var_name) + RETURN(-ENOMEM); + + parent_ns_proc = ns->ns_proc_dir_entry; + if (parent_ns_proc == NULL) { + CERROR("%s: proc entry is not initialized\n", + ldlm_ns_name(ns)); + GOTO(out_free_name, rc = -EINVAL); + } + pl->pl_proc_dir = lprocfs_seq_register("pool", parent_ns_proc, + NULL, NULL); + if (IS_ERR(pl->pl_proc_dir)) { + rc = PTR_ERR(pl->pl_proc_dir); + pl->pl_proc_dir = NULL; + CERROR("%s: cannot create 'pool' proc entry: rc = %d\n", + ldlm_ns_name(ns), rc); + GOTO(out_free_name, rc); + } + + var_name[MAX_STRING_SIZE] = '\0'; + memset(pool_vars, 0, sizeof(pool_vars)); + pool_vars[0].name = var_name; + + ldlm_add_var(&pool_vars[0], pl->pl_proc_dir, "server_lock_volume", + &pl->pl_server_lock_volume, &ldlm_pool_u64_fops); + ldlm_add_var(&pool_vars[0], pl->pl_proc_dir, "limit", &pl->pl_limit, + &ldlm_pool_rw_atomic_fops); + ldlm_add_var(&pool_vars[0], pl->pl_proc_dir, "granted", + &pl->pl_granted, &ldlm_pool_atomic_fops); + ldlm_add_var(&pool_vars[0], pl->pl_proc_dir, "grant_speed", pl, + &lprocfs_grant_speed_fops); + ldlm_add_var(&pool_vars[0], pl->pl_proc_dir, "cancel_rate", + &pl->pl_cancel_rate, &ldlm_pool_atomic_fops); + ldlm_add_var(&pool_vars[0], pl->pl_proc_dir, "grant_rate", + &pl->pl_grant_rate, &ldlm_pool_atomic_fops); + ldlm_add_var(&pool_vars[0], pl->pl_proc_dir, "grant_plan", pl, + &lprocfs_grant_plan_fops); + ldlm_add_var(&pool_vars[0], pl->pl_proc_dir, "recalc_period", + pl, &lprocfs_recalc_period_fops); + ldlm_add_var(&pool_vars[0], pl->pl_proc_dir, "lock_volume_factor", + &pl->pl_lock_volume_factor, &ldlm_pool_rw_atomic_fops); + ldlm_add_var(&pool_vars[0], pl->pl_proc_dir, "state", pl, + &lprocfs_pool_state_fops); pl->pl_stats = lprocfs_alloc_stats(LDLM_POOL_LAST_STAT - LDLM_POOL_FIRST_STAT, 0); @@ -847,7 +822,7 @@ static int ldlm_pool_proc_init(struct ldlm_pool *pl) lprocfs_counter_init(pl->pl_stats, LDLM_POOL_TIMING_STAT, LPROCFS_CNTR_AVGMINMAX | LPROCFS_CNTR_STDDEV, "recalc_timing", "sec"); - lprocfs_register_stats(pl->pl_proc_dir, "stats", pl->pl_stats); + rc = lprocfs_register_stats(pl->pl_proc_dir, "stats", pl->pl_stats); EXIT; out_free_name: @@ -866,28 +841,24 @@ static void ldlm_pool_proc_fini(struct ldlm_pool *pl) pl->pl_proc_dir = NULL; } } -#else /* !__KERNEL__*/ -#define ldlm_pool_proc_init(pl) (0) -#define ldlm_pool_proc_fini(pl) while (0) {} -#endif int ldlm_pool_init(struct ldlm_pool *pl, struct ldlm_namespace *ns, - int idx, ldlm_side_t client) + int idx, ldlm_side_t client) { - int rc; - ENTRY; + int rc; + ENTRY; - cfs_spin_lock_init(&pl->pl_lock); - cfs_atomic_set(&pl->pl_granted, 0); - pl->pl_recalc_time = cfs_time_current_sec(); - cfs_atomic_set(&pl->pl_lock_volume_factor, 1); + spin_lock_init(&pl->pl_lock); + atomic_set(&pl->pl_granted, 0); + pl->pl_recalc_time = cfs_time_current_sec(); + atomic_set(&pl->pl_lock_volume_factor, 1); - cfs_atomic_set(&pl->pl_grant_rate, 0); - cfs_atomic_set(&pl->pl_cancel_rate, 0); - pl->pl_grant_plan = LDLM_POOL_GP(LDLM_POOL_HOST_L); + atomic_set(&pl->pl_grant_rate, 0); + atomic_set(&pl->pl_cancel_rate, 0); + pl->pl_grant_plan = LDLM_POOL_GP(LDLM_POOL_HOST_L); - snprintf(pl->pl_name, sizeof(pl->pl_name), "ldlm-pool-%s-%d", - ldlm_ns_name(ns), idx); + snprintf(pl->pl_name, sizeof(pl->pl_name), "ldlm-pool-%s-%d", + ldlm_ns_name(ns), idx); if (client == LDLM_NAMESPACE_SERVER) { pl->pl_ops = &ldlm_srv_pool_ops; @@ -931,26 +902,26 @@ EXPORT_SYMBOL(ldlm_pool_fini); */ void ldlm_pool_add(struct ldlm_pool *pl, struct ldlm_lock *lock) { - /* - * FLOCK locks are special in a sense that they are almost never - * cancelled, instead special kind of lock is used to drop them. - * also there is no LRU for flock locks, so no point in tracking - * them anyway. - */ - if (lock->l_resource->lr_type == LDLM_FLOCK) - return; - - cfs_atomic_inc(&pl->pl_granted); - cfs_atomic_inc(&pl->pl_grant_rate); - lprocfs_counter_incr(pl->pl_stats, LDLM_POOL_GRANT_STAT); - /* - * Do not do pool recalc for client side as all locks which - * potentially may be canceled has already been packed into - * enqueue/cancel rpc. Also we do not want to run out of stack - * with too long call paths. - */ - if (ns_is_server(ldlm_pl2ns(pl))) - ldlm_pool_recalc(pl); + /* + * FLOCK locks are special in a sense that they are almost never + * cancelled, instead special kind of lock is used to drop them. + * also there is no LRU for flock locks, so no point in tracking + * them anyway. + */ + if (lock->l_resource->lr_type == LDLM_FLOCK) + return; + + atomic_inc(&pl->pl_granted); + atomic_inc(&pl->pl_grant_rate); + lprocfs_counter_incr(pl->pl_stats, LDLM_POOL_GRANT_STAT); + /* + * Do not do pool recalc for client side as all locks which + * potentially may be canceled has already been packed into + * enqueue/cancel rpc. Also we do not want to run out of stack + * with too long call paths. + */ + if (ns_is_server(ldlm_pl2ns(pl))) + ldlm_pool_recalc(pl); } EXPORT_SYMBOL(ldlm_pool_add); @@ -959,20 +930,20 @@ EXPORT_SYMBOL(ldlm_pool_add); */ void ldlm_pool_del(struct ldlm_pool *pl, struct ldlm_lock *lock) { - /* - * Filter out FLOCK locks. Read above comment in ldlm_pool_add(). - */ - if (lock->l_resource->lr_type == LDLM_FLOCK) - return; + /* + * Filter out FLOCK locks. Read above comment in ldlm_pool_add(). + */ + if (lock->l_resource->lr_type == LDLM_FLOCK) + return; - LASSERT(cfs_atomic_read(&pl->pl_granted) > 0); - cfs_atomic_dec(&pl->pl_granted); - cfs_atomic_inc(&pl->pl_cancel_rate); + LASSERT(atomic_read(&pl->pl_granted) > 0); + atomic_dec(&pl->pl_granted); + atomic_inc(&pl->pl_cancel_rate); - lprocfs_counter_incr(pl->pl_stats, LDLM_POOL_CANCEL_STAT); + lprocfs_counter_incr(pl->pl_stats, LDLM_POOL_CANCEL_STAT); - if (ns_is_server(ldlm_pl2ns(pl))) - ldlm_pool_recalc(pl); + if (ns_is_server(ldlm_pl2ns(pl))) + ldlm_pool_recalc(pl); } EXPORT_SYMBOL(ldlm_pool_del); @@ -983,11 +954,11 @@ EXPORT_SYMBOL(ldlm_pool_del); */ __u64 ldlm_pool_get_slv(struct ldlm_pool *pl) { - __u64 slv; - cfs_spin_lock(&pl->pl_lock); - slv = pl->pl_server_lock_volume; - cfs_spin_unlock(&pl->pl_lock); - return slv; + __u64 slv; + spin_lock(&pl->pl_lock); + slv = pl->pl_server_lock_volume; + spin_unlock(&pl->pl_lock); + return slv; } EXPORT_SYMBOL(ldlm_pool_get_slv); @@ -998,9 +969,9 @@ EXPORT_SYMBOL(ldlm_pool_get_slv); */ void ldlm_pool_set_slv(struct ldlm_pool *pl, __u64 slv) { - cfs_spin_lock(&pl->pl_lock); - pl->pl_server_lock_volume = slv; - cfs_spin_unlock(&pl->pl_lock); + spin_lock(&pl->pl_lock); + pl->pl_server_lock_volume = slv; + spin_unlock(&pl->pl_lock); } EXPORT_SYMBOL(ldlm_pool_set_slv); @@ -1011,11 +982,11 @@ EXPORT_SYMBOL(ldlm_pool_set_slv); */ __u64 ldlm_pool_get_clv(struct ldlm_pool *pl) { - __u64 slv; - cfs_spin_lock(&pl->pl_lock); - slv = pl->pl_client_lock_volume; - cfs_spin_unlock(&pl->pl_lock); - return slv; + __u64 slv; + spin_lock(&pl->pl_lock); + slv = pl->pl_client_lock_volume; + spin_unlock(&pl->pl_lock); + return slv; } EXPORT_SYMBOL(ldlm_pool_get_clv); @@ -1026,9 +997,9 @@ EXPORT_SYMBOL(ldlm_pool_get_clv); */ void ldlm_pool_set_clv(struct ldlm_pool *pl, __u64 clv) { - cfs_spin_lock(&pl->pl_lock); - pl->pl_client_lock_volume = clv; - cfs_spin_unlock(&pl->pl_lock); + spin_lock(&pl->pl_lock); + pl->pl_client_lock_volume = clv; + spin_unlock(&pl->pl_lock); } EXPORT_SYMBOL(ldlm_pool_set_clv); @@ -1037,7 +1008,7 @@ EXPORT_SYMBOL(ldlm_pool_set_clv); */ __u32 ldlm_pool_get_limit(struct ldlm_pool *pl) { - return cfs_atomic_read(&pl->pl_limit); + return atomic_read(&pl->pl_limit); } EXPORT_SYMBOL(ldlm_pool_get_limit); @@ -1046,7 +1017,7 @@ EXPORT_SYMBOL(ldlm_pool_get_limit); */ void ldlm_pool_set_limit(struct ldlm_pool *pl, __u32 limit) { - cfs_atomic_set(&pl->pl_limit, limit); + atomic_set(&pl->pl_limit, limit); } EXPORT_SYMBOL(ldlm_pool_set_limit); @@ -1055,104 +1026,173 @@ EXPORT_SYMBOL(ldlm_pool_set_limit); */ __u32 ldlm_pool_get_lvf(struct ldlm_pool *pl) { - return cfs_atomic_read(&pl->pl_lock_volume_factor); + return atomic_read(&pl->pl_lock_volume_factor); } EXPORT_SYMBOL(ldlm_pool_get_lvf); -#ifdef __KERNEL__ -static int ldlm_pool_granted(struct ldlm_pool *pl) +static struct ptlrpc_thread *ldlm_pools_thread; +static struct shrinker *ldlm_pools_srv_shrinker; +static struct shrinker *ldlm_pools_cli_shrinker; +static struct completion ldlm_pools_comp; + +/* +* count locks from all namespaces (if possible). Returns number of +* cached locks. +*/ +static unsigned long ldlm_pools_count(ldlm_side_t client, gfp_t gfp_mask) { - return cfs_atomic_read(&pl->pl_granted); + unsigned long total = 0; + int nr_ns; + struct ldlm_namespace *ns; + struct ldlm_namespace *ns_old = NULL; /* loop detection */ + void *cookie; + + if (client == LDLM_NAMESPACE_CLIENT && !(gfp_mask & __GFP_FS)) + return 0; + + CDEBUG(D_DLMTRACE, "Request to count %s locks from all pools\n", + client == LDLM_NAMESPACE_CLIENT ? "client" : "server"); + + cookie = cl_env_reenter(); + + /* + * Find out how many resources we may release. + */ + for (nr_ns = ldlm_namespace_nr_read(client); + nr_ns > 0; nr_ns--) { + mutex_lock(ldlm_namespace_lock(client)); + if (list_empty(ldlm_namespace_list(client))) { + mutex_unlock(ldlm_namespace_lock(client)); + cl_env_reexit(cookie); + return 0; + } + ns = ldlm_namespace_first_locked(client); + + if (ns == ns_old) { + mutex_unlock(ldlm_namespace_lock(client)); + break; + } + + if (ldlm_ns_empty(ns)) { + ldlm_namespace_move_to_inactive_locked(ns, client); + mutex_unlock(ldlm_namespace_lock(client)); + continue; + } + + if (ns_old == NULL) + ns_old = ns; + + ldlm_namespace_get(ns); + ldlm_namespace_move_to_active_locked(ns, client); + mutex_unlock(ldlm_namespace_lock(client)); + total += ldlm_pool_shrink(&ns->ns_pool, 0, gfp_mask); + ldlm_namespace_put(ns); + } + + cl_env_reexit(cookie); + return total; } -static struct ptlrpc_thread *ldlm_pools_thread; -static struct cfs_shrinker *ldlm_pools_srv_shrinker; -static struct cfs_shrinker *ldlm_pools_cli_shrinker; -static cfs_completion_t ldlm_pools_comp; +static unsigned long ldlm_pools_scan(ldlm_side_t client, int nr, + gfp_t gfp_mask) +{ + unsigned long freed = 0; + int tmp, nr_ns; + struct ldlm_namespace *ns; + void *cookie; + + if (client == LDLM_NAMESPACE_CLIENT && !(gfp_mask & __GFP_FS)) + return -1; + + cookie = cl_env_reenter(); + + /* + * Shrink at least ldlm_namespace_nr_read(client) namespaces. + */ + for (tmp = nr_ns = ldlm_namespace_nr_read(client); + tmp > 0; tmp--) { + int cancel, nr_locks; + + /* + * Do not call shrink under ldlm_namespace_lock(client) + */ + mutex_lock(ldlm_namespace_lock(client)); + if (list_empty(ldlm_namespace_list(client))) { + mutex_unlock(ldlm_namespace_lock(client)); + break; + } + ns = ldlm_namespace_first_locked(client); + ldlm_namespace_get(ns); + ldlm_namespace_move_to_active_locked(ns, client); + mutex_unlock(ldlm_namespace_lock(client)); + + nr_locks = ldlm_pool_granted(&ns->ns_pool); + /* + * We use to shrink propotionally but with new shrinker API, + * we lost the total number of freeable locks. + */ + cancel = 1 + min_t(int, nr_locks, nr / nr_ns); + freed += ldlm_pool_shrink(&ns->ns_pool, cancel, gfp_mask); + ldlm_namespace_put(ns); + } + cl_env_reexit(cookie); + /* + * we only decrease the SLV in server pools shrinker, return + * SHRINK_STOP to kernel to avoid needless loop. LU-1128 + */ + return (client == LDLM_NAMESPACE_SERVER) ? SHRINK_STOP : freed; +} + +#ifdef HAVE_SHRINKER_COUNT +static unsigned long ldlm_pools_srv_count(struct shrinker *s, + struct shrink_control *sc) +{ + return ldlm_pools_count(LDLM_NAMESPACE_SERVER, sc->gfp_mask); +} + +static unsigned long ldlm_pools_srv_scan(struct shrinker *s, + struct shrink_control *sc) +{ + return ldlm_pools_scan(LDLM_NAMESPACE_SERVER, sc->nr_to_scan, + sc->gfp_mask); +} + +static unsigned long ldlm_pools_cli_count(struct shrinker *s, struct shrink_control *sc) +{ + return ldlm_pools_count(LDLM_NAMESPACE_CLIENT, sc->gfp_mask); +} + +static unsigned long ldlm_pools_cli_scan(struct shrinker *s, + struct shrink_control *sc) +{ + return ldlm_pools_scan(LDLM_NAMESPACE_CLIENT, sc->nr_to_scan, + sc->gfp_mask); +} +#else /* * Cancel \a nr locks from all namespaces (if possible). Returns number of * cached locks after shrink is finished. All namespaces are asked to * cancel approximately equal amount of locks to keep balancing. */ static int ldlm_pools_shrink(ldlm_side_t client, int nr, - unsigned int gfp_mask) + gfp_t gfp_mask) { - int total = 0, cached = 0, nr_ns; - struct ldlm_namespace *ns; - void *cookie; - - if (client == LDLM_NAMESPACE_CLIENT && nr != 0 && - !(gfp_mask & __GFP_FS)) - return -1; - - CDEBUG(D_DLMTRACE, "Request to shrink %d %s locks from all pools\n", - nr, client == LDLM_NAMESPACE_CLIENT ? "client" : "server"); + unsigned long total = 0; - cookie = cl_env_reenter(); + if (client == LDLM_NAMESPACE_CLIENT && nr != 0 && + !(gfp_mask & __GFP_FS)) + return -1; - /* - * Find out how many resources we may release. - */ - for (nr_ns = cfs_atomic_read(ldlm_namespace_nr(client)); - nr_ns > 0; nr_ns--) - { - cfs_mutex_lock(ldlm_namespace_lock(client)); - if (cfs_list_empty(ldlm_namespace_list(client))) { - cfs_mutex_unlock(ldlm_namespace_lock(client)); - cl_env_reexit(cookie); - return 0; - } - ns = ldlm_namespace_first_locked(client); - ldlm_namespace_get(ns); - ldlm_namespace_move_locked(ns, client); - cfs_mutex_unlock(ldlm_namespace_lock(client)); - total += ldlm_pool_shrink(&ns->ns_pool, 0, gfp_mask); - ldlm_namespace_put(ns); - } + CDEBUG(D_DLMTRACE, "Request to shrink %d %s locks from all pools\n", + nr, client == LDLM_NAMESPACE_CLIENT ? "client" : "server"); - if (nr == 0 || total == 0) { - cl_env_reexit(cookie); - return total; - } + total = ldlm_pools_count(client, gfp_mask); - /* - * Shrink at least ldlm_namespace_nr(client) namespaces. - */ - for (nr_ns = cfs_atomic_read(ldlm_namespace_nr(client)); - nr_ns > 0; nr_ns--) - { - int cancel, nr_locks; + if (nr == 0 || total == 0) + return total; - /* - * Do not call shrink under ldlm_namespace_lock(client) - */ - cfs_mutex_lock(ldlm_namespace_lock(client)); - if (cfs_list_empty(ldlm_namespace_list(client))) { - cfs_mutex_unlock(ldlm_namespace_lock(client)); - /* - * If list is empty, we can't return any @cached > 0, - * that probably would cause needless shrinker - * call. - */ - cached = 0; - break; - } - ns = ldlm_namespace_first_locked(client); - ldlm_namespace_get(ns); - ldlm_namespace_move_locked(ns, client); - cfs_mutex_unlock(ldlm_namespace_lock(client)); - - nr_locks = ldlm_pool_granted(&ns->ns_pool); - cancel = 1 + nr_locks * nr / total; - ldlm_pool_shrink(&ns->ns_pool, cancel, gfp_mask); - cached += ldlm_pool_granted(&ns->ns_pool); - ldlm_namespace_put(ns); - } - cl_env_reexit(cookie); - /* we only decrease the SLV in server pools shrinker, return -1 to - * kernel to avoid needless loop. LU-1128 */ - return (client == LDLM_NAMESPACE_SERVER) ? -1 : cached; + return ldlm_pools_scan(client, nr, gfp_mask); } static int ldlm_pools_srv_shrink(SHRINKER_ARGS(sc, nr_to_scan, gfp_mask)) @@ -1169,25 +1209,29 @@ static int ldlm_pools_cli_shrink(SHRINKER_ARGS(sc, nr_to_scan, gfp_mask)) shrink_param(sc, gfp_mask)); } -void ldlm_pools_recalc(ldlm_side_t client) +#endif /* HAVE_SHRINKER_COUNT */ + +int ldlm_pools_recalc(ldlm_side_t client) { - __u32 nr_l = 0, nr_p = 0, l; + unsigned long nr_l = 0, nr_p = 0, l; struct ldlm_namespace *ns; + struct ldlm_namespace *ns_old = NULL; int nr, equal = 0; - - /* - * No need to setup pool limit for client pools. - */ - if (client == LDLM_NAMESPACE_SERVER) { - /* - * Check all modest namespaces first. - */ - cfs_mutex_lock(ldlm_namespace_lock(client)); - cfs_list_for_each_entry(ns, ldlm_namespace_list(client), - ns_list_chain) - { - if (ns->ns_appetite != LDLM_NAMESPACE_MODEST) - continue; + int time = 50; /* seconds of sleep if no active namespaces */ + + /* + * No need to setup pool limit for client pools. + */ + if (client == LDLM_NAMESPACE_SERVER) { + /* + * Check all modest namespaces first. + */ + mutex_lock(ldlm_namespace_lock(client)); + list_for_each_entry(ns, ldlm_namespace_list(client), + ns_list_chain) + { + if (ns->ns_appetite != LDLM_NAMESPACE_MODEST) + continue; l = ldlm_pool_granted(&ns->ns_pool); if (l == 0) @@ -1209,20 +1253,20 @@ void ldlm_pools_recalc(ldlm_side_t client) */ if (nr_l >= 2 * (LDLM_POOL_HOST_L / 3)) { CWARN("\"Modest\" pools eat out 2/3 of server locks " - "limit (%d of %lu). This means that you have too " + "limit (%lu of %lu). This means that you have too " "many clients for this amount of server RAM. " "Upgrade server!\n", nr_l, LDLM_POOL_HOST_L); equal = 1; } - /* - * The rest is given to greedy namespaces. - */ - cfs_list_for_each_entry(ns, ldlm_namespace_list(client), - ns_list_chain) - { - if (!equal && ns->ns_appetite != LDLM_NAMESPACE_GREEDY) - continue; + /* + * The rest is given to greedy namespaces. + */ + list_for_each_entry(ns, ldlm_namespace_list(client), + ns_list_chain) + { + if (!equal && ns->ns_appetite != LDLM_NAMESPACE_GREEDY) + continue; if (equal) { /* @@ -1231,27 +1275,25 @@ void ldlm_pools_recalc(ldlm_side_t client) * for _all_ pools. */ l = LDLM_POOL_HOST_L / - cfs_atomic_read( - ldlm_namespace_nr(client)); + ldlm_namespace_nr_read(client); } else { /* * All the rest of greedy pools will have * all locks in equal parts. */ l = (LDLM_POOL_HOST_L - nr_l) / - (cfs_atomic_read( - ldlm_namespace_nr(client)) - + (ldlm_namespace_nr_read(client) - nr_p); } ldlm_pool_setup(&ns->ns_pool, l); } - cfs_mutex_unlock(ldlm_namespace_lock(client)); + mutex_unlock(ldlm_namespace_lock(client)); } /* * Recalc at least ldlm_namespace_nr(client) namespaces. */ - for (nr = cfs_atomic_read(ldlm_namespace_nr(client)); nr > 0; nr--) { + for (nr = ldlm_namespace_nr_read(client); nr > 0; nr--) { int skip; /* * Lock the list, get first @ns in the list, getref, move it @@ -1260,68 +1302,96 @@ void ldlm_pools_recalc(ldlm_side_t client) * rid of potential deadlock on client nodes when canceling * locks synchronously. */ - cfs_mutex_lock(ldlm_namespace_lock(client)); - if (cfs_list_empty(ldlm_namespace_list(client))) { - cfs_mutex_unlock(ldlm_namespace_lock(client)); - break; - } - ns = ldlm_namespace_first_locked(client); - - cfs_spin_lock(&ns->ns_lock); - /* - * skip ns which is being freed, and we don't want to increase - * its refcount again, not even temporarily. bz21519 & LU-499. - */ - if (ns->ns_stopping) { - skip = 1; - } else { - skip = 0; - ldlm_namespace_get(ns); - } - cfs_spin_unlock(&ns->ns_lock); - - ldlm_namespace_move_locked(ns, client); - cfs_mutex_unlock(ldlm_namespace_lock(client)); - - /* - * After setup is done - recalc the pool. - */ - if (!skip) { - ldlm_pool_recalc(&ns->ns_pool); - ldlm_namespace_put(ns); - } + mutex_lock(ldlm_namespace_lock(client)); + if (list_empty(ldlm_namespace_list(client))) { + mutex_unlock(ldlm_namespace_lock(client)); + break; + } + ns = ldlm_namespace_first_locked(client); + + if (ns_old == ns) { /* Full pass complete */ + mutex_unlock(ldlm_namespace_lock(client)); + break; + } + + /* We got an empty namespace, need to move it back to inactive + * list. + * The race with parallel resource creation is fine: + * - If they do namespace_get before our check, we fail the + * check and they move this item to the end of the list anyway + * - If we do the check and then they do namespace_get, then + * we move the namespace to inactive and they will move + * it back to active (synchronised by the lock, so no clash + * there). + */ + if (ldlm_ns_empty(ns)) { + ldlm_namespace_move_to_inactive_locked(ns, client); + mutex_unlock(ldlm_namespace_lock(client)); + continue; + } + + if (ns_old == NULL) + ns_old = ns; + + spin_lock(&ns->ns_lock); + /* + * skip ns which is being freed, and we don't want to increase + * its refcount again, not even temporarily. bz21519 & LU-499. + */ + if (ns->ns_stopping) { + skip = 1; + } else { + skip = 0; + ldlm_namespace_get(ns); + } + spin_unlock(&ns->ns_lock); + + ldlm_namespace_move_to_active_locked(ns, client); + mutex_unlock(ldlm_namespace_lock(client)); + + /* + * After setup is done - recalc the pool. + */ + if (!skip) { + int ttime = ldlm_pool_recalc(&ns->ns_pool); + + if (ttime < time) + time = ttime; + + ldlm_namespace_put(ns); + } } + return time; } EXPORT_SYMBOL(ldlm_pools_recalc); static int ldlm_pools_thread_main(void *arg) { - struct ptlrpc_thread *thread = (struct ptlrpc_thread *)arg; - char *t_name = "ldlm_poold"; - ENTRY; + struct ptlrpc_thread *thread = (struct ptlrpc_thread *)arg; + int s_time, c_time; + ENTRY; - cfs_daemonize(t_name); - thread_set_flags(thread, SVC_RUNNING); - cfs_waitq_signal(&thread->t_ctl_waitq); + thread_set_flags(thread, SVC_RUNNING); + wake_up(&thread->t_ctl_waitq); - CDEBUG(D_DLMTRACE, "%s: pool thread starting, process %d\n", - t_name, cfs_curproc_pid()); + CDEBUG(D_DLMTRACE, "%s: pool thread starting, process %d\n", + "ldlm_poold", current_pid()); while (1) { struct l_wait_info lwi; - /* - * Recal all pools on this tick. - */ - ldlm_pools_recalc(LDLM_NAMESPACE_SERVER); - ldlm_pools_recalc(LDLM_NAMESPACE_CLIENT); - - /* - * Wait until the next check time, or until we're - * stopped. - */ - lwi = LWI_TIMEOUT(cfs_time_seconds(LDLM_POOLS_THREAD_PERIOD), - NULL, NULL); + /* + * Recal all pools on this tick. + */ + s_time = ldlm_pools_recalc(LDLM_NAMESPACE_SERVER); + c_time = ldlm_pools_recalc(LDLM_NAMESPACE_CLIENT); + + /* + * Wait until the next check time, or until we're + * stopped. + */ + lwi = LWI_TIMEOUT(cfs_time_seconds(min(s_time, c_time)), + NULL, NULL); l_wait_event(thread->t_ctl_waitq, thread_is_stopping(thread) || thread_is_event(thread), @@ -1333,104 +1403,100 @@ static int ldlm_pools_thread_main(void *arg) thread_test_and_clear_flags(thread, SVC_EVENT); } - thread_set_flags(thread, SVC_STOPPED); - cfs_waitq_signal(&thread->t_ctl_waitq); + thread_set_flags(thread, SVC_STOPPED); + wake_up(&thread->t_ctl_waitq); - CDEBUG(D_DLMTRACE, "%s: pool thread exiting, process %d\n", - t_name, cfs_curproc_pid()); + CDEBUG(D_DLMTRACE, "%s: pool thread exiting, process %d\n", + "ldlm_poold", current_pid()); - cfs_complete_and_exit(&ldlm_pools_comp, 0); + complete_and_exit(&ldlm_pools_comp, 0); } static int ldlm_pools_thread_start(void) { - struct l_wait_info lwi = { 0 }; - int rc; - ENTRY; - - if (ldlm_pools_thread != NULL) - RETURN(-EALREADY); - - OBD_ALLOC_PTR(ldlm_pools_thread); - if (ldlm_pools_thread == NULL) - RETURN(-ENOMEM); - - cfs_init_completion(&ldlm_pools_comp); - cfs_waitq_init(&ldlm_pools_thread->t_ctl_waitq); - - /* - * CLONE_VM and CLONE_FILES just avoid a needless copy, because we - * just drop the VM and FILES in cfs_daemonize() right away. - */ - rc = cfs_create_thread(ldlm_pools_thread_main, ldlm_pools_thread, - CFS_DAEMON_FLAGS); - if (rc < 0) { - CERROR("Can't start pool thread, error %d\n", - rc); - OBD_FREE(ldlm_pools_thread, sizeof(*ldlm_pools_thread)); - ldlm_pools_thread = NULL; - RETURN(rc); - } - l_wait_event(ldlm_pools_thread->t_ctl_waitq, - thread_is_running(ldlm_pools_thread), &lwi); - RETURN(0); + struct l_wait_info lwi = { 0 }; + struct task_struct *task; + ENTRY; + + if (ldlm_pools_thread != NULL) + RETURN(-EALREADY); + + OBD_ALLOC_PTR(ldlm_pools_thread); + if (ldlm_pools_thread == NULL) + RETURN(-ENOMEM); + + init_completion(&ldlm_pools_comp); + init_waitqueue_head(&ldlm_pools_thread->t_ctl_waitq); + + task = kthread_run(ldlm_pools_thread_main, ldlm_pools_thread, + "ldlm_poold"); + if (IS_ERR(task)) { + CERROR("Can't start pool thread, error %ld\n", PTR_ERR(task)); + OBD_FREE(ldlm_pools_thread, sizeof(*ldlm_pools_thread)); + ldlm_pools_thread = NULL; + RETURN(PTR_ERR(task)); + } + l_wait_event(ldlm_pools_thread->t_ctl_waitq, + thread_is_running(ldlm_pools_thread), &lwi); + RETURN(0); } static void ldlm_pools_thread_stop(void) { - ENTRY; - - if (ldlm_pools_thread == NULL) { - EXIT; - return; - } - - thread_set_flags(ldlm_pools_thread, SVC_STOPPING); - cfs_waitq_signal(&ldlm_pools_thread->t_ctl_waitq); - - /* - * Make sure that pools thread is finished before freeing @thread. - * This fixes possible race and oops due to accessing freed memory - * in pools thread. - */ - cfs_wait_for_completion(&ldlm_pools_comp); - OBD_FREE_PTR(ldlm_pools_thread); - ldlm_pools_thread = NULL; - EXIT; + ENTRY; + + if (ldlm_pools_thread == NULL) { + EXIT; + return; + } + + thread_set_flags(ldlm_pools_thread, SVC_STOPPING); + wake_up(&ldlm_pools_thread->t_ctl_waitq); + + /* + * Make sure that pools thread is finished before freeing @thread. + * This fixes possible race and oops due to accessing freed memory + * in pools thread. + */ + wait_for_completion(&ldlm_pools_comp); + OBD_FREE_PTR(ldlm_pools_thread); + ldlm_pools_thread = NULL; + EXIT; } int ldlm_pools_init(void) { - int rc; - ENTRY; - - rc = ldlm_pools_thread_start(); - if (rc == 0) { - ldlm_pools_srv_shrinker = - cfs_set_shrinker(CFS_DEFAULT_SEEKS, - ldlm_pools_srv_shrink); - ldlm_pools_cli_shrinker = - cfs_set_shrinker(CFS_DEFAULT_SEEKS, - ldlm_pools_cli_shrink); - } - RETURN(rc); + int rc; + DEF_SHRINKER_VAR(shsvar, ldlm_pools_srv_shrink, + ldlm_pools_srv_count, ldlm_pools_srv_scan); + DEF_SHRINKER_VAR(shcvar, ldlm_pools_cli_shrink, + ldlm_pools_cli_count, ldlm_pools_cli_scan); + ENTRY; + + rc = ldlm_pools_thread_start(); + if (rc == 0) { + ldlm_pools_srv_shrinker = + set_shrinker(DEFAULT_SEEKS, &shsvar); + ldlm_pools_cli_shrinker = + set_shrinker(DEFAULT_SEEKS, &shcvar); + } + RETURN(rc); } EXPORT_SYMBOL(ldlm_pools_init); void ldlm_pools_fini(void) { - if (ldlm_pools_srv_shrinker != NULL) { - cfs_remove_shrinker(ldlm_pools_srv_shrinker); - ldlm_pools_srv_shrinker = NULL; - } - if (ldlm_pools_cli_shrinker != NULL) { - cfs_remove_shrinker(ldlm_pools_cli_shrinker); - ldlm_pools_cli_shrinker = NULL; - } - ldlm_pools_thread_stop(); + if (ldlm_pools_srv_shrinker != NULL) { + remove_shrinker(ldlm_pools_srv_shrinker); + ldlm_pools_srv_shrinker = NULL; + } + if (ldlm_pools_cli_shrinker != NULL) { + remove_shrinker(ldlm_pools_cli_shrinker); + ldlm_pools_cli_shrinker = NULL; + } + ldlm_pools_thread_stop(); } EXPORT_SYMBOL(ldlm_pools_fini); -#endif /* __KERNEL__ */ #else /* !HAVE_LRU_RESIZE_SUPPORT */ int ldlm_pool_setup(struct ldlm_pool *pl, int limit) @@ -1446,7 +1512,7 @@ int ldlm_pool_recalc(struct ldlm_pool *pl) EXPORT_SYMBOL(ldlm_pool_recalc); int ldlm_pool_shrink(struct ldlm_pool *pl, - int nr, unsigned int gfp_mask) + int nr, gfp_t gfp_mask) { return 0; } @@ -1531,9 +1597,9 @@ void ldlm_pools_fini(void) } EXPORT_SYMBOL(ldlm_pools_fini); -void ldlm_pools_recalc(ldlm_side_t client) +int ldlm_pools_recalc(ldlm_side_t client) { - return; + return 0; } EXPORT_SYMBOL(ldlm_pools_recalc); #endif /* HAVE_LRU_RESIZE_SUPPORT */