X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Finclude%2Flprocfs_status.h;h=2336a2479d9e517087e8a06569d25124821bfdf9;hb=588f17c88a415e19394d793be32f6a695449519f;hp=89b914b1f813e458d8b3fbd1bcc6732cb3db3e93;hpb=4dfe4a49ccab3d087c14c8b3d539061f9f7f4b75;p=fs%2Flustre-release.git diff --git a/lustre/include/lprocfs_status.h b/lustre/include/lprocfs_status.h index 89b914b..2336a24 100644 --- a/lustre/include/lprocfs_status.h +++ b/lustre/include/lprocfs_status.h @@ -27,7 +27,6 @@ */ /* * This file is part of Lustre, http://www.lustre.org/ - * Lustre is a trademark of Sun Microsystems, Inc. * * lustre/include/lprocfs_status.h * @@ -47,15 +46,28 @@ #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; }; @@ -154,8 +166,14 @@ enum { 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 { @@ -300,6 +318,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 + @@ -327,25 +346,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)) @@ -395,7 +420,8 @@ struct obd_histogram; #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 */ @@ -501,11 +527,9 @@ struct dentry *ldebugfs_add_symlink(const char *name, const char *target, static inline int lprocfs_exp_cleanup(struct obd_export *exp) { return 0; } #endif -struct dentry *ldebugfs_add_simple(struct dentry *root, char *name, void *data, - const struct file_operations *fops); 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, ...); @@ -516,14 +540,17 @@ 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 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 ldebugfs_vars *list, + void *data); extern int lprocfs_add_vars(struct proc_dir_entry *root, struct lprocfs_vars *var, void *data); @@ -536,19 +563,12 @@ extern void lprocfs_remove_proc_entry(const char *name, struct proc_dir_entry *parent); 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 -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 *obd, const char *name, - mode_t mode, - const struct file_operations *seq_fops, + mode_t mode, const struct proc_ops *seq_fops, void *data); /* Generic callbacks */ @@ -580,21 +600,20 @@ ssize_t ping_show(struct kobject *kobj, struct attribute *attr, char *buffer); 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); -int lu_str_to_s64(char *buffer, unsigned long count, __s64 *val, char defunit); -extern int lprocfs_str_with_units_to_s64(const char __user *buffer, - unsigned long count, __s64 *val, - char defunit); - -extern int lprocfs_str_with_units_to_u64(const char __user *buffer, - unsigned long count, __u64 *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); @@ -634,18 +653,26 @@ 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 + * 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. */ -#define with_imp_locked(__obd, __imp, __rc) \ - for (down_read(&(__obd)->u.cli.cl_sem), \ + +#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 ldebugfs_seq_create(obd, filename, 0444, &name#_fops, data); + * 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) \ @@ -725,13 +752,13 @@ static int name##_single_open(struct inode *inode, struct file *file) \ inode->i_private ? inode->i_private : \ PDE_DATA(inode)); \ } \ -static const struct file_operations name##_fops = { \ - .owner = THIS_MODULE, \ - .open = name##_single_open, \ - .read = seq_read, \ - .write = custom_seq_write, \ - .llseek = seq_lseek, \ - .release = lprocfs_single_release, \ +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) @@ -772,10 +799,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 { @@ -835,10 +862,6 @@ 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); -int lprocfs_obd_short_io_bytes_seq_show(struct seq_file *m, void *data); -ssize_t lprocfs_obd_short_io_bytes_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, @@ -978,6 +1001,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; }