Back to home page

OSCL-LXR
 
 

     

0001 /* SPDX-License-Identifier: GPL-2.0 */
0002 /*
0003  * Events for filesystem locks
0004  *
0005  * Copyright 2013 Jeff Layton <jlayton@poochiereds.net>
0006  */
0007 #undef TRACE_SYSTEM
0008 #define TRACE_SYSTEM filelock
0009 
0010 #if !defined(_TRACE_FILELOCK_H) || defined(TRACE_HEADER_MULTI_READ)
0011 #define _TRACE_FILELOCK_H
0012 
0013 #include <linux/tracepoint.h>
0014 #include <linux/fs.h>
0015 #include <linux/device.h>
0016 #include <linux/kdev_t.h>
0017 
0018 #define show_fl_flags(val)                      \
0019     __print_flags(val, "|",                     \
0020         { FL_POSIX,     "FL_POSIX" },           \
0021         { FL_FLOCK,     "FL_FLOCK" },           \
0022         { FL_DELEG,     "FL_DELEG" },           \
0023         { FL_ACCESS,        "FL_ACCESS" },          \
0024         { FL_EXISTS,        "FL_EXISTS" },          \
0025         { FL_LEASE,     "FL_LEASE" },           \
0026         { FL_CLOSE,     "FL_CLOSE" },           \
0027         { FL_SLEEP,     "FL_SLEEP" },           \
0028         { FL_DOWNGRADE_PENDING, "FL_DOWNGRADE_PENDING" },   \
0029         { FL_UNLOCK_PENDING,    "FL_UNLOCK_PENDING" },      \
0030         { FL_OFDLCK,        "FL_OFDLCK" })
0031 
0032 #define show_fl_type(val)               \
0033     __print_symbolic(val,               \
0034             { F_RDLCK, "F_RDLCK" },     \
0035             { F_WRLCK, "F_WRLCK" },     \
0036             { F_UNLCK, "F_UNLCK" })
0037 
0038 TRACE_EVENT(locks_get_lock_context,
0039     TP_PROTO(struct inode *inode, int type, struct file_lock_context *ctx),
0040 
0041     TP_ARGS(inode, type, ctx),
0042 
0043     TP_STRUCT__entry(
0044         __field(unsigned long, i_ino)
0045         __field(dev_t, s_dev)
0046         __field(unsigned char, type)
0047         __field(struct file_lock_context *, ctx)
0048     ),
0049 
0050     TP_fast_assign(
0051         __entry->s_dev = inode->i_sb->s_dev;
0052         __entry->i_ino = inode->i_ino;
0053         __entry->type = type;
0054         __entry->ctx = ctx;
0055     ),
0056 
0057     TP_printk("dev=0x%x:0x%x ino=0x%lx type=%s ctx=%p",
0058           MAJOR(__entry->s_dev), MINOR(__entry->s_dev),
0059           __entry->i_ino, show_fl_type(__entry->type), __entry->ctx)
0060 );
0061 
0062 DECLARE_EVENT_CLASS(filelock_lock,
0063     TP_PROTO(struct inode *inode, struct file_lock *fl, int ret),
0064 
0065     TP_ARGS(inode, fl, ret),
0066 
0067     TP_STRUCT__entry(
0068         __field(struct file_lock *, fl)
0069         __field(unsigned long, i_ino)
0070         __field(dev_t, s_dev)
0071         __field(struct file_lock *, fl_blocker)
0072         __field(fl_owner_t, fl_owner)
0073         __field(unsigned int, fl_pid)
0074         __field(unsigned int, fl_flags)
0075         __field(unsigned char, fl_type)
0076         __field(loff_t, fl_start)
0077         __field(loff_t, fl_end)
0078         __field(int, ret)
0079     ),
0080 
0081     TP_fast_assign(
0082         __entry->fl = fl ? fl : NULL;
0083         __entry->s_dev = inode->i_sb->s_dev;
0084         __entry->i_ino = inode->i_ino;
0085         __entry->fl_blocker = fl ? fl->fl_blocker : NULL;
0086         __entry->fl_owner = fl ? fl->fl_owner : NULL;
0087         __entry->fl_pid = fl ? fl->fl_pid : 0;
0088         __entry->fl_flags = fl ? fl->fl_flags : 0;
0089         __entry->fl_type = fl ? fl->fl_type : 0;
0090         __entry->fl_start = fl ? fl->fl_start : 0;
0091         __entry->fl_end = fl ? fl->fl_end : 0;
0092         __entry->ret = ret;
0093     ),
0094 
0095     TP_printk("fl=%p dev=0x%x:0x%x ino=0x%lx fl_blocker=%p fl_owner=%p fl_pid=%u fl_flags=%s fl_type=%s fl_start=%lld fl_end=%lld ret=%d",
0096         __entry->fl, MAJOR(__entry->s_dev), MINOR(__entry->s_dev),
0097         __entry->i_ino, __entry->fl_blocker, __entry->fl_owner,
0098         __entry->fl_pid, show_fl_flags(__entry->fl_flags),
0099         show_fl_type(__entry->fl_type),
0100         __entry->fl_start, __entry->fl_end, __entry->ret)
0101 );
0102 
0103 DEFINE_EVENT(filelock_lock, posix_lock_inode,
0104         TP_PROTO(struct inode *inode, struct file_lock *fl, int ret),
0105         TP_ARGS(inode, fl, ret));
0106 
0107 DEFINE_EVENT(filelock_lock, fcntl_setlk,
0108         TP_PROTO(struct inode *inode, struct file_lock *fl, int ret),
0109         TP_ARGS(inode, fl, ret));
0110 
0111 DEFINE_EVENT(filelock_lock, locks_remove_posix,
0112         TP_PROTO(struct inode *inode, struct file_lock *fl, int ret),
0113         TP_ARGS(inode, fl, ret));
0114 
0115 DEFINE_EVENT(filelock_lock, flock_lock_inode,
0116         TP_PROTO(struct inode *inode, struct file_lock *fl, int ret),
0117         TP_ARGS(inode, fl, ret));
0118 
0119 DECLARE_EVENT_CLASS(filelock_lease,
0120     TP_PROTO(struct inode *inode, struct file_lock *fl),
0121 
0122     TP_ARGS(inode, fl),
0123 
0124     TP_STRUCT__entry(
0125         __field(struct file_lock *, fl)
0126         __field(unsigned long, i_ino)
0127         __field(dev_t, s_dev)
0128         __field(struct file_lock *, fl_blocker)
0129         __field(fl_owner_t, fl_owner)
0130         __field(unsigned int, fl_flags)
0131         __field(unsigned char, fl_type)
0132         __field(unsigned long, fl_break_time)
0133         __field(unsigned long, fl_downgrade_time)
0134     ),
0135 
0136     TP_fast_assign(
0137         __entry->fl = fl ? fl : NULL;
0138         __entry->s_dev = inode->i_sb->s_dev;
0139         __entry->i_ino = inode->i_ino;
0140         __entry->fl_blocker = fl ? fl->fl_blocker : NULL;
0141         __entry->fl_owner = fl ? fl->fl_owner : NULL;
0142         __entry->fl_flags = fl ? fl->fl_flags : 0;
0143         __entry->fl_type = fl ? fl->fl_type : 0;
0144         __entry->fl_break_time = fl ? fl->fl_break_time : 0;
0145         __entry->fl_downgrade_time = fl ? fl->fl_downgrade_time : 0;
0146     ),
0147 
0148     TP_printk("fl=%p dev=0x%x:0x%x ino=0x%lx fl_blocker=%p fl_owner=%p fl_flags=%s fl_type=%s fl_break_time=%lu fl_downgrade_time=%lu",
0149         __entry->fl, MAJOR(__entry->s_dev), MINOR(__entry->s_dev),
0150         __entry->i_ino, __entry->fl_blocker, __entry->fl_owner,
0151         show_fl_flags(__entry->fl_flags),
0152         show_fl_type(__entry->fl_type),
0153         __entry->fl_break_time, __entry->fl_downgrade_time)
0154 );
0155 
0156 DEFINE_EVENT(filelock_lease, break_lease_noblock, TP_PROTO(struct inode *inode, struct file_lock *fl),
0157         TP_ARGS(inode, fl));
0158 
0159 DEFINE_EVENT(filelock_lease, break_lease_block, TP_PROTO(struct inode *inode, struct file_lock *fl),
0160         TP_ARGS(inode, fl));
0161 
0162 DEFINE_EVENT(filelock_lease, break_lease_unblock, TP_PROTO(struct inode *inode, struct file_lock *fl),
0163         TP_ARGS(inode, fl));
0164 
0165 DEFINE_EVENT(filelock_lease, generic_delete_lease, TP_PROTO(struct inode *inode, struct file_lock *fl),
0166         TP_ARGS(inode, fl));
0167 
0168 DEFINE_EVENT(filelock_lease, time_out_leases, TP_PROTO(struct inode *inode, struct file_lock *fl),
0169         TP_ARGS(inode, fl));
0170 
0171 TRACE_EVENT(generic_add_lease,
0172     TP_PROTO(struct inode *inode, struct file_lock *fl),
0173 
0174     TP_ARGS(inode, fl),
0175 
0176     TP_STRUCT__entry(
0177         __field(unsigned long, i_ino)
0178         __field(int, wcount)
0179         __field(int, rcount)
0180         __field(int, icount)
0181         __field(dev_t, s_dev)
0182         __field(fl_owner_t, fl_owner)
0183         __field(unsigned int, fl_flags)
0184         __field(unsigned char, fl_type)
0185     ),
0186 
0187     TP_fast_assign(
0188         __entry->s_dev = inode->i_sb->s_dev;
0189         __entry->i_ino = inode->i_ino;
0190         __entry->wcount = atomic_read(&inode->i_writecount);
0191         __entry->rcount = atomic_read(&inode->i_readcount);
0192         __entry->icount = atomic_read(&inode->i_count);
0193         __entry->fl_owner = fl->fl_owner;
0194         __entry->fl_flags = fl->fl_flags;
0195         __entry->fl_type = fl->fl_type;
0196     ),
0197 
0198     TP_printk("dev=0x%x:0x%x ino=0x%lx wcount=%d rcount=%d icount=%d fl_owner=%p fl_flags=%s fl_type=%s",
0199         MAJOR(__entry->s_dev), MINOR(__entry->s_dev),
0200         __entry->i_ino, __entry->wcount, __entry->rcount,
0201         __entry->icount, __entry->fl_owner,
0202         show_fl_flags(__entry->fl_flags),
0203         show_fl_type(__entry->fl_type))
0204 );
0205 
0206 TRACE_EVENT(leases_conflict,
0207     TP_PROTO(bool conflict, struct file_lock *lease, struct file_lock *breaker),
0208 
0209     TP_ARGS(conflict, lease, breaker),
0210 
0211     TP_STRUCT__entry(
0212         __field(void *, lease)
0213         __field(void *, breaker)
0214         __field(unsigned int, l_fl_flags)
0215         __field(unsigned int, b_fl_flags)
0216         __field(unsigned char, l_fl_type)
0217         __field(unsigned char, b_fl_type)
0218         __field(bool, conflict)
0219     ),
0220 
0221     TP_fast_assign(
0222         __entry->lease = lease;
0223         __entry->l_fl_flags = lease->fl_flags;
0224         __entry->l_fl_type = lease->fl_type;
0225         __entry->breaker = breaker;
0226         __entry->b_fl_flags = breaker->fl_flags;
0227         __entry->b_fl_type = breaker->fl_type;
0228         __entry->conflict = conflict;
0229     ),
0230 
0231     TP_printk("conflict %d: lease=%p fl_flags=%s fl_type=%s; breaker=%p fl_flags=%s fl_type=%s",
0232         __entry->conflict,
0233         __entry->lease,
0234         show_fl_flags(__entry->l_fl_flags),
0235         show_fl_type(__entry->l_fl_type),
0236         __entry->breaker,
0237         show_fl_flags(__entry->b_fl_flags),
0238         show_fl_type(__entry->b_fl_type))
0239 );
0240 
0241 #endif /* _TRACE_FILELOCK_H */
0242 
0243 /* This part must be outside protection */
0244 #include <trace/define_trace.h>
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!