X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Fmds%2Flproc_mds.c;h=fa8cbe61d59a214cd81400f5c8a86c0d04332b43;hb=761ab6a5cd758638df384d6bf9985cb063ef0fd8;hp=853217c0fe3693872c66aa036ba115b0def4988f;hpb=191061ee668400324f4505cf498f1ee2d57e4962;p=fs%2Flustre-release.git diff --git a/lustre/mds/lproc_mds.c b/lustre/mds/lproc_mds.c index 853217c..fa8cbe6 100644 --- a/lustre/mds/lproc_mds.c +++ b/lustre/mds/lproc_mds.c @@ -31,68 +31,16 @@ #include "mds_internal.h" #ifndef LPROCFS + struct lprocfs_vars lprocfs_mds_obd_vars[] = { {0} }; struct lprocfs_vars lprocfs_mds_module_vars[] = { {0} }; struct lprocfs_vars lprocfs_mdt_obd_vars[] = { {0} }; struct lprocfs_vars lprocfs_mdt_module_vars[] = { {0} }; -atomic_t * lprocfs_alloc_mds_counters() -{ - return NULL; -} -void lprocfs_free_mds_counters(atomic_t *ptr) -{ - return; -} - #else -struct ll_mdscounters_opcode { - __u32 opcode; - const char *opname; -} ll_mdscounters_opcode_table[MDS_LAST_OPC_COUNT] = { - { MDS_OPEN_COUNT, "mds_open" }, - { MDS_CREATE_COUNT, "mds_create" }, - { MDS_CLOSE_COUNT, "mds_close" }, - { MDS_LINK_COUNT, "mds_link" }, - { MDS_UNLINK_COUNT, "mds_unlink" }, - { MDS_GETATTR_COUNT, "mds_getattr" }, - { MDS_GETATTR_NAME_COUNT, "mds_getattr_name" }, - { MDS_SETATTR_COUNT, "mds_setattr" }, - { MDS_RENAME_COUNT, "mds_rename" }, - { MDS_STATFS_COUNT, "mds_statfs" }, -}; - -const char* ll_mds_count_opcode2str(__u32 opcode) -{ - __u32 offset = opcode; - - LASSERT(offset < MDS_LAST_OPC_COUNT); - LASSERT(ll_mdscounters_opcode_table[offset].opcode == opcode); - return ll_mdscounters_opcode_table[offset].opname; -} - -struct lprocfs_stats * lprocfs_alloc_mds_counters() -{ - struct lprocfs_stats *counters; - int i; - - counters = lprocfs_alloc_stats(MDS_LAST_OPC_COUNT); - - for (i = 0; i < MDS_LAST_OPC_COUNT; i ++) { - lprocfs_counter_init(counters, i, 0, - (char *)ll_mds_count_opcode2str(i), "reqs"); - } - return counters; -} - -void lprocfs_free_mds_counters(struct lprocfs_stats *ptr) -{ - lprocfs_free_stats(ptr); -} - -static int lprocfs_mds_rd_mntdev(char *page, char **start, off_t off, int count, - int *eof, void *data) +static int lprocfs_mds_rd_mntdev(char *page, char **start, off_t off, + int count, int *eof, void *data) { struct obd_device* obd = (struct obd_device *)data; @@ -100,52 +48,8 @@ static int lprocfs_mds_rd_mntdev(char *page, char **start, off_t off, int count, LASSERT(obd->u.mds.mds_vfsmnt->mnt_devname); *eof = 1; - return snprintf(page, count, "%s\n",obd->u.mds.mds_vfsmnt->mnt_devname); -} - -static int lprocfs_rd_mds_counters(char *page, char **start, off_t off, - int count, int *eof, void *data) -{ - struct obd_device* obd = (struct obd_device *)data; - int len = 0, n, i, j; - struct lprocfs_counter t, ret = { .lc_min = ~(__u64)0 }; - struct lprocfs_stats *stats; - struct timeval now; - - LASSERT(obd != NULL); - if (obd->u.mds.mds_counters == NULL) - return 0; - - do_gettimeofday(&now); - - n = snprintf(page, count, "%-25s %lu.%lu secs.usecs\n", - "snapshot_time", now.tv_sec, now.tv_usec); - page += n; len +=n; count -=n; - - stats = obd->u.mds.mds_counters; - - *eof = 1; - for (i = 0; i < MDS_LAST_OPC_COUNT; i ++) { - ret.lc_count = 0; - for (j = 0; j < num_online_cpus(); j++) { - struct lprocfs_counter *percpu_cntr = - &(stats->ls_percpu[j])->lp_cntr[i]; - int centry; - do { - centry = - atomic_read(&percpu_cntr->lc_cntl.la_entry); - t.lc_count = percpu_cntr->lc_count; - } while (centry != - atomic_read(&percpu_cntr->lc_cntl.la_entry) && - centry != - atomic_read(&percpu_cntr->lc_cntl.la_exit)); - ret.lc_count += t.lc_count; - } - n = snprintf(page, count, "%-25s "LPU64" \n", - ll_mds_count_opcode2str(i), ret.lc_count); - page += n; len +=n; count -=n; - } - return (len); + return snprintf(page, count, "%s\n", + obd->u.mds.mds_vfsmnt->mnt_devname); } static int lprocfs_mds_wr_evict_client(struct file *file, const char *buffer, @@ -189,7 +93,44 @@ static int lprocfs_mds_wr_config_update(struct file *file, const char *buffer, struct obd_device *obd = data; ENTRY; - RETURN(mds_lov_update_config(obd, 0)); + RETURN(mds_dt_update_config(obd, 0)); +} + +static int lprocfs_rd_filesopen(char *page, char **start, off_t off, + int count, int *eof, void *data) +{ + struct obd_device *obd = data; + LASSERT(obd != NULL); + *eof = 1; + + return snprintf(page, count, "%d\n", + atomic_read(&obd->u.mds.mds_open_count)); +} + +static int lprocfs_rd_last_fid(char *page, char **start, off_t off, + int count, int *eof, void *data) +{ + struct obd_device *obd = (struct obd_device *)data; + struct mds_obd *mds = &obd->u.mds; + __u64 last_fid; + + spin_lock(&mds->mds_last_fid_lock); + last_fid = mds->mds_last_fid; + spin_unlock(&mds->mds_last_fid_lock); + + *eof = 1; + return snprintf(page, count, LPD64"\n", last_fid); +} + +static int lprocfs_rd_group(char *page, char **start, off_t off, + int count, int *eof, void *data) +{ + struct obd_device *obd = (struct obd_device *)data; + struct mds_obd *mds = &obd->u.mds; + + *eof = 1; + return snprintf(page, count, "%lu\n", + (unsigned long)mds->mds_num); } struct lprocfs_vars lprocfs_mds_obd_vars[] = { @@ -201,41 +142,45 @@ struct lprocfs_vars lprocfs_mds_obd_vars[] = { { "fstype", lprocfs_rd_fstype, 0, 0 }, { "filestotal", lprocfs_rd_filestotal, 0, 0 }, { "filesfree", lprocfs_rd_filesfree, 0, 0 }, + { "filesopen", lprocfs_rd_filesopen, 0, 0 }, { "mntdev", lprocfs_mds_rd_mntdev, 0, 0 }, + { "last_fid", lprocfs_rd_last_fid, 0, 0 }, + { "group", lprocfs_rd_group, 0, 0 }, { "recovery_status", lprocfs_obd_rd_recovery_status, 0, 0 }, { "evict_client", 0, lprocfs_mds_wr_evict_client, 0 }, { "config_update", 0, lprocfs_mds_wr_config_update, 0 }, { "num_exports", lprocfs_rd_num_exports, 0, 0 }, - { "counters", lprocfs_rd_mds_counters, 0, 0 }, { 0 } }; /* - * group hash proc entries handler + * LSD proc entry handlers */ -static int lprocfs_wr_group_info(struct file *file, const char *buffer, - unsigned long count, void *data) +static int lprocfs_wr_lsd_downcall(struct file *file, const char *buffer, + unsigned long count, void *data) { - struct { - int err; - uid_t uid; - uint32_t ngroups; - gid_t *groups; - } param; + struct upcall_cache *cache = __mds_get_global_lsd_cache(); + struct lsd_downcall_args param; gid_t gids_local[NGROUPS_SMALL]; gid_t *gids = NULL; if (count != sizeof(param)) { CERROR("invalid data size %lu\n", count); - return count; + goto do_err_downcall; } if (copy_from_user(¶m, buffer, count)) { CERROR("broken downcall\n"); - return count; + goto do_err_downcall; } + + if (param.err) { + CERROR("LSD downcall indicate error %d\n", param.err); + goto do_downcall; + } + if (param.ngroups > NGROUPS_MAX) { - CERROR("%d groups?\n", param.ngroups); - return count; + CERROR("%d groups too big\n", param.ngroups); + goto do_err_downcall; } if (param.ngroups <= NGROUPS_SMALL) @@ -245,121 +190,174 @@ static int lprocfs_wr_group_info(struct file *file, const char *buffer, if (!gids) { CERROR("fail to alloc memory for %d gids\n", param.ngroups); - return count; + goto do_err_downcall; } } if (copy_from_user(gids, param.groups, param.ngroups * sizeof(gid_t))) { CERROR("broken downcall\n"); - goto out; + goto do_err_downcall; } - mds_handle_group_downcall(param.err, param.uid, - param.ngroups, gids); + param.groups = gids; + +do_downcall: + upcall_cache_downcall(cache, (__u64) param.uid, ¶m); -out: if (gids && gids != gids_local) OBD_FREE(gids, param.ngroups * sizeof(gid_t)); return count; + +do_err_downcall: + param.err = -EINVAL; + goto do_downcall; } -static int lprocfs_rd_expire(char *page, char **start, off_t off, int count, - int *eof, void *data) + +static int lprocfs_rd_lsd_expire(char *page, char **start, off_t off, int count, + int *eof, void *data) { - struct mds_grp_hash *hash = __mds_get_global_group_hash(); + struct upcall_cache *cache= __mds_get_global_lsd_cache(); *eof = 1; - return snprintf(page, count, "%d\n", hash->gh_entry_expire); + return snprintf(page, count, "%lu\n", cache->uc_entry_expire); } -static int lprocfs_wr_expire(struct file *file, const char *buffer, - unsigned long count, void *data) +static int lprocfs_wr_lsd_expire(struct file *file, const char *buffer, + unsigned long count, void *data) { - struct mds_grp_hash *hash = __mds_get_global_group_hash(); + struct upcall_cache *cache= __mds_get_global_lsd_cache(); char buf[32]; if (copy_from_user(buf, buffer, min(count, 32UL))) return count; buf[31] = 0; - sscanf(buf, "%d", &hash->gh_entry_expire); + sscanf(buf, "%lu", &cache->uc_entry_expire); return count; } -static int lprocfs_rd_ac_expire(char *page, char **start, off_t off, int count, - int *eof, void *data) + +static int lprocfs_rd_lsd_ac_expire(char *page, char **start, off_t off, + int count, int *eof, void *data) { - struct mds_grp_hash *hash = __mds_get_global_group_hash(); + struct upcall_cache *cache= __mds_get_global_lsd_cache(); *eof = 1; - return snprintf(page, count, "%d\n", hash->gh_acquire_expire); + return snprintf(page, count, "%lu\n", cache->uc_acquire_expire); } -static int lprocfs_wr_ac_expire(struct file *file, const char *buffer, - unsigned long count, void *data) +static int lprocfs_wr_lsd_ac_expire(struct file *file, const char *buffer, + unsigned long count, void *data) { - struct mds_grp_hash *hash = __mds_get_global_group_hash(); + struct upcall_cache *cache= __mds_get_global_lsd_cache(); char buf[32]; if (copy_from_user(buf, buffer, min(count, 32UL))) return count; buf[31] = 0; - sscanf(buf, "%d", &hash->gh_acquire_expire); + sscanf(buf, "%lu", &cache->uc_acquire_expire); return count; } -static int lprocfs_rd_hash_upcall(char *page, char **start, off_t off, int count, - int *eof, void *data) + +static int lprocfs_rd_lsd_upcall(char *page, char **start, off_t off, int count, + int *eof, void *data) { - struct mds_grp_hash *hash = __mds_get_global_group_hash(); + struct upcall_cache *cache= __mds_get_global_lsd_cache(); *eof = 1; - return snprintf(page, count, "%s\n", hash->gh_upcall); + return snprintf(page, count, "%s\n", cache->uc_upcall); } -static int lprocfs_wr_hash_upcall(struct file *file, const char *buffer, - unsigned long count, void *data) +static int lprocfs_wr_lsd_upcall(struct file *file, const char *buffer, + unsigned long count, void *data) { - struct mds_grp_hash *hash = __mds_get_global_group_hash(); + struct upcall_cache *cache= __mds_get_global_lsd_cache(); - if (count < MDSGRP_UPCALL_MAXPATH) { - sscanf(buffer, "%1024s", hash->gh_upcall); - hash->gh_upcall[MDSGRP_UPCALL_MAXPATH-1] = 0; + if (count < UC_CACHE_UPCALL_MAXPATH) { + sscanf(buffer, "%1024s", cache->uc_upcall); + cache->uc_upcall[UC_CACHE_UPCALL_MAXPATH - 1] = 0; } return count; } -static int lprocfs_wr_hash_flush(struct file *file, const char *buffer, - unsigned long count, void *data) + +extern void lgss_svc_cache_flush(__u32 uid); +static int lprocfs_wr_lsd_flush(struct file *file, const char *buffer, + unsigned long count, void *data) { - mds_group_hash_flush_idle(); + char buf[32]; + __u32 uid; + + if (copy_from_user(buf, buffer, min(count, 32UL))) + return count; + buf[31] = 0; + sscanf(buf, "%d", &uid); + + mds_flush_lsd(uid); +#ifdef ENABLE_GSS + lgss_svc_cache_flush(uid); +#endif return count; } -static int lprocfs_rd_allow_setgroups(char *page, char **start, off_t off, - int count, int *eof, void *data) + +/* + * remote acl proc handling + */ +static int lprocfs_rd_lacl_upcall(char *page, char **start, off_t off, + int count, int *eof, void *data) { - struct mds_grp_hash *hash = __mds_get_global_group_hash(); + struct upcall_cache *cache = __mds_get_global_rmtacl_upcall_cache(); *eof = 1; - return snprintf(page, count, "%d\n", hash->gh_allow_setgroups); + return snprintf(page, count, "%s\n", cache->uc_upcall); } -static int lprocfs_wr_allow_setgroups(struct file *file, const char *buffer, - unsigned long count, void *data) + +static int lprocfs_wr_lacl_upcall(struct file *file, const char *buffer, + unsigned long count, void *data) { - struct mds_grp_hash *hash = __mds_get_global_group_hash(); - char buf[8]; - int val; + struct upcall_cache *cache = __mds_get_global_rmtacl_upcall_cache(); - if (copy_from_user(buf, buffer, min(count, 8UL))) - return count; - buf[7] = 0; - sscanf(buf, "%d", &val); - hash->gh_allow_setgroups = (val != 0); + if (count < UC_CACHE_UPCALL_MAXPATH) { + sscanf(buffer, "%1024s", cache->uc_upcall); + cache->uc_upcall[UC_CACHE_UPCALL_MAXPATH - 1] = 0; + } return count; } +static int lprocfs_wr_lacl_downcall(struct file *file, const char *buffer, + unsigned long count, void *data) +{ + struct upcall_cache *cache = __mds_get_global_rmtacl_upcall_cache(); + struct rmtacl_downcall_args param; + + if (count != sizeof(param)) { + CERROR("invalid data size %lu\n", count); + goto do_err_downcall; + } + if (copy_from_user(¶m, buffer, count)) { + CERROR("broken downcall\n"); + goto do_err_downcall; + } + +do_downcall: + upcall_cache_downcall(cache, param.key, ¶m); + return count; + +do_err_downcall: + memset(¶m, 0, sizeof(param)); + param.status = -EINVAL; + goto do_downcall; +} + struct lprocfs_vars lprocfs_mds_module_vars[] = { - { "num_refs", lprocfs_rd_numrefs, 0, 0 }, - { "grp_hash_expire_interval", lprocfs_rd_expire, lprocfs_wr_expire, 0}, - { "grp_hash_acquire_expire", lprocfs_rd_ac_expire, - lprocfs_wr_ac_expire, 0}, - { "grp_hash_upcall", lprocfs_rd_hash_upcall, lprocfs_wr_hash_upcall, 0}, - { "grp_hash_flush", 0, lprocfs_wr_hash_flush, 0}, - { "group_info", 0, lprocfs_wr_group_info, 0 }, - { "allow_setgroups", lprocfs_rd_allow_setgroups, - lprocfs_wr_allow_setgroups, 0}, + { "num_refs", lprocfs_rd_numrefs, 0, 0 }, + /* LSD stuff */ + { "lsd_expire_interval", lprocfs_rd_lsd_expire, + lprocfs_wr_lsd_expire, 0}, + { "lsd_acquire_expire", lprocfs_rd_lsd_ac_expire, + lprocfs_wr_lsd_ac_expire, 0}, + { "lsd_upcall", lprocfs_rd_lsd_upcall, + lprocfs_wr_lsd_upcall, 0}, + { "lsd_flush", 0, lprocfs_wr_lsd_flush, 0}, + { "lsd_downcall", 0, lprocfs_wr_lsd_downcall, 0}, + /* remote acl */ + { "lacl_upcall", lprocfs_rd_lacl_upcall, + lprocfs_wr_lacl_upcall, 0}, + { "lacl_downcall", 0, lprocfs_wr_lacl_downcall, 0}, { 0 } }; @@ -372,7 +370,6 @@ struct lprocfs_vars lprocfs_mdt_module_vars[] = { { "num_refs", lprocfs_rd_numrefs, 0, 0 }, { 0 } }; - #endif /* LPROCFS */ struct lprocfs_static_vars lprocfs_array_vars[] = { {lprocfs_mds_module_vars,