X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lustre%2Fmdt%2Fmdt_lproc.c;h=514139414d93cab2abe0812b903afdca600b2385;hp=667285d0ca22ac12170868056b69604f6cad2ac8;hb=e8273a3dd71c4e6ab5ca9de3fbfbc0f7603d6930;hpb=26b8238659974959780cd49de92595b4b0bdf89f;ds=sidebyside diff --git a/lustre/mdt/mdt_lproc.c b/lustre/mdt/mdt_lproc.c index 667285d..5141394 100644 --- a/lustre/mdt/mdt_lproc.c +++ b/lustre/mdt/mdt_lproc.c @@ -217,7 +217,8 @@ static int mdt_identity_expire_seq_show(struct seq_file *m, void *data) struct obd_device *obd = m->private; struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev); - return seq_printf(m, "%u\n", mdt->mdt_identity_cache->uc_entry_expire); + seq_printf(m, "%u\n", mdt->mdt_identity_cache->uc_entry_expire); + return 0; } static ssize_t @@ -227,13 +228,17 @@ mdt_identity_expire_seq_write(struct file *file, const char __user *buffer, struct seq_file *m = file->private_data; struct obd_device *obd = m->private; struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev); - int rc, val; + int rc; + __s64 val; - rc = lprocfs_write_helper(buffer, count, &val); + rc = lprocfs_str_to_s64(buffer, count, &val); if (rc) return rc; + if (val < 0 || val > INT_MAX) + return -ERANGE; mdt->mdt_identity_cache->uc_entry_expire = val; + return count; } LPROC_SEQ_FOPS(mdt_identity_expire); @@ -243,7 +248,8 @@ static int mdt_identity_acquire_expire_seq_show(struct seq_file *m, void *data) struct obd_device *obd = m->private; struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev); - return seq_printf(m, "%u\n", mdt->mdt_identity_cache->uc_acquire_expire); + seq_printf(m, "%u\n", mdt->mdt_identity_cache->uc_acquire_expire); + return 0; } static ssize_t @@ -254,13 +260,17 @@ mdt_identity_acquire_expire_seq_write(struct file *file, struct seq_file *m = file->private_data; struct obd_device *obd = m->private; struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev); - int rc, val; + int rc; + __s64 val; - rc = lprocfs_write_helper(buffer, count, &val); + rc = lprocfs_str_to_s64(buffer, count, &val); if (rc) return rc; + if (val < 0 || val > INT_MAX) + return -ERANGE; mdt->mdt_identity_cache->uc_acquire_expire = val; + return count; } LPROC_SEQ_FOPS(mdt_identity_acquire_expire); @@ -271,9 +281,9 @@ static int mdt_identity_upcall_seq_show(struct seq_file *m, void *data) struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev); struct upcall_cache *hash = mdt->mdt_identity_cache; - read_lock(&hash->uc_upcall_rwlock); + down_read(&hash->uc_upcall_rwsem); seq_printf(m, "%s\n", hash->uc_upcall); - read_unlock(&hash->uc_upcall_rwlock); + up_read(&hash->uc_upcall_rwsem); return 0; } @@ -299,9 +309,9 @@ mdt_identity_upcall_seq_write(struct file *file, const char __user *buffer, GOTO(failed, rc = -EFAULT); /* Remove any extraneous bits from the upcall (e.g. linefeeds) */ - write_lock(&hash->uc_upcall_rwlock); + down_write(&hash->uc_upcall_rwsem); sscanf(kernbuf, "%s", hash->uc_upcall); - write_unlock(&hash->uc_upcall_rwlock); + up_write(&hash->uc_upcall_rwsem); if (strcmp(hash->uc_name, mdt_obd_name(mdt)) != 0) CWARN("%s: write to upcall name %s\n", @@ -330,11 +340,14 @@ lprocfs_identity_flush_seq_write(struct file *file, const char __user *buffer, struct seq_file *m = file->private_data; struct obd_device *obd = m->private; struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev); - int rc, uid; + int rc; + __s64 uid; - rc = lprocfs_write_helper(buffer, count, &uid); + rc = lprocfs_str_to_s64(buffer, count, &uid); if (rc) return rc; + if (uid < INT_MIN || uid > INT_MAX) + return -ERANGE; mdt_flush_identity(mdt->mdt_identity_cache, uid); return count; @@ -421,85 +434,93 @@ LPROC_SEQ_FOPS_RO(mdt_site_stats); #define BUFLEN (UUID_MAX + 4) static ssize_t -lprocfs_mds_evict_client_seq_write(struct file *file, - const char __user *buffer, +lprocfs_mds_evict_client_seq_write(struct file *file, const char __user *buf, size_t count, loff_t *off) { + struct seq_file *m = file->private_data; + struct obd_device *obd = m->private; + struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev); char *kbuf; char *tmpbuf; + int rc = 0; - OBD_ALLOC(kbuf, BUFLEN); - if (kbuf == NULL) - return -ENOMEM; - - /* - * OBD_ALLOC() will zero kbuf, but we only copy BUFLEN - 1 - * bytes into kbuf, to ensure that the string is NUL-terminated. - * UUID_MAX should include a trailing NUL already. - */ - if (copy_from_user(kbuf, buffer, - min_t(unsigned long, BUFLEN - 1, count))) { - count = -EFAULT; - goto out; - } - tmpbuf = cfs_firststr(kbuf, min_t(unsigned long, BUFLEN - 1, count)); + OBD_ALLOC(kbuf, BUFLEN); + if (kbuf == NULL) + return -ENOMEM; - if (strncmp(tmpbuf, "nid:", 4) != 0) { - count = lprocfs_evict_client_seq_write(file, buffer, count, - off); - goto out; - } + /* + * OBD_ALLOC() will zero kbuf, but we only copy BUFLEN - 1 + * bytes into kbuf, to ensure that the string is NUL-terminated. + * UUID_MAX should include a trailing NUL already. + */ + if (copy_from_user(kbuf, buf, min_t(unsigned long, BUFLEN - 1, count))) + GOTO(out, rc = -EFAULT); + tmpbuf = cfs_firststr(kbuf, min_t(unsigned long, BUFLEN - 1, count)); + + if (strncmp(tmpbuf, "nid:", 4) != 0) { + count = lprocfs_evict_client_seq_write(file, buf, count, off); + goto out; + } + + if (mdt->mdt_opts.mo_evict_tgt_nids) { + rc = obd_set_info_async(NULL, mdt->mdt_child_exp, + sizeof(KEY_EVICT_BY_NID), + KEY_EVICT_BY_NID, + strlen(tmpbuf + 4) + 1, + tmpbuf + 4, NULL); + if (rc) + CERROR("Failed to evict nid %s from OSTs: rc %d\n", + tmpbuf + 4, rc); + } + + /* See the comments in function lprocfs_wr_evict_client() + * in ptlrpc/lproc_ptlrpc.c for details. - jay */ + class_incref(obd, __func__, current); + obd_export_evict_by_nid(obd, tmpbuf + 4); + class_decref(obd, __func__, current); - CERROR("NOT implement evict client by nid %s\n", tmpbuf); out: - OBD_FREE(kbuf, BUFLEN); - return count; + OBD_FREE(kbuf, BUFLEN); + return rc < 0 ? rc : count; } #undef BUFLEN -static int mdt_sec_level_seq_show(struct seq_file *m, void *data) +static int mdt_evict_tgt_nids_seq_show(struct seq_file *m, void *data) { struct obd_device *obd = m->private; struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev); - return seq_printf(m, "%d\n", mdt->mdt_lut.lut_sec_level); + seq_printf(m, "%u\n", mdt->mdt_opts.mo_evict_tgt_nids); + return 0; } static ssize_t -mdt_sec_level_seq_write(struct file *file, const char __user *buffer, - size_t count, loff_t *off) +mdt_evict_tgt_nids_seq_write(struct file *file, const char __user *buffer, + size_t count, loff_t *off) { - struct seq_file *m = file->private_data; + struct seq_file *m = file->private_data; struct obd_device *obd = m->private; struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev); - int val, rc; - - rc = lprocfs_write_helper(buffer, count, &val); - if (rc) - return rc; - - if (val > LUSTRE_SEC_ALL || val < LUSTRE_SEC_NONE) - return -EINVAL; - - if (val == LUSTRE_SEC_SPECIFY) { - CWARN("security level %d will be supported in future.\n", - LUSTRE_SEC_SPECIFY); - return -EINVAL; - } + __s64 val; + int rc; - mdt->mdt_lut.lut_sec_level = val; + rc = lprocfs_str_to_s64(buffer, count, &val); + if (rc) + return rc; + mdt->mdt_opts.mo_evict_tgt_nids = !!val; return count; } -LPROC_SEQ_FOPS(mdt_sec_level); +LPROC_SEQ_FOPS(mdt_evict_tgt_nids); static int mdt_cos_seq_show(struct seq_file *m, void *data) { struct obd_device *obd = m->private; struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev); - return seq_printf(m, "%u\n", mdt_cos_is_enabled(mdt)); + seq_printf(m, "%u\n", mdt_cos_is_enabled(mdt)); + return 0; } static ssize_t @@ -509,11 +530,15 @@ mdt_cos_seq_write(struct file *file, const char __user *buffer, struct seq_file *m = file->private_data; struct obd_device *obd = m->private; struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev); - int val, rc; + int rc; + __s64 val; - rc = lprocfs_write_helper(buffer, count, &val); + rc = lprocfs_str_to_s64(buffer, count, &val); if (rc) return rc; + if (val < INT_MIN || val > INT_MAX) + return -ERANGE; + mdt_enable_cos(mdt, val); return count; } @@ -525,8 +550,9 @@ static int mdt_root_squash_seq_show(struct seq_file *m, void *data) struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev); struct root_squash_info *squash = &mdt->mdt_squash; - return seq_printf(m, "%u:%u\n", squash->rsi_uid, - squash->rsi_gid); + seq_printf(m, "%u:%u\n", squash->rsi_uid, + squash->rsi_gid); + return 0; } static ssize_t @@ -548,19 +574,19 @@ static int mdt_nosquash_nids_seq_show(struct seq_file *m, void *data) struct obd_device *obd = m->private; struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev); struct root_squash_info *squash = &mdt->mdt_squash; - int len = 0, rc; + int len = 0; down_read(&squash->rsi_sem); if (!list_empty(&squash->rsi_nosquash_nids)) { len = cfs_print_nidlist(m->buf + m->count, m->size - m->count, &squash->rsi_nosquash_nids); m->count += len; - rc = seq_printf(m, "\n"); + seq_putc(m, '\n'); } else - rc = seq_printf(m, "NONE\n"); + seq_puts(m, "NONE\n"); up_read(&squash->rsi_sem); - return rc; + return 0; } static ssize_t @@ -582,7 +608,8 @@ static int mdt_enable_remote_dir_seq_show(struct seq_file *m, void *data) struct obd_device *obd = m->private; struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev); - return seq_printf(m, "%u\n", mdt->mdt_enable_remote_dir); + seq_printf(m, "%u\n", mdt->mdt_enable_remote_dir); + return 0; } static ssize_t @@ -592,14 +619,14 @@ mdt_enable_remote_dir_seq_write(struct file *file, const char __user *buffer, struct seq_file *m = file->private_data; struct obd_device *obd = m->private; struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev); - __u32 val; + __s64 val; int rc; - rc = lprocfs_write_helper(buffer, count, &val); + rc = lprocfs_str_to_s64(buffer, count, &val); if (rc) return rc; - if (val > 1) + if (val > 1 || val < 0) return -ERANGE; mdt->mdt_enable_remote_dir = val; @@ -612,8 +639,9 @@ static int mdt_enable_remote_dir_gid_seq_show(struct seq_file *m, void *data) struct obd_device *obd = m->private; struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev); - return seq_printf(m, "%d\n", - (int)mdt->mdt_enable_remote_dir_gid); + seq_printf(m, "%d\n", + (int)mdt->mdt_enable_remote_dir_gid); + return 0; } static ssize_t @@ -624,10 +652,10 @@ mdt_enable_remote_dir_gid_seq_write(struct file *file, struct seq_file *m = file->private_data; struct obd_device *obd = m->private; struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev); - __u32 val; + __s64 val; int rc; - rc = lprocfs_write_helper(buffer, count, &val); + rc = lprocfs_str_to_s64(buffer, count, &val); if (rc) return rc; @@ -636,6 +664,109 @@ mdt_enable_remote_dir_gid_seq_write(struct file *file, } LPROC_SEQ_FOPS(mdt_enable_remote_dir_gid); +/** + * Show MDT policy for handling dirty metadata under a lock being cancelled. + * + * \param[in] m seq_file handle + * \param[in] data unused for single entry + * + * \retval 0 on success + * \retval negative value on error + */ +static int mdt_slc_seq_show(struct seq_file *m, void *data) +{ + struct obd_device *obd = m->private; + struct lu_target *tgt = obd->u.obt.obt_lut; + char *slc_states[] = {"never", "blocking", "always" }; + + seq_printf(m, "%s\n", slc_states[tgt->lut_sync_lock_cancel]); + return 0; +} +LPROC_SEQ_FOPS_RO(mdt_slc); + +/** + * Show MDT async commit count. + * + * \param[in] m seq_file handle + * \param[in] data unused for single entry + * + * \retval 0 on success + * \retval negative value on error + */ +static int mdt_async_commit_count_seq_show(struct seq_file *m, void *data) +{ + struct obd_device *obd = m->private; + struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev); + + seq_printf(m, "%d\n", atomic_read(&mdt->mdt_async_commit_count)); + return 0; +} + +static ssize_t +mdt_async_commit_count_seq_write(struct file *file, const char __user *buffer, + size_t count, loff_t *off) +{ + struct seq_file *m = file->private_data; + struct obd_device *obd = m->private; + struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev); + __s64 val; + int rc; + + rc = lprocfs_str_to_s64(buffer, count, &val); + if (rc) + return rc; + + if (val < INT_MIN || val > INT_MAX) + return -ERANGE; + + atomic_set(&mdt->mdt_async_commit_count, val); + + return count; +} +LPROC_SEQ_FOPS(mdt_async_commit_count); + +/** + * Show MDT sync count. + * + * \param[in] m seq_file handle + * \param[in] data unused for single entry + * + * \retval 0 on success + * \retval negative value on error + */ +static int mdt_sync_count_seq_show(struct seq_file *m, void *data) +{ + struct obd_device *obd = m->private; + struct lu_target *tgt = obd->u.obt.obt_lut; + + seq_printf(m, "%d\n", atomic_read(&tgt->lut_sync_count)); + return 0; +} + +static ssize_t +mdt_sync_count_seq_write(struct file *file, const char __user *buffer, + size_t count, loff_t *off) +{ + struct seq_file *m = file->private_data; + struct obd_device *obd = m->private; + struct lu_target *tgt = obd->u.obt.obt_lut; + __s64 val; + int rc; + + rc = lprocfs_str_to_s64(buffer, count, &val); + if (rc) + return rc; + + if (val < INT_MIN || val > INT_MAX) + return -ERANGE; + + atomic_set(&tgt->lut_sync_count, val); + + return count; +} +LPROC_SEQ_FOPS(mdt_sync_count); + + LPROC_SEQ_FOPS_RO_TYPE(mdt, uuid); LPROC_SEQ_FOPS_RO_TYPE(mdt, recovery_status); LPROC_SEQ_FOPS_RO_TYPE(mdt, num_exports); @@ -647,6 +778,9 @@ LPROC_SEQ_FOPS_RW_TYPE(mdt, ir_factor); LPROC_SEQ_FOPS_RW_TYPE(mdt, nid_stats_clear); LPROC_SEQ_FOPS(mdt_hsm_cdt_control); +LPROC_SEQ_FOPS_RW_TYPE(mdt, recovery_time_hard); +LPROC_SEQ_FOPS_RW_TYPE(mdt, recovery_time_soft); + static struct lprocfs_vars lprocfs_mdt_obd_vars[] = { { .name = "uuid", .fops = &mdt_uuid_fops }, @@ -668,10 +802,10 @@ static struct lprocfs_vars lprocfs_mdt_obd_vars[] = { .fops = &mdt_site_stats_fops }, { .name = "evict_client", .fops = &mdt_mds_evict_client_fops }, + { .name = "evict_tgt_nids", + .fops = &mdt_evict_tgt_nids_fops }, { .name = "hash_stats", .fops = &mdt_hash_fops }, - { .name = "sec_level", - .fops = &mdt_sec_level_fops }, { .name = "commit_on_sharing", .fops = &mdt_cos_fops }, { .name = "root_squash", @@ -690,11 +824,22 @@ static struct lprocfs_vars lprocfs_mdt_obd_vars[] = { .fops = &mdt_enable_remote_dir_gid_fops }, { .name = "hsm_control", .fops = &mdt_hsm_cdt_control_fops }, + { .name = "recovery_time_hard", + .fops = &mdt_recovery_time_hard_fops }, + { .name = "recovery_time_soft", + .fops = &mdt_recovery_time_soft_fops }, + { .name = "sync_lock_cancel", + .fops = &mdt_slc_fops }, + { .name = "async_commit_count", + .fops = &mdt_async_commit_count_fops }, + { .name = "sync_count", + .fops = &mdt_sync_count_fops }, { NULL } }; -static int lprocfs_mdt_print_open_files(cfs_hash_t *hs, cfs_hash_bd_t *bd, - struct hlist_node *hnode, void *v) +static int +lprocfs_mdt_print_open_files(struct cfs_hash *hs, struct cfs_hash_bd *bd, + struct hlist_node *hnode, void *v) { struct obd_export *exp = cfs_hash_object(hs, hnode); struct seq_file *seq = v;