void ldlm_namespace_proc_unregister(struct ldlm_namespace *ns) { struct proc_dir_entry *dir; dir = lprocfs_srch(ldlm_ns_proc_dir, ldlm_ns_name(ns)); if (dir == NULL) { CERROR("dlm namespace %s has no procfs dir?\n", ldlm_ns_name(ns)); } else { lprocfs_remove(&dir); } if (ns->ns_stats != NULL) lprocfs_free_stats(&ns->ns_stats); }
int ldlm_namespace_proc_register(struct ldlm_namespace *ns) { struct lprocfs_vars lock_vars[2]; char lock_name[MAX_STRING_SIZE + 1]; proc_dir_entry_t *ns_pde; LASSERT(ns != NULL); LASSERT(ns->ns_rs_hash != NULL); if (ns->ns_proc_dir_entry != NULL) { ns_pde = ns->ns_proc_dir_entry; } else { ns_pde = proc_mkdir(ldlm_ns_name(ns), ldlm_ns_proc_dir); if (ns_pde == NULL) return -ENOMEM; ns->ns_proc_dir_entry = ns_pde; } ns->ns_stats = lprocfs_alloc_stats(LDLM_NSS_LAST, 0); if (ns->ns_stats == NULL) return -ENOMEM; lprocfs_counter_init(ns->ns_stats, LDLM_NSS_LOCKS, LPROCFS_CNTR_AVGMINMAX, "locks", "locks"); lock_name[MAX_STRING_SIZE] = '\0'; memset(lock_vars, 0, sizeof(lock_vars)); lock_vars[0].name = lock_name; LDLM_NS_ADD_VAR("resource_count", ns, &lprocfs_ns_resources_fops); LDLM_NS_ADD_VAR("lock_count", ns, &lprocfs_ns_locks_fops); if (ns_is_client(ns)) { LDLM_NS_ADD_VAR("lock_unused_count", &ns->ns_nr_unused, &ldlm_uint_fops); LDLM_NS_ADD_VAR("lru_size", ns, &lprocfs_lru_size_fops); LDLM_NS_ADD_VAR("lru_max_age", &ns->ns_max_age, &ldlm_rw_uint_fops); LDLM_NS_ADD_VAR("early_lock_cancel", ns, &lprocfs_elc_fops); } else { LDLM_NS_ADD_VAR("ctime_age_limit", &ns->ns_ctime_age_limit, &ldlm_rw_uint_fops); LDLM_NS_ADD_VAR("lock_timeouts", &ns->ns_timeouts, &ldlm_uint_fops); LDLM_NS_ADD_VAR("max_nolock_bytes", &ns->ns_max_nolock_size, &ldlm_rw_uint_fops); LDLM_NS_ADD_VAR("contention_seconds", &ns->ns_contention_time, &ldlm_rw_uint_fops); LDLM_NS_ADD_VAR("contended_locks", &ns->ns_contended_locks, &ldlm_rw_uint_fops); LDLM_NS_ADD_VAR("max_parallel_ast", &ns->ns_max_parallel_ast, &ldlm_rw_uint_fops); } return 0; }
static void ldlm_namespace_debugfs_unregister(struct ldlm_namespace *ns) { if (IS_ERR_OR_NULL(ns->ns_debugfs_entry)) CERROR("dlm namespace %s has no procfs dir?\n", ldlm_ns_name(ns)); else ldebugfs_remove(&ns->ns_debugfs_entry); if (ns->ns_stats) lprocfs_free_stats(&ns->ns_stats); }
void ldlm_namespace_proc_unregister(struct ldlm_namespace *ns) { if (ns->ns_proc_dir_entry == NULL) CERROR("dlm namespace %s has no procfs dir?\n", ldlm_ns_name(ns)); else lprocfs_remove(&ns->ns_proc_dir_entry); if (ns->ns_stats != NULL) lprocfs_free_stats(&ns->ns_stats); }
static int ldlm_namespace_debugfs_register(struct ldlm_namespace *ns) { struct dentry *ns_entry; if (!IS_ERR_OR_NULL(ns->ns_debugfs_entry)) { ns_entry = ns->ns_debugfs_entry; } else { ns_entry = debugfs_create_dir(ldlm_ns_name(ns), ldlm_ns_debugfs_dir); if (!ns_entry) return -ENOMEM; ns->ns_debugfs_entry = ns_entry; } return 0; }
static int ldlm_namespace_sysfs_register(struct ldlm_namespace *ns) { int err; ns->ns_kobj.kset = ldlm_ns_kset; init_completion(&ns->ns_kobj_unregister); err = kobject_init_and_add(&ns->ns_kobj, &ldlm_ns_ktype, NULL, "%s", ldlm_ns_name(ns)); ns->ns_stats = lprocfs_alloc_stats(LDLM_NSS_LAST, 0); if (!ns->ns_stats) { kobject_put(&ns->ns_kobj); return -ENOMEM; } lprocfs_counter_init(ns->ns_stats, LDLM_NSS_LOCKS, LPROCFS_CNTR_AVGMINMAX, "locks", "locks"); return err; }
static ssize_t lru_size_store(struct kobject *kobj, struct attribute *attr, const char *buffer, size_t count) { struct ldlm_namespace *ns = container_of(kobj, struct ldlm_namespace, ns_kobj); unsigned long tmp; int lru_resize; int err; if (strncmp(buffer, "clear", 5) == 0) { CDEBUG(D_DLMTRACE, "dropping all unused locks from namespace %s\n", ldlm_ns_name(ns)); if (ns_connect_lru_resize(ns)) { int canceled, unused = ns->ns_nr_unused; /* Try to cancel all @ns_nr_unused locks. */ canceled = ldlm_cancel_lru(ns, unused, 0, LDLM_LRU_FLAG_PASSED); if (canceled < unused) { CDEBUG(D_DLMTRACE, "not all requested locks are canceled, requested: %d, canceled: %d\n", unused, canceled); return -EINVAL; } } else { tmp = ns->ns_max_unused; ns->ns_max_unused = 0; ldlm_cancel_lru(ns, 0, 0, LDLM_LRU_FLAG_PASSED); ns->ns_max_unused = tmp; } return count; } err = kstrtoul(buffer, 10, &tmp); if (err != 0) { CERROR("lru_size: invalid value written\n"); return -EINVAL; } lru_resize = (tmp == 0); if (ns_connect_lru_resize(ns)) { if (!lru_resize) ns->ns_max_unused = (unsigned int)tmp; if (tmp > ns->ns_nr_unused) tmp = ns->ns_nr_unused; tmp = ns->ns_nr_unused - tmp; CDEBUG(D_DLMTRACE, "changing namespace %s unused locks from %u to %u\n", ldlm_ns_name(ns), ns->ns_nr_unused, (unsigned int)tmp); ldlm_cancel_lru(ns, tmp, LCF_ASYNC, LDLM_LRU_FLAG_PASSED); if (!lru_resize) { CDEBUG(D_DLMTRACE, "disable lru_resize for namespace %s\n", ldlm_ns_name(ns)); ns->ns_connect_flags &= ~OBD_CONNECT_LRU_RESIZE; } } else { CDEBUG(D_DLMTRACE, "changing namespace %s max_unused from %u to %u\n", ldlm_ns_name(ns), ns->ns_max_unused, (unsigned int)tmp); ns->ns_max_unused = (unsigned int)tmp; ldlm_cancel_lru(ns, 0, LCF_ASYNC, LDLM_LRU_FLAG_PASSED); /* Make sure that LRU resize was originally supported before * turning it on here. */ if (lru_resize && (ns->ns_orig_connect_flags & OBD_CONNECT_LRU_RESIZE)) { CDEBUG(D_DLMTRACE, "enable lru_resize for namespace %s\n", ldlm_ns_name(ns)); ns->ns_connect_flags |= OBD_CONNECT_LRU_RESIZE; } } return count; }
static ssize_t lprocfs_lru_size_seq_write(struct file *file, const char *buffer, size_t count, loff_t *off) { struct ldlm_namespace *ns = ((struct seq_file *)file->private_data)->private; char dummy[MAX_STRING_SIZE + 1], *end; unsigned long tmp; int lru_resize; dummy[MAX_STRING_SIZE] = '\0'; if (copy_from_user(dummy, buffer, MAX_STRING_SIZE)) return -EFAULT; if (strncmp(dummy, "clear", 5) == 0) { CDEBUG(D_DLMTRACE, "dropping all unused locks from namespace %s\n", ldlm_ns_name(ns)); if (ns_connect_lru_resize(ns)) { int canceled, unused = ns->ns_nr_unused; /* Try to cancel all @ns_nr_unused locks. */ canceled = ldlm_cancel_lru(ns, unused, 0, LDLM_CANCEL_PASSED); if (canceled < unused) { CDEBUG(D_DLMTRACE, "not all requested locks are canceled, " "requested: %d, canceled: %d\n", unused, canceled); return -EINVAL; } } else { tmp = ns->ns_max_unused; ns->ns_max_unused = 0; ldlm_cancel_lru(ns, 0, 0, LDLM_CANCEL_PASSED); ns->ns_max_unused = tmp; } return count; } tmp = simple_strtoul(dummy, &end, 0); if (dummy == end) { CERROR("invalid value written\n"); return -EINVAL; } lru_resize = (tmp == 0); if (ns_connect_lru_resize(ns)) { if (!lru_resize) ns->ns_max_unused = (unsigned int)tmp; if (tmp > ns->ns_nr_unused) tmp = ns->ns_nr_unused; tmp = ns->ns_nr_unused - tmp; CDEBUG(D_DLMTRACE, "changing namespace %s unused locks from %u to %u\n", ldlm_ns_name(ns), ns->ns_nr_unused, (unsigned int)tmp); ldlm_cancel_lru(ns, tmp, LCF_ASYNC, LDLM_CANCEL_PASSED); if (!lru_resize) { CDEBUG(D_DLMTRACE, "disable lru_resize for namespace %s\n", ldlm_ns_name(ns)); ns->ns_connect_flags &= ~OBD_CONNECT_LRU_RESIZE; } } else { CDEBUG(D_DLMTRACE, "changing namespace %s max_unused from %u to %u\n", ldlm_ns_name(ns), ns->ns_max_unused, (unsigned int)tmp); ns->ns_max_unused = (unsigned int)tmp; ldlm_cancel_lru(ns, 0, LCF_ASYNC, LDLM_CANCEL_PASSED); /* Make sure that LRU resize was originally supported before * turning it on here. */ if (lru_resize && (ns->ns_orig_connect_flags & OBD_CONNECT_LRU_RESIZE)) { CDEBUG(D_DLMTRACE, "enable lru_resize for namespace %s\n", ldlm_ns_name(ns)); ns->ns_connect_flags |= OBD_CONNECT_LRU_RESIZE; } } return count; }
int ldlm_namespace_proc_register(struct ldlm_namespace *ns) { struct lprocfs_vars lock_vars[2]; char lock_name[MAX_STRING_SIZE + 1]; LASSERT(ns != NULL); LASSERT(ns->ns_rs_hash != NULL); ns->ns_stats = lprocfs_alloc_stats(LDLM_NSS_LAST, 0); if (ns->ns_stats == NULL) return -ENOMEM; lprocfs_counter_init(ns->ns_stats, LDLM_NSS_LOCKS, LPROCFS_CNTR_AVGMINMAX, "locks", "locks"); lock_name[MAX_STRING_SIZE] = '\0'; memset(lock_vars, 0, sizeof(lock_vars)); lock_vars[0].name = lock_name; snprintf(lock_name, MAX_STRING_SIZE, "%s/resource_count", ldlm_ns_name(ns)); lock_vars[0].data = ns; lock_vars[0].read_fptr = lprocfs_rd_ns_resources; lprocfs_add_vars(ldlm_ns_proc_dir, lock_vars, 0); snprintf(lock_name, MAX_STRING_SIZE, "%s/lock_count", ldlm_ns_name(ns)); lock_vars[0].data = ns; lock_vars[0].read_fptr = lprocfs_rd_ns_locks; lprocfs_add_vars(ldlm_ns_proc_dir, lock_vars, 0); if (ns_is_client(ns)) { snprintf(lock_name, MAX_STRING_SIZE, "%s/lock_unused_count", ldlm_ns_name(ns)); lock_vars[0].data = &ns->ns_nr_unused; lock_vars[0].read_fptr = lprocfs_rd_uint; lprocfs_add_vars(ldlm_ns_proc_dir, lock_vars, 0); snprintf(lock_name, MAX_STRING_SIZE, "%s/lru_size", ldlm_ns_name(ns)); lock_vars[0].data = ns; lock_vars[0].read_fptr = lprocfs_rd_lru_size; lock_vars[0].write_fptr = lprocfs_wr_lru_size; lprocfs_add_vars(ldlm_ns_proc_dir, lock_vars, 0); snprintf(lock_name, MAX_STRING_SIZE, "%s/lru_max_age", ldlm_ns_name(ns)); lock_vars[0].data = &ns->ns_max_age; lock_vars[0].read_fptr = lprocfs_rd_uint; lock_vars[0].write_fptr = lprocfs_wr_uint; lprocfs_add_vars(ldlm_ns_proc_dir, lock_vars, 0); snprintf(lock_name, MAX_STRING_SIZE, "%s/early_lock_cancel", ldlm_ns_name(ns)); lock_vars[0].data = ns; lock_vars[0].read_fptr = lprocfs_rd_elc; lock_vars[0].write_fptr = lprocfs_wr_elc; lprocfs_add_vars(ldlm_ns_proc_dir, lock_vars, 0); } else { snprintf(lock_name, MAX_STRING_SIZE, "%s/ctime_age_limit", ldlm_ns_name(ns)); lock_vars[0].data = &ns->ns_ctime_age_limit; lock_vars[0].read_fptr = lprocfs_rd_uint; lock_vars[0].write_fptr = lprocfs_wr_uint; lprocfs_add_vars(ldlm_ns_proc_dir, lock_vars, 0); snprintf(lock_name, MAX_STRING_SIZE, "%s/lock_timeouts", ldlm_ns_name(ns)); lock_vars[0].data = &ns->ns_timeouts; lock_vars[0].read_fptr = lprocfs_rd_uint; lprocfs_add_vars(ldlm_ns_proc_dir, lock_vars, 0); snprintf(lock_name, MAX_STRING_SIZE, "%s/max_nolock_bytes", ldlm_ns_name(ns)); lock_vars[0].data = &ns->ns_max_nolock_size; lock_vars[0].read_fptr = lprocfs_rd_uint; lock_vars[0].write_fptr = lprocfs_wr_uint; lprocfs_add_vars(ldlm_ns_proc_dir, lock_vars, 0); snprintf(lock_name, MAX_STRING_SIZE, "%s/contention_seconds", ldlm_ns_name(ns)); lock_vars[0].data = &ns->ns_contention_time; lock_vars[0].read_fptr = lprocfs_rd_uint; lock_vars[0].write_fptr = lprocfs_wr_uint; lprocfs_add_vars(ldlm_ns_proc_dir, lock_vars, 0); snprintf(lock_name, MAX_STRING_SIZE, "%s/contended_locks", ldlm_ns_name(ns)); lock_vars[0].data = &ns->ns_contended_locks; lock_vars[0].read_fptr = lprocfs_rd_uint; lock_vars[0].write_fptr = lprocfs_wr_uint; lprocfs_add_vars(ldlm_ns_proc_dir, lock_vars, 0); snprintf(lock_name, MAX_STRING_SIZE, "%s/max_parallel_ast", ldlm_ns_name(ns)); lock_vars[0].data = &ns->ns_max_parallel_ast; lock_vars[0].read_fptr = lprocfs_rd_uint; lock_vars[0].write_fptr = lprocfs_wr_uint; lprocfs_add_vars(ldlm_ns_proc_dir, lock_vars, 0); } return 0; }