X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lustre%2Finclude%2Flprocfs_status.h;h=5c7ddb2998858ee7f71a49e2986cda352c9d26df;hp=8656a0851ab17f45e3c18f9cbb9b858e9f6c70f0;hb=8a84c7f9c7d65f6f880be6fe4d94fca26a405d81;hpb=b27575d1b91d93c0f3f7f4e4a9744db37686a504;ds=sidebyside diff --git a/lustre/include/lprocfs_status.h b/lustre/include/lprocfs_status.h index 8656a08..5c7ddb2 100644 --- a/lustre/include/lprocfs_status.h +++ b/lustre/include/lprocfs_status.h @@ -23,11 +23,10 @@ * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved. * Use is subject to license terms. * - * Copyright (c) 2011, 2016, Intel Corporation. + * Copyright (c) 2011, 2017, Intel Corporation. */ /* * This file is part of Lustre, http://www.lustre.org/ - * Lustre is a trademark of Sun Microsystems, Inc. * * lustre/include/lprocfs_status.h * @@ -43,21 +42,59 @@ #include #include #include +#include #include #include +#include #include +/* + * Liuux 5.6 introduces proc_ops with v5.5-8862-gd56c0d45f0e2 + * Now that proc and debugfs use separate operation vector types + * separate containers are also needed. + */ struct lprocfs_vars { const char *name; + const struct proc_ops *fops; + void *data; + /** /proc file mode. */ + mode_t proc_mode; +}; + +/** Provide a debugfs container */ +struct ldebugfs_vars { + const char *name; const struct file_operations *fops; void *data; - /** - * /proc file mode. - */ + /** debugfs file mode. */ mode_t proc_mode; }; +static inline unsigned int pct(unsigned long a, unsigned long b) +{ + return b ? a * 100 / b : 0; +} + +#define PAGES_TO_MiB(pages) ((pages) >> (20 - PAGE_SHIFT)) +#define MiB_TO_PAGES(mb) ((mb) << (20 - PAGE_SHIFT)) + +/** + * Append a space separated list of current set flags to str. + */ +#define flag2str(port, flag) \ + do { \ + if ((port)->port##_##flag) { \ + seq_printf(m, "%s" #flag, first ? "" : ", "); \ + first = false; \ + } \ + } while (0) + +void obd_connect_seq_flags2str(struct seq_file *m, __u64 flags, __u64 flags2, + const char *sep); +void obd_connect_data_seqprint(struct seq_file *m, + struct obd_connect_data *ocd); + /* if we find more consumers this could be generalized */ #define OBD_HIST_MAX 32 struct obd_histogram { @@ -66,28 +103,6 @@ struct obd_histogram { }; enum { - BRW_R_PAGES = 0, - BRW_W_PAGES, - BRW_R_RPC_HIST, - BRW_W_RPC_HIST, - BRW_R_IO_TIME, - BRW_W_IO_TIME, - BRW_R_DISCONT_PAGES, - BRW_W_DISCONT_PAGES, - BRW_R_DISCONT_BLOCKS, - BRW_W_DISCONT_BLOCKS, - BRW_R_DISK_IOSIZE, - BRW_W_DISK_IOSIZE, - BRW_R_DIO_FRAGS, - BRW_W_DIO_FRAGS, - BRW_LAST, -}; - -struct brw_stats { - struct obd_histogram hist[BRW_LAST]; -}; - -enum { RENAME_SAMEDIR_SIZE = 0, RENAME_CROSSDIR_SRC_SIZE, RENAME_CROSSDIR_TGT_SIZE, @@ -95,7 +110,8 @@ enum { }; struct rename_stats { - struct obd_histogram hist[RENAME_LAST]; + ktime_t rs_init; + struct obd_histogram rs_hist[RENAME_LAST]; }; /* An lprocfs counter can be configured using the enum bit masks below. @@ -120,17 +136,23 @@ struct rename_stats { */ enum { - LPROCFS_CNTR_EXTERNALLOCK = 0x0001, - LPROCFS_CNTR_AVGMINMAX = 0x0002, - LPROCFS_CNTR_STDDEV = 0x0004, - - /* counter data type */ - LPROCFS_TYPE_REGS = 0x0100, - LPROCFS_TYPE_BYTES = 0x0200, - LPROCFS_TYPE_PAGES = 0x0400, - LPROCFS_TYPE_CYCLE = 0x0800, + LPROCFS_CNTR_EXTERNALLOCK = 0x0001, + LPROCFS_CNTR_AVGMINMAX = 0x0002, + LPROCFS_CNTR_STDDEV = 0x0004, + + /* counter data type */ + LPROCFS_TYPE_REQS = 0x0100, + LPROCFS_TYPE_BYTES = 0x0200, + LPROCFS_TYPE_PAGES = 0x0400, + LPROCFS_TYPE_USEC = 0x0800, + + LPROCFS_TYPE_LATENCY = LPROCFS_TYPE_USEC | + LPROCFS_CNTR_AVGMINMAX | + LPROCFS_CNTR_STDDEV, + LPROCFS_TYPE_BYTES_FULL = LPROCFS_TYPE_BYTES | + LPROCFS_CNTR_AVGMINMAX | + LPROCFS_CNTR_STDDEV, }; - #define LC_MIN_INIT ((~(__u64)0) >> 1) struct lprocfs_counter_header { @@ -187,6 +209,7 @@ struct lprocfs_stats { /* 1 + the biggest cpu # whose ls_percpu slot has been allocated */ unsigned short ls_biggest_alloc_num; enum lprocfs_stats_flags ls_flags; + ktime_t ls_init; /* Lock used when there are no percpu stats areas; For percpu stats, * it is used to protect ls_biggest_alloc_num change */ spinlock_t ls_lock; @@ -275,6 +298,7 @@ static inline int opcode_offset(__u32 opc) { OPC_RANGE(LDLM) + OPC_RANGE(MDS) + OPC_RANGE(OST)); +#ifdef HAVE_SERVER_SUPPORT } else if (opc < OUT_UPDATE_LAST_OPC) { /* update opcode */ return (opc - OUT_UPDATE_FIRST_OPC + @@ -302,25 +326,31 @@ static inline int opcode_offset(__u32 opc) { OPC_RANGE(LDLM) + OPC_RANGE(MDS) + OPC_RANGE(OST)); +#endif /* HAVE_SERVER_SUPPORT */ } else { /* Unknown Opcode */ return -1; } } +#define LUSTRE_MAX_OPCODES_CLIENT (OPC_RANGE(OST) + \ + OPC_RANGE(MDS) + \ + OPC_RANGE(LDLM) + \ + OPC_RANGE(MGS) + \ + OPC_RANGE(OBD) + \ + OPC_RANGE(LLOG) + \ + OPC_RANGE(SEC) + \ + OPC_RANGE(SEQ) + \ + OPC_RANGE(SEC) + \ + OPC_RANGE(FLD)) -#define LUSTRE_MAX_OPCODES (OPC_RANGE(OST) + \ - OPC_RANGE(MDS) + \ - OPC_RANGE(LDLM) + \ - OPC_RANGE(MGS) + \ - OPC_RANGE(OBD) + \ - OPC_RANGE(LLOG) + \ - OPC_RANGE(SEC) + \ - OPC_RANGE(SEQ) + \ - OPC_RANGE(SEC) + \ - OPC_RANGE(FLD) + \ +#ifdef HAVE_SERVER_SUPPORT +#define LUSTRE_MAX_OPCODES (LUSTRE_MAX_OPCODES_CLIENT + \ OPC_RANGE(OUT_UPDATE) + \ OPC_RANGE(LFSCK)) +#else +#define LUSTRE_MAX_OPCODES LUSTRE_MAX_OPCODES_CLIENT +#endif #define EXTRA_MAX_OPCODES ((PTLRPC_LAST_CNTR - PTLRPC_FIRST_CNTR) + \ OPC_RANGE(EXTRA)) @@ -337,23 +367,60 @@ enum { #define PTLRPC_FIRST_CNTR PTLRPC_REQWAIT_CNTR enum lprocfs_extra_opc { - LDLM_GLIMPSE_ENQUEUE = 0, - LDLM_PLAIN_ENQUEUE, - LDLM_EXTENT_ENQUEUE, - LDLM_FLOCK_ENQUEUE, - LDLM_IBITS_ENQUEUE, - MDS_REINT_SETATTR, - MDS_REINT_CREATE, - MDS_REINT_LINK, - MDS_REINT_UNLINK, - MDS_REINT_RENAME, - MDS_REINT_OPEN, - MDS_REINT_SETXATTR, - BRW_READ_BYTES, - BRW_WRITE_BYTES, - EXTRA_LAST_OPC + LDLM_GLIMPSE_ENQUEUE = 0, + LDLM_PLAIN_ENQUEUE, + LDLM_EXTENT_ENQUEUE, + LDLM_FLOCK_ENQUEUE, + LDLM_IBITS_ENQUEUE, + MDS_REINT_SETATTR, + MDS_REINT_CREATE, + MDS_REINT_LINK, + MDS_REINT_UNLINK, + MDS_REINT_RENAME, + MDS_REINT_OPEN, + MDS_REINT_SETXATTR, + MDS_REINT_RESYNC, + BRW_READ_BYTES, + BRW_WRITE_BYTES, + EXTRA_LAST_OPC +}; + +#ifdef HAVE_SERVER_SUPPORT +enum brw_rw_stats { + BRW_R_PAGES = 0, + BRW_W_PAGES, + BRW_R_DISCONT_PAGES, + BRW_W_DISCONT_PAGES, + BRW_R_DISCONT_BLOCKS, + BRW_W_DISCONT_BLOCKS, + BRW_R_DIO_FRAGS, + BRW_W_DIO_FRAGS, + BRW_R_RPC_HIST, + BRW_W_RPC_HIST, + BRW_R_IO_TIME, + BRW_W_IO_TIME, + BRW_R_DISK_IOSIZE, + BRW_W_DISK_IOSIZE, + BRW_RW_STATS_NUM, +}; + +struct brw_stats_props { + const char *bsp_name; + const char *bsp_units; + bool bsp_scale; +}; + +struct brw_stats { + ktime_t bs_init; + struct obd_histogram bs_hist[BRW_RW_STATS_NUM]; + struct brw_stats_props bs_props[BRW_RW_STATS_NUM / 2]; }; +void ldebugfs_register_osd_stats(struct dentry *parent, + struct brw_stats *brw_stats, + struct lprocfs_stats *stats); +#endif /* HAVE_SERVER_SUPPORT */ + #define EXTRA_FIRST_OPC LDLM_GLIMPSE_ENQUEUE /* class_obd.c */ extern struct proc_dir_entry *proc_lustre_root; @@ -361,21 +428,22 @@ extern struct dentry *debugfs_lustre_root; extern struct kset *lustre_kset; struct obd_device; -struct obd_histogram; #define JOBSTATS_JOBID_VAR_MAX_LEN 20 #define JOBSTATS_DISABLE "disable" #define JOBSTATS_PROCNAME_UID "procname_uid" #define JOBSTATS_NODELOCAL "nodelocal" +#define JOBSTATS_SESSION "session" -typedef void (*cntr_init_callback)(struct lprocfs_stats *stats); +typedef void (*cntr_init_callback)(struct lprocfs_stats *stats, + unsigned int offset); struct obd_job_stats { struct cfs_hash *ojs_hash; /* hash of jobids */ struct list_head ojs_list; /* list of job_stat structs */ rwlock_t ojs_lock; /* protect ojs_list/js_list */ - unsigned int ojs_cleanup_interval;/* seconds before expiry */ - time64_t ojs_last_cleanup; /* previous cleanup time */ + ktime_t ojs_cleanup_interval;/* 1/2 expiry seconds */ + ktime_t ojs_cleanup_last;/* previous cleanup time */ cntr_init_callback ojs_cntr_init_fn;/* lprocfs_stats initializer */ unsigned short ojs_cntr_num; /* number of stats in struct */ bool ojs_cleaning; /* currently expiring stats */ @@ -451,34 +519,32 @@ extern struct lprocfs_stats * lprocfs_alloc_stats(unsigned int num, enum lprocfs_stats_flags flags); extern void lprocfs_clear_stats(struct lprocfs_stats *stats); extern void lprocfs_free_stats(struct lprocfs_stats **stats); -extern void lprocfs_init_ops_stats(int num_private_stats, - struct lprocfs_stats *stats); -extern void lprocfs_init_mps_stats(int num_private_stats, - struct lprocfs_stats *stats); extern void lprocfs_init_ldlm_stats(struct lprocfs_stats *ldlm_stats); -extern int lprocfs_alloc_obd_stats(struct obd_device *obddev, - unsigned int num_private_stats); -extern int lprocfs_alloc_md_stats(struct obd_device *obddev, - unsigned int num_private_stats); +extern int lprocfs_alloc_obd_stats(struct obd_device *obd, + unsigned int num_stats); +extern int lprocfs_alloc_md_stats(struct obd_device *obd, + unsigned int num_private_stats); extern void lprocfs_counter_init(struct lprocfs_stats *stats, int index, - unsigned conf, const char *name, - const char *units); -extern void lprocfs_free_obd_stats(struct obd_device *obddev); -extern void lprocfs_free_md_stats(struct obd_device *obddev); + unsigned conf, const char *name, + const char *units); +extern void lprocfs_free_obd_stats(struct obd_device *obd); +extern void lprocfs_free_md_stats(struct obd_device *obd); struct obd_export; struct nid_stat; -extern int lprocfs_add_clear_entry(struct obd_device * obd, +extern int lprocfs_add_clear_entry(struct obd_device *obd, struct proc_dir_entry *entry); #ifdef HAVE_SERVER_SUPPORT extern int lprocfs_exp_setup(struct obd_export *exp, lnet_nid_t *peer_nid); extern int lprocfs_exp_cleanup(struct obd_export *exp); +struct dentry *ldebugfs_add_symlink(const char *name, const char *target, + const char *format, ...); #else static inline int lprocfs_exp_cleanup(struct obd_export *exp) { return 0; } #endif extern struct proc_dir_entry * lprocfs_add_simple(struct proc_dir_entry *root, char *name, - void *data, const struct file_operations *fops); + void *data, const struct proc_ops *ops); extern struct proc_dir_entry * lprocfs_add_symlink(const char *name, struct proc_dir_entry *parent, const char *format, ...); @@ -489,92 +555,50 @@ lprocfs_nid_stats_clear_seq_write(struct file *file, const char __user *buffer, size_t count, loff_t *off); extern int lprocfs_nid_stats_clear_seq_show(struct seq_file *file, void *data); #endif -extern int ldebugfs_register_stats(struct dentry *parent, const char *name, - struct lprocfs_stats *stats); extern int lprocfs_register_stats(struct proc_dir_entry *root, const char *name, - struct lprocfs_stats *stats); + struct lprocfs_stats *stats); +extern const struct file_operations ldebugfs_stats_seq_fops; /* lprocfs_status.c */ -extern int ldebugfs_add_vars(struct dentry *parent, struct lprocfs_vars *var, - void *data); -extern int lprocfs_add_vars(struct proc_dir_entry *root, - struct lprocfs_vars *var, void *data); - +extern void ldebugfs_add_vars(struct dentry *parent, struct ldebugfs_vars *var, + void *data); extern struct dentry *ldebugfs_register(const char *name, struct dentry *parent, - struct lprocfs_vars *list, + struct ldebugfs_vars *list, void *data); +extern int lprocfs_add_vars(struct proc_dir_entry *root, + struct lprocfs_vars *var, void *data); + extern struct proc_dir_entry * lprocfs_register(const char *name, struct proc_dir_entry *parent, struct lprocfs_vars *list, void *data); -extern void ldebugfs_remove(struct dentry **entryp); extern void lprocfs_remove(struct proc_dir_entry **root); extern void lprocfs_remove_proc_entry(const char *name, struct proc_dir_entry *parent); -#ifndef HAVE_REMOVE_PROC_SUBTREE -extern int remove_proc_subtree(const char *name, - struct proc_dir_entry *parent); -#define PDE_DATA(inode) (PDE(inode)->data) - -static inline int LPROCFS_ENTRY_CHECK(struct inode *inode) -{ - struct proc_dir_entry *dp = PDE(inode); - int deleted = 0; - - spin_lock(&(dp)->pde_unload_lock); - if (dp->proc_fops == NULL) - deleted = 1; - spin_unlock(&(dp)->pde_unload_lock); - if (deleted) - return -ENODEV; - return 0; -} -#else -static inline int LPROCFS_ENTRY_CHECK(struct inode *inode) -{ return 0; } -#endif - -extern int lprocfs_obd_setup(struct obd_device *dev, bool uuid_only); +extern int lprocfs_obd_setup(struct obd_device *obd, bool uuid_only); extern int lprocfs_obd_cleanup(struct obd_device *obd); -#ifdef HAVE_SERVER_SUPPORT -extern const struct file_operations lprocfs_evict_client_fops; -#endif -extern int ldebugfs_seq_create(struct dentry *parent, const char *name, - umode_t mode, - const struct file_operations *seq_fops, - void *data); extern int lprocfs_seq_create(struct proc_dir_entry *parent, const char *name, - mode_t mode, - const struct file_operations *seq_fops, + mode_t mode, const struct proc_ops *seq_fops, void *data); -extern int lprocfs_obd_seq_create(struct obd_device *dev, const char *name, - mode_t mode, - const struct file_operations *seq_fops, +extern int lprocfs_obd_seq_create(struct obd_device *obd, const char *name, + mode_t mode, const struct proc_ops *seq_fops, void *data); +extern void lprocfs_stats_header(struct seq_file *seq, ktime_t now, + ktime_t ts_init, int width, const char *colon, + bool show_units); /* Generic callbacks */ -extern int lprocfs_u64_seq_show(struct seq_file *m, void *data); -extern int lprocfs_atomic_seq_show(struct seq_file *m, void *data); -extern ssize_t lprocfs_atomic_seq_write(struct file *file, - const char __user *buffer, - size_t count, loff_t *off); -extern int lprocfs_uint_seq_show(struct seq_file *m, void *data); -extern ssize_t lprocfs_uint_seq_write(struct file *file, - const char __user *buffer, - size_t count, loff_t *off); -extern int lprocfs_wr_uint(struct file *file, const char __user *buffer, - unsigned long count, void *data); extern int lprocfs_uuid_seq_show(struct seq_file *m, void *data); -extern int lprocfs_name_seq_show(struct seq_file *m, void *data); extern int lprocfs_server_uuid_seq_show(struct seq_file *m, void *data); -extern int lprocfs_conn_uuid_seq_show(struct seq_file *m, void *data); +ssize_t conn_uuid_show(struct kobject *kobj, struct attribute *attr, char *buf); extern int lprocfs_import_seq_show(struct seq_file *m, void *data); extern int lprocfs_state_seq_show(struct seq_file *m, void *data); extern int lprocfs_connect_flags_seq_show(struct seq_file *m, void *data); #ifdef HAVE_SERVER_SUPPORT -extern int lprocfs_num_exports_seq_show(struct seq_file *m, void *data); +ssize_t num_exports_show(struct kobject *kobj, struct attribute *attr, + char *buf); #endif struct adaptive_timeout; extern int lprocfs_at_hist_helper(struct seq_file *m, @@ -588,25 +612,30 @@ extern ssize_t lprocfs_evict_client_seq_write(struct file *file, const char __user *buffer, size_t count, loff_t *off); #endif +ssize_t ping_store(struct kobject *kobj, struct attribute *attr, + const char *buffer, size_t count); +ssize_t ping_show(struct kobject *kobj, struct attribute *attr, + char *buffer); + extern ssize_t -lprocfs_ping_seq_write(struct file *file, const char __user *buffer, - size_t count, loff_t *off); -extern ssize_t +ldebugfs_import_seq_write(struct file *file, const char __user *buffer, + size_t count, loff_t *off); +static inline ssize_t lprocfs_import_seq_write(struct file *file, const char __user *buffer, - size_t count, loff_t *off); + size_t count, loff_t *off) +{ + return ldebugfs_import_seq_write(file, buffer, count, off); +} + extern int lprocfs_pinger_recov_seq_show(struct seq_file *m, void *data); extern ssize_t lprocfs_pinger_recov_seq_write(struct file *file, const char __user *buffer, size_t count, loff_t *off); -extern int lprocfs_seq_read_frac_helper(struct seq_file *m, long val, int mult); -extern int lprocfs_read_frac_helper(char *buffer, unsigned long count, - long val, int mult); -extern int lprocfs_str_to_s64(const char __user *buffer, unsigned long count, - __s64 *val); -extern int lprocfs_str_with_units_to_s64(const char __user *buffer, - unsigned long count, __s64 *val, - char defunit); +int string_to_size(u64 *size, const char *buffer, size_t count); +int sysfs_memparse(const char *buffer, size_t count, u64 *val, + const char *defunit); +char *lprocfs_strnstr(const char *s1, const char *s2, size_t len); char *lprocfs_find_named_value(const char *buffer, const char *name, size_t *count); void lprocfs_oh_tally(struct obd_histogram *oh, unsigned int value); @@ -625,10 +654,10 @@ int lprocfs_recovery_status_seq_show(struct seq_file *m, void *data); int lprocfs_hash_seq_show(struct seq_file *m, void *data); /* lprocfs_status.c: IR factor */ -int lprocfs_ir_factor_seq_show(struct seq_file *m, void *data); -ssize_t -lprocfs_ir_factor_seq_write(struct file *file, const char __user *buffer, - size_t count, loff_t *off); +ssize_t ir_factor_show(struct kobject *kobj, struct attribute *attr, + char *buf); +ssize_t ir_factor_store(struct kobject *kobj, struct attribute *attr, + const char *buffer, size_t count); #endif /* lprocfs_status.c: dump pages on cksum error */ @@ -641,34 +670,32 @@ extern int lprocfs_single_release(struct inode *, struct file *); extern int lprocfs_seq_release(struct inode *, struct file *); /* You must use these macros when you want to refer to - * the import in a client obd_device for a lprocfs entry */ -#define LPROCFS_CLIMP_CHECK(obd) do { \ - typecheck(struct obd_device *, obd); \ - down_read(&(obd)->u.cli.cl_sem); \ - if ((obd)->u.cli.cl_import == NULL) { \ - up_read(&(obd)->u.cli.cl_sem); \ - return -ENODEV; \ - } \ -} while(0) -#define LPROCFS_CLIMP_EXIT(obd) \ - up_read(&(obd)->u.cli.cl_sem); + * the import in a client obd_device for a lprocfs entry + * Note that it is not safe to 'goto', 'return' or 'break' + * out of the body of this statement. It *IS* safe to + * 'goto' the a label inside the statement, or to 'continue' + * to get out of the statement. + */ -/* write the name##_seq_show function, call LPROC_SEQ_FOPS_RO for read-only - proc entries; otherwise, you will define name##_seq_write function also for - a read-write proc entry, and then call LPROC_SEQ_SEQ instead. Finally, - call lprocfs_obd_seq_create(obd, filename, 0444, &name#_fops, data); */ -#define __LPROC_SEQ_FOPS(name, custom_seq_write) \ +#define with_imp_locked_nested(__obd, __imp, __rc, __nest) \ + for (down_read_nested(&(__obd)->u.cli.cl_sem, __nest), \ + __imp = (__obd)->u.cli.cl_import, \ + __rc = __imp ? 0 : -ENODEV; \ + __imp ? 1 : (up_read(&(__obd)->u.cli.cl_sem), 0); \ + __imp = NULL) + +#define with_imp_locked(__obd, __imp, __rc) \ + with_imp_locked_nested(__obd, __imp, __rc, 0) + +/* write the name##_seq_show function, call LDEBUGFS_SEQ_FOPS_RO for read-only + * debugfs entries; otherwise, you will define name##_seq_write function also + * for a read-write debugfs entry, and then call LDEBUGFS_SEQ_FOPS instead. + * Finally, call debugfs_create_file(filename, 0444, obd, data, &name#_fops); + */ +#define __LDEBUGFS_SEQ_FOPS(name, custom_seq_write) \ static int name##_single_open(struct inode *inode, struct file *file) \ { \ - int rc; \ - \ - rc = LPROCFS_ENTRY_CHECK(inode); \ - if (rc < 0) \ - return rc; \ - \ - return single_open(file, name##_seq_show, \ - inode->i_private ? inode->i_private : \ - PDE_DATA(inode)); \ + return single_open(file, name##_seq_show, inode->i_private); \ } \ static const struct file_operations name##_fops = { \ .owner = THIS_MODULE, \ @@ -676,7 +703,80 @@ static const struct file_operations name##_fops = { \ .read = seq_read, \ .write = custom_seq_write, \ .llseek = seq_lseek, \ - .release = lprocfs_single_release, \ + .release = single_release, \ +} + +#define LDEBUGFS_SEQ_FOPS_RO(name) __LDEBUGFS_SEQ_FOPS(name, NULL) +#define LDEBUGFS_SEQ_FOPS(name) __LDEBUGFS_SEQ_FOPS(name, \ + name##_seq_write) + +#define LDEBUGFS_SEQ_FOPS_RO_TYPE(name, type) \ + static int name##_##type##_seq_show(struct seq_file *m, void *v)\ + { \ + if (!m->private) \ + return -ENODEV; \ + return lprocfs_##type##_seq_show(m, m->private); \ + } \ + LDEBUGFS_SEQ_FOPS_RO(name##_##type) + +#define LDEBUGFS_SEQ_FOPS_RW_TYPE(name, type) \ + static int name##_##type##_seq_show(struct seq_file *m, void *v)\ + { \ + if (!m->private) \ + return -ENODEV; \ + return lprocfs_##type##_seq_show(m, m->private); \ + } \ + static ssize_t name##_##type##_seq_write(struct file *file, \ + const char __user *buffer, size_t count, \ + loff_t *off) \ + { \ + struct seq_file *seq = file->private_data; \ + \ + if (!seq->private) \ + return -ENODEV; \ + return ldebugfs_##type##_seq_write(file, buffer, count, \ + seq->private); \ + } \ + LDEBUGFS_SEQ_FOPS(name##_##type); + +#define LDEBUGFS_FOPS_WR_ONLY(name, type) \ + static ssize_t name##_##type##_write(struct file *file, \ + const char __user *buffer, size_t count, \ + loff_t *off) \ + { \ + return ldebugfs_##type##_seq_write(file, buffer, count, \ + off); \ + } \ + static int name##_##type##_open(struct inode *inode, \ + struct file *file) \ + { \ + return single_open(file, NULL, inode->i_private); \ + } \ + static const struct file_operations name##_##type##_fops = { \ + .open = name##_##type##_open, \ + .write = name##_##type##_write, \ + .release = single_release, \ + }; + +/* write the name##_seq_show function, call LPROC_SEQ_FOPS_RO for read-only + * proc entries; otherwise, you will define name##_seq_write function also for + * a read-write proc entry, and then call LPROC_SEQ_FOPS instead. Finally, + * call ldebugfs_obd_seq_create(obd, filename, 0444, &name#_fops, data); + */ +#define __LPROC_SEQ_FOPS(name, custom_seq_write) \ +static int name##_single_open(struct inode *inode, struct file *file) \ +{ \ + return single_open(file, name##_seq_show, \ + inode->i_private ? inode->i_private : \ + PDE_DATA(inode)); \ +} \ +static const struct proc_ops name##_fops = { \ + PROC_OWNER(THIS_MODULE) \ + .proc_open = name##_single_open, \ + .proc_read = seq_read, \ + .proc_write = custom_seq_write, \ + .proc_lseek = seq_lseek, \ + .proc_release = lprocfs_single_release, \ } #define LPROC_SEQ_FOPS_RO(name) __LPROC_SEQ_FOPS(name, NULL) @@ -717,10 +817,10 @@ static const struct file_operations name##_fops = { \ inode->i_private ? inode->i_private : \ PDE_DATA(inode)); \ } \ - static const struct file_operations name##_##type##_fops = { \ - .open = name##_##type##_open, \ - .write = name##_##type##_write, \ - .release = lprocfs_single_release, \ + static const struct proc_ops name##_##type##_fops = { \ + .proc_open = name##_##type##_open, \ + .proc_write = name##_##type##_write, \ + .proc_release = lprocfs_single_release, \ }; struct lustre_attr { @@ -756,26 +856,34 @@ int lprocfs_job_stats_log(struct obd_device *obd, char *jobid, void lprocfs_job_stats_fini(struct obd_device *obd); int lprocfs_job_stats_init(struct obd_device *obd, int cntr_num, cntr_init_callback fn); -int lprocfs_job_interval_seq_show(struct seq_file *m, void *data); -ssize_t -lprocfs_job_interval_seq_write(struct file *file, const char __user *buffer, - size_t count, loff_t *off); -/* lproc_status.c */ -int lprocfs_recovery_time_soft_seq_show(struct seq_file *m, void *data); -ssize_t lprocfs_recovery_time_soft_seq_write(struct file *file, - const char __user *buffer, - size_t count, loff_t *off); -int lprocfs_recovery_time_hard_seq_show(struct seq_file *m, void *data); -ssize_t -lprocfs_recovery_time_hard_seq_write(struct file *file, - const char __user *buffer, - size_t count, loff_t *off); -int lprocfs_target_instance_seq_show(struct seq_file *m, void *data); +ssize_t job_cleanup_interval_show(struct kobject *kobj, struct attribute *attr, + char *buf); +ssize_t job_cleanup_interval_store(struct kobject *kobj, + struct attribute *attr, + const char *buffer, size_t count); +/* lproc_status_server.c */ +ssize_t recovery_time_soft_show(struct kobject *kobj, struct attribute *attr, + char *buf); +ssize_t recovery_time_soft_store(struct kobject *kobj, + struct attribute *attr, + const char *buffer, size_t count); +ssize_t recovery_time_hard_show(struct kobject *kobj, struct attribute *attr, + char *buf); +ssize_t recovery_time_hard_store(struct kobject *kobj, + struct attribute *attr, + const char *buffer, size_t count); +ssize_t instance_show(struct kobject *kobj, struct attribute *attr, + char *buf); #endif +/* lproc_status.c */ int lprocfs_obd_max_pages_per_rpc_seq_show(struct seq_file *m, void *data); ssize_t lprocfs_obd_max_pages_per_rpc_seq_write(struct file *file, const char __user *buffer, size_t count, loff_t *off); +ssize_t short_io_bytes_show(struct kobject *kobj, struct attribute *attr, + char *buf); +ssize_t short_io_bytes_store(struct kobject *kobj, struct attribute *attr, + const char *buffer, size_t count); struct root_squash_info; int lprocfs_wr_root_squash(const char __user *buffer, unsigned long count, @@ -820,23 +928,17 @@ static inline int lprocfs_register_stats(struct proc_dir_entry *root, const char *name, struct lprocfs_stats *stats) { return 0; } -static inline void lprocfs_init_ops_stats(int num_private_stats, - struct lprocfs_stats *stats) -{ return; } -static inline void lprocfs_init_mps_stats(int num_private_stats, - struct lprocfs_stats *stats) -{ return; } static inline void lprocfs_init_ldlm_stats(struct lprocfs_stats *ldlm_stats) { return; } -static inline int lprocfs_alloc_obd_stats(struct obd_device *obddev, - unsigned int num_private_stats) +static inline int lprocfs_alloc_obd_stats(struct obd_device *obd, + unsigned int num_stats) { return 0; } -static inline int lprocfs_alloc_md_stats(struct obd_device *obddev, +static inline int lprocfs_alloc_md_stats(struct obd_device *obd, unsigned int num_private_stats) { return 0; } -static inline void lprocfs_free_obd_stats(struct obd_device *obddev) +static inline void lprocfs_free_obd_stats(struct obd_device *obd) { return; } -static inline void lprocfs_free_md_stats(struct obd_device *obddev) +static inline void lprocfs_free_md_stats(struct obd_device *obd) { return; } struct obd_export; @@ -878,18 +980,14 @@ static inline void lprocfs_remove(struct proc_dir_entry **root) static inline void lprocfs_remove_proc_entry(const char *name, struct proc_dir_entry *parent) { return; } -static inline int lprocfs_obd_setup(struct obd_device *dev, bool uuid_only) +static inline int lprocfs_obd_setup(struct obd_device *obd, bool uuid_only) { return 0; } -static inline int lprocfs_obd_cleanup(struct obd_device *dev) +static inline int lprocfs_obd_cleanup(struct obd_device *obd) { return 0; } static inline int lprocfs_uuid_seq_show(struct seq_file *m, void *data) { return 0; } -static inline int lprocfs_name_seq_show(struct seq_file *m, void *data) -{ return 0; } static inline int lprocfs_server_seq_show(struct seq_file *m, void *data) { return 0; } -static inline int lprocfs_conn_uuid_seq_show(struct seq_file *m, void *data) -{ return 0; } static inline int lprocfs_import_seq_show(struct seq_file *m, void *data) { return 0; } static inline int lprocfs_state_seq_show(struct seq_file *m, void *data) @@ -921,6 +1019,10 @@ lprocfs_ping_seq_write(struct file *file, const char __user *buffer, size_t count, loff_t *off) { return 0; } static inline ssize_t +ldebugfs_import_seq_write(struct file *file, const char __user *buffer, + size_t count, loff_t *off) +{ return 0; } +static inline ssize_t lprocfs_import_seq_write(struct file *file, const char __user *buffer, size_t count, loff_t *off) { return 0; }