X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Fmdd%2Fmdd_lproc.c;h=5b8f488bc1a18c2a50a9fac88f3ae85f371d797a;hb=e3a7c58aebafce40323db54bf6056029e5af4a70;hp=d675478c55e87aaafe827e1fa6f2a08e159d5bea;hpb=0e660eab787c3b2857e4295f1ec554e016393885;p=fs%2Flustre-release.git diff --git a/lustre/mdd/mdd_lproc.c b/lustre/mdd/mdd_lproc.c index d675478..5b8f488 100644 --- a/lustre/mdd/mdd_lproc.c +++ b/lustre/mdd/mdd_lproc.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. @@ -26,7 +24,7 @@ * GPL HEADER END */ /* - * Copyright 2008 Sun Microsystems, Inc. All rights reserved + * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved. * Use is subject to license terms. */ /* @@ -46,6 +44,7 @@ #define DEBUG_SUBSYSTEM S_MDS #include +#include #include #include #include @@ -58,17 +57,9 @@ #include "mdd_internal.h" -#ifndef SEEK_CUR /* SLES10 needs this */ -#define SEEK_CUR 1 -#define SEEK_END 2 -#endif - static const char *mdd_counter_names[LPROC_MDD_NR] = { }; -/* from LPROC_SEQ_FOPS(mdd_changelog) below */ -extern struct file_operations mdd_changelog_fops; - int mdd_procfs_init(struct mdd_device *mdd, const char *name) { struct lprocfs_static_vars lvars; @@ -138,7 +129,7 @@ static int lprocfs_wr_atime_diff(struct file *file, const char *buffer, if (count > (sizeof(kernbuf) - 1)) return -EINVAL; - if (copy_from_user(kernbuf, buffer, count)) + if (cfs_copy_from_user(kernbuf, buffer, count)) return -EFAULT; kernbuf[count] = '\0'; @@ -160,20 +151,10 @@ static int lprocfs_rd_atime_diff(char *page, char **start, off_t off, return snprintf(page, count, "%lu\n", mdd->mdd_atime_diff); } -/* match enum changelog_rec_type */ -static const char *changelog_str[] = {"MARK","CREAT","MKDIR","HLINK","SLINK", - "MKNOD","UNLNK","RMDIR","RNMFM","RNMTO","OPEN","CLOSE","IOCTL", - "TRUNC","SATTR","XATTR"}; - -const char *changelog_bit2str(int bit) -{ - if (bit < CL_LAST) - return changelog_str[bit]; - return NULL; -} -static int lprocfs_rd_cl_mask(char *page, char **start, off_t off, - int count, int *eof, void *data) +/**** changelogs ****/ +static int lprocfs_rd_changelog_mask(char *page, char **start, off_t off, + int count, int *eof, void *data) { struct mdd_device *mdd = data; int i = 0, rc = 0; @@ -182,14 +163,14 @@ static int lprocfs_rd_cl_mask(char *page, char **start, off_t off, while (i < CL_LAST) { if (mdd->mdd_cl.mc_mask & (1 << i)) rc += snprintf(page + rc, count - rc, "%s ", - changelog_str[i]); + changelog_type2str(i)); i++; } return rc; } -static int lprocfs_wr_cl_mask(struct file *file, const char *buffer, - unsigned long count, void *data) +static int lprocfs_wr_changelog_mask(struct file *file, const char *buffer, + unsigned long count, void *data) { struct mdd_device *mdd = data; char *kernbuf; @@ -201,12 +182,12 @@ static int lprocfs_wr_cl_mask(struct file *file, const char *buffer, OBD_ALLOC(kernbuf, CFS_PAGE_SIZE); if (kernbuf == NULL) RETURN(-ENOMEM); - if (copy_from_user(kernbuf, buffer, count)) + if (cfs_copy_from_user(kernbuf, buffer, count)) GOTO(out, rc = -EFAULT); kernbuf[count] = 0; - rc = libcfs_str2mask(kernbuf, changelog_bit2str, - &mdd->mdd_cl.mc_mask, CL_MINMASK, CL_ALLMASK); + rc = cfs_str2mask(kernbuf, changelog_type2str, &mdd->mdd_cl.mc_mask, + CHANGELOG_MINMASK, CHANGELOG_ALLMASK); if (rc == 0) rc = count; out: @@ -214,402 +195,67 @@ out: return rc; } -/** struct for holding changelog data for seq_file processing */ -struct cl_seq_iter { - struct mdd_device *csi_mdd; - __u64 csi_startrec; - __u64 csi_endrec; - loff_t csi_pos; - int csi_wrote; - int csi_startcat; - int csi_startidx; - int csi_fill:1; +struct cucb_data { + char *page; + int count; + int idx; }; -/* non-seq version for direct calling by class_process_proc_param */ -static int lprocfs_wr_cl(struct file *file, const char *buffer, - unsigned long count, void *data) -{ - struct mdd_device *mdd = (struct mdd_device *)data; - char kernbuf[32]; - char *end; - int rc; - - if (count > (sizeof(kernbuf) - 1)) - goto out_usage; - - count = min_t(unsigned long, count, sizeof(kernbuf)); - if (copy_from_user(kernbuf, buffer, count)) - return -EFAULT; - - kernbuf[count] = '\0'; - /* strip trailing newline from "echo blah" */ - if (kernbuf[count - 1] == '\n') - kernbuf[count - 1] = '\0'; - - if (strcmp(kernbuf, "on") == 0) { - LCONSOLE_INFO("changelog on\n"); - if (mdd->mdd_cl.mc_flags & CLM_ERR) { - CERROR("Changelogs cannot be enabled due to error " - "condition.\n"); - } else { - spin_lock(&mdd->mdd_cl.mc_lock); - mdd->mdd_cl.mc_flags |= CLM_ON; - spin_unlock(&mdd->mdd_cl.mc_lock); - rc = mdd_changelog_write_header(mdd, CLM_START); - if (rc) - return rc; - } - } else if (strcmp(kernbuf, "off") == 0) { - LCONSOLE_INFO("changelog off\n"); - rc = mdd_changelog_write_header(mdd, CLM_FINI); - if (rc) - return rc; - spin_lock(&mdd->mdd_cl.mc_lock); - mdd->mdd_cl.mc_flags &= ~CLM_ON; - spin_unlock(&mdd->mdd_cl.mc_lock); - } else { - /* purge to an index */ - long long unsigned endrec, cur; - - spin_lock(&mdd->mdd_cl.mc_lock); - cur = (long long)mdd->mdd_cl.mc_index; - spin_unlock(&mdd->mdd_cl.mc_lock); - - if (strcmp(kernbuf, "0") == 0) - /* purge to "0" is shorthand for everything */ - endrec = cur; - else - endrec = (long long)simple_strtoull(kernbuf, &end, 0); - if ((kernbuf == end) || (endrec == 0)) - goto out_usage; - if (endrec > cur) - endrec = cur; - - /* If purging all records, write a header entry so we - don't have an empty catalog and - we're sure to have a valid starting index next time. In - case of crash, we just restart with old log so we're - allright. */ - if (endrec == cur) { - rc = mdd_changelog_write_header(mdd, CLM_PURGE); - if (rc) - return rc; - } - - LCONSOLE_INFO("changelog purge to %llu\n", endrec); - - rc = mdd_changelog_llog_cancel(mdd, endrec); - if (rc < 0) - return rc; - } - - return count; - -out_usage: - CWARN("changelog write usage: [on|off] | \n"); - return -EINVAL; -} - -static ssize_t mdd_cl_seq_write(struct file *file, const char *buffer, - size_t count, loff_t *off) -{ - struct seq_file *seq = file->private_data; - struct cl_seq_iter *csi = seq->private; - struct mdd_device *mdd = csi->csi_mdd; - - return lprocfs_wr_cl(file, buffer, count, mdd); -} - -#define D_CL 0 - -/* How many records per seq_show. Too small, we spawn llog_process threads - too often; too large, we run out of buffer space */ -#define CL_CHUNK_SIZE 100 - -static int changelog_show_cb(struct llog_handle *llh, struct llog_rec_hdr *hdr, - void *data) +static int lprocfs_changelog_users_cb(struct llog_handle *llh, + struct llog_rec_hdr *hdr, void *data) { - struct seq_file *seq = (struct seq_file *)data; - struct cl_seq_iter *csi = seq->private; - struct llog_changelog_rec *rec = (struct llog_changelog_rec *)hdr; - int rc; - ENTRY; - - if ((rec->cr_hdr.lrh_type != CHANGELOG_REC) || - (rec->cr_type >= CL_LAST)) { - CERROR("Not a changelog rec? %d/%d\n", rec->cr_hdr.lrh_type, - rec->cr_type); - RETURN(-EINVAL); - } + struct llog_changelog_user_rec *rec; + struct cucb_data *cucb = (struct cucb_data *)data; - CDEBUG(D_CL, "rec="LPU64" start="LPU64" cat=%d:%d start=%d:%d\n", - rec->cr_index, csi->csi_startrec, - llh->lgh_hdr->llh_cat_idx, llh->lgh_cur_idx, - csi->csi_startcat, csi->csi_startidx); - - if (rec->cr_index < csi->csi_startrec) - RETURN(0); - if (rec->cr_index == csi->csi_startrec) { - /* Remember where we started, since seq_read will re-read - * the data when it reallocs space. Sigh, if only there was - * a way to tell seq_file how big the buf should be in the - * first place... */ - csi->csi_startcat = llh->lgh_hdr->llh_cat_idx; - csi->csi_startidx = rec->cr_hdr.lrh_index - 1; - } - if (csi->csi_wrote > CL_CHUNK_SIZE) { - /* Stop at some point with a reasonable seq_file buffer size. - * Start from here the next time. - */ - csi->csi_endrec = rec->cr_index - 1; - csi->csi_startcat = llh->lgh_hdr->llh_cat_idx; - csi->csi_startidx = rec->cr_hdr.lrh_index - 1; - csi->csi_wrote = 0; - RETURN(LLOG_PROC_BREAK); - } + LASSERT(llh->lgh_hdr->llh_flags & LLOG_F_IS_PLAIN); - rc = seq_printf(seq, LPU64" %02d%-5s "LPU64" 0x%x t="DFID, - rec->cr_index, rec->cr_type, - changelog_str[rec->cr_type], rec->cr_time, - rec->cr_flags & CLF_FLAGMASK, PFID(&rec->cr_tfid)); - - if (rec->cr_namelen) - /* namespace rec includes parent and filename */ - rc += seq_printf(seq, " p="DFID" %.*s\n", PFID(&rec->cr_pfid), - rec->cr_namelen, rec->cr_name); - else - rc += seq_puts(seq, "\n"); - - if (rc < 0) { - /* seq_read will dump the whole buffer and re-seq_start with a - larger one; no point in continuing the llog_process */ - CDEBUG(D_CL, "rec="LPU64" overflow "LPU64"<-"LPU64"\n", - rec->cr_index, csi->csi_startrec, csi->csi_endrec); - csi->csi_endrec = csi->csi_startrec - 1; - csi->csi_wrote = 0; - RETURN(LLOG_PROC_BREAK); - } + rec = (struct llog_changelog_user_rec *)hdr; - csi->csi_wrote++; - csi->csi_endrec = rec->cr_index; + cucb->idx += snprintf(cucb->page + cucb->idx, cucb->count - cucb->idx, + CHANGELOG_USER_PREFIX"%-3d "LPU64"\n", + rec->cur_id, rec->cur_endrec); + if (cucb->idx >= cucb->count) + return -ENOSPC; - RETURN(0); + return 0; } -static int mdd_cl_seq_show(struct seq_file *seq, void *v) +static int lprocfs_rd_changelog_users(char *page, char **start, off_t off, + int count, int *eof, void *data) { - struct cl_seq_iter *csi = seq->private; - struct obd_device *obd = mdd2obd_dev(csi->csi_mdd); + struct mdd_device *mdd = data; struct llog_ctxt *ctxt; - int rc; + struct cucb_data cucb; + __u64 cur; - if (csi->csi_fill) { - /* seq_read wants more data to fill his buffer. But we already - filled the buf as much as we cared to; force seq_read to - accept that. */ - while ((rc = seq_putc(seq, 0)) == 0); - return 0; - } + *eof = 1; - ctxt = llog_get_context(obd, LLOG_CHANGELOG_ORIG_CTXT); + ctxt = llog_get_context(mdd2obd_dev(mdd),LLOG_CHANGELOG_USER_ORIG_CTXT); if (ctxt == NULL) - return -ENOENT; - - /* Since we have to restart the llog_cat_process for each chunk of the - seq_ functions, start from where we left off. */ - rc = llog_cat_process(ctxt->loc_handle, changelog_show_cb, seq, - csi->csi_startcat, csi->csi_startidx); + return -ENXIO; + LASSERT(ctxt->loc_handle->lgh_hdr->llh_flags & LLOG_F_IS_CAT); - CDEBUG(D_CL, "seq_show "LPU64"-"LPU64" cat=%d:%d wrote=%d rc=%d\n", - csi->csi_startrec, csi->csi_endrec, csi->csi_startcat, - csi->csi_startidx, csi->csi_wrote, rc); + cfs_spin_lock(&mdd->mdd_cl.mc_lock); + cur = mdd->mdd_cl.mc_index; + cfs_spin_unlock(&mdd->mdd_cl.mc_lock); - llog_ctxt_put(ctxt); - - if (rc == LLOG_PROC_BREAK) - rc = 0; - - return rc; -} + cucb.count = count; + cucb.page = page; + cucb.idx = 0; -static int mdd_cl_done(struct cl_seq_iter *csi) -{ - int done = 0; - spin_lock(&csi->csi_mdd->mdd_cl.mc_lock); - done = (csi->csi_endrec >= csi->csi_mdd->mdd_cl.mc_index); - spin_unlock(&csi->csi_mdd->mdd_cl.mc_lock); - return done; -} + cucb.idx += snprintf(cucb.page + cucb.idx, cucb.count - cucb.idx, + "current index: "LPU64"\n", cur); + cucb.idx += snprintf(cucb.page + cucb.idx, cucb.count - cucb.idx, + "%-5s %s\n", "ID", "index"); -static void *mdd_cl_seq_start(struct seq_file *seq, loff_t *pos) -{ - struct cl_seq_iter *csi = seq->private; - LASSERT(csi); - - CDEBUG(D_CL, "start "LPU64"-"LPU64" pos="LPU64"\n", - csi->csi_startrec, csi->csi_endrec, *pos); - - csi->csi_fill = 0; - - if (mdd_cl_done(csi)) - /* no more records, seq_read should return 0 if buffer - is empty */ - return NULL; - - if (*pos > csi->csi_pos) { - /* The seq_read implementation sucks. It may call start - multiple times, using pos to indicate advances, if any, - by arbitrarily increasing it by 1. So ignore the actual - value of pos, and just register any increase as - "seq_read wants the next values". */ - csi->csi_startrec = csi->csi_endrec + 1; - csi->csi_pos = *pos; - } - /* else use old startrec/startidx */ - - return csi; -} - -static void mdd_cl_seq_stop(struct seq_file *seq, void *v) -{ - struct cl_seq_iter *csi = seq->private; - - CDEBUG(D_CL, "stop "LPU64"-"LPU64"\n", - csi->csi_startrec, csi->csi_endrec); -} + llog_cat_process(ctxt->loc_handle, lprocfs_changelog_users_cb, + &cucb, 0, 0); -static void *mdd_cl_seq_next(struct seq_file *seq, void *v, loff_t *pos) -{ - struct cl_seq_iter *csi = seq->private; - - CDEBUG(D_CL, "next "LPU64"-"LPU64" pos="LPU64"\n", - csi->csi_startrec, csi->csi_endrec, *pos); - - csi->csi_fill = 1; - - return csi; -} - -struct seq_operations mdd_cl_sops = { - .start = mdd_cl_seq_start, - .stop = mdd_cl_seq_stop, - .next = mdd_cl_seq_next, - .show = mdd_cl_seq_show, -}; - -static int mdd_cl_seq_open(struct inode *inode, struct file *file) -{ - struct cl_seq_iter *csi; - struct proc_dir_entry *dp = PDE(inode); - struct seq_file *seq; - int rc; - - LPROCFS_ENTRY_AND_CHECK(dp); - - rc = seq_open(file, &mdd_cl_sops); - if (rc) - goto out; - - OBD_ALLOC_PTR(csi); - if (csi == NULL) { - rc = -ENOMEM; - goto out; - } - csi->csi_mdd = dp->data; - seq = file->private_data; - seq->private = csi; - -out: - if (rc) - LPROCFS_EXIT(); - return rc; -} - -static int mdd_cl_seq_release(struct inode *inode, struct file *file) -{ - struct seq_file *seq = file->private_data; - struct cl_seq_iter *csi = seq->private; - - OBD_FREE_PTR(csi); - - return lprocfs_seq_release(inode, file); -} - -static loff_t mdd_cl_seq_lseek(struct file *file, loff_t offset, int origin) -{ - struct seq_file *seq = (struct seq_file *)file->private_data; - struct cl_seq_iter *csi = seq->private; - - CDEBUG(D_CL, "seek "LPU64"-"LPU64" off="LPU64":%d fpos="LPU64"\n", - csi->csi_startrec, csi->csi_endrec, offset, origin, file->f_pos); - - LL_SEQ_LOCK(seq); - - switch (origin) { - case SEEK_CUR: - offset += csi->csi_endrec; - break; - case SEEK_END: - spin_lock(&csi->csi_mdd->mdd_cl.mc_lock); - offset += csi->csi_mdd->mdd_cl.mc_index; - spin_unlock(&csi->csi_mdd->mdd_cl.mc_lock); - break; - } - - /* SEEK_SET */ - - if (offset < 0) { - LL_SEQ_UNLOCK(seq); - return -EINVAL; - } - - csi->csi_startrec = offset; - csi->csi_endrec = offset ? offset - 1 : 0; - - /* drop whatever is left in sucky seq_read's buffer */ - seq->count = 0; - seq->from = 0; - seq->index++; - LL_SEQ_UNLOCK(seq); - file->f_pos = csi->csi_startrec; - return csi->csi_startrec; -} - -static ssize_t mdd_cl_seq_read(struct file *file, char __user *buf, - size_t count, loff_t *ppos) -{ - struct seq_file *seq = (struct seq_file *)file->private_data; - struct cl_seq_iter *csi = seq->private; - - if ((file->f_flags & O_NONBLOCK) && mdd_cl_done(csi)) - return -EAGAIN; - return seq_read(file, buf, count, ppos); -} - -static unsigned int mdd_cl_seq_poll(struct file *file, poll_table *wait) -{ /* based on kmsg_poll */ - struct seq_file *seq = (struct seq_file *)file->private_data; - struct cl_seq_iter *csi = seq->private; - - poll_wait(file, &csi->csi_mdd->mdd_cl.mc_waitq, wait); - if (!mdd_cl_done(csi)) - return POLLIN | POLLRDNORM; - - return 0; + llog_ctxt_put(ctxt); + return cucb.idx; } -struct file_operations mdd_changelog_fops = { - .owner = THIS_MODULE, - .open = mdd_cl_seq_open, - .read = mdd_cl_seq_read, - .write = mdd_cl_seq_write, - .llseek = mdd_cl_seq_lseek, - .poll = mdd_cl_seq_poll, - .release = mdd_cl_seq_release, -}; - #ifdef HAVE_QUOTA_SUPPORT static int mdd_lprocfs_quota_rd_type(char *page, char **start, off_t off, int count, int *eof, void *data) @@ -627,14 +273,40 @@ static int mdd_lprocfs_quota_wr_type(struct file *file, const char *buffer, } #endif +static int lprocfs_rd_sync_perm(char *page, char **start, off_t off, + int count, int *eof, void *data) +{ + struct mdd_device *mdd = data; + + LASSERT(mdd != NULL); + return snprintf(page, count, "%d\n", mdd->mdd_sync_permission); +} + +static int lprocfs_wr_sync_perm(struct file *file, const char *buffer, + unsigned long count, void *data) +{ + struct mdd_device *mdd = data; + int val, rc; + + LASSERT(mdd != NULL); + rc = lprocfs_write_helper(buffer, count, &val); + if (rc) + return rc; + + mdd->mdd_sync_permission = !!val; + return count; +} + static struct lprocfs_vars lprocfs_mdd_obd_vars[] = { - { "atime_diff", lprocfs_rd_atime_diff, lprocfs_wr_atime_diff, 0 }, - { "changelog_mask", lprocfs_rd_cl_mask, lprocfs_wr_cl_mask, 0 }, - { "changelog", 0, lprocfs_wr_cl, 0, &mdd_changelog_fops, 0600 }, + { "atime_diff", lprocfs_rd_atime_diff, lprocfs_wr_atime_diff, 0 }, + { "changelog_mask", lprocfs_rd_changelog_mask, + lprocfs_wr_changelog_mask, 0 }, + { "changelog_users", lprocfs_rd_changelog_users, 0, 0}, #ifdef HAVE_QUOTA_SUPPORT { "quota_type", mdd_lprocfs_quota_rd_type, mdd_lprocfs_quota_wr_type, 0 }, #endif + { "sync_permission", lprocfs_rd_sync_perm, lprocfs_wr_sync_perm, 0 }, { 0 } };