[linux-block.git] / include / trace / events / afs.h

/* AFS tracepoints
 *
 * Copyright (C) 2016 Red Hat, Inc. All Rights Reserved.
 * Written by David Howells (dhowells@redhat.com)
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public Licence
 * as published by the Free Software Foundation; either version
 * 2 of the Licence, or (at your option) any later version.
 */
#undef TRACE_SYSTEM
#define TRACE_SYSTEM afs

#if !defined(_TRACE_AFS_H) || defined(TRACE_HEADER_MULTI_READ)
#define _TRACE_AFS_H

#include <linux/tracepoint.h>

/*
 * Define enums for tracing information.
 */
#ifndef __AFS_DECLARE_TRACE_ENUMS_ONCE_ONLY
#define __AFS_DECLARE_TRACE_ENUMS_ONCE_ONLY

enum afs_call_trace {
	afs_call_trace_alloc,
	afs_call_trace_free,
	afs_call_trace_put,
	afs_call_trace_wake,
	afs_call_trace_work,
};

enum afs_fs_operation {
	afs_FS_FetchData		= 130,	/* AFS Fetch file data */
	afs_FS_FetchStatus		= 132,	/* AFS Fetch file status */
	afs_FS_StoreData		= 133,	/* AFS Store file data */
	afs_FS_StoreStatus		= 135,	/* AFS Store file status */
	afs_FS_RemoveFile		= 136,	/* AFS Remove a file */
	afs_FS_CreateFile		= 137,	/* AFS Create a file */
	afs_FS_Rename			= 138,	/* AFS Rename or move a file or directory */
	afs_FS_Symlink			= 139,	/* AFS Create a symbolic link */
	afs_FS_Link			= 140,	/* AFS Create a hard link */
	afs_FS_MakeDir			= 141,	/* AFS Create a directory */
	afs_FS_RemoveDir		= 142,	/* AFS Remove a directory */
	afs_FS_GetVolumeInfo		= 148,	/* AFS Get information about a volume */
	afs_FS_GetVolumeStatus		= 149,	/* AFS Get volume status information */
	afs_FS_GetRootVolume		= 151,	/* AFS Get root volume name */
	afs_FS_SetLock			= 156,	/* AFS Request a file lock */
	afs_FS_ExtendLock		= 157,	/* AFS Extend a file lock */
	afs_FS_ReleaseLock		= 158,	/* AFS Release a file lock */
	afs_FS_Lookup			= 161,	/* AFS lookup file in directory */
	afs_FS_InlineBulkStatus		= 65536, /* AFS Fetch multiple file statuses with errors */
	afs_FS_FetchData64		= 65537, /* AFS Fetch file data */
	afs_FS_StoreData64		= 65538, /* AFS Store file data */
	afs_FS_GiveUpAllCallBacks	= 65539, /* AFS Give up all our callbacks on a server */
	afs_FS_GetCapabilities		= 65540, /* AFS Get FS server capabilities */
};

enum afs_vl_operation {
	afs_VL_GetEntryByNameU	= 527,		/* AFS Get Vol Entry By Name operation ID */
	afs_VL_GetAddrsU	= 533,		/* AFS Get FS server addresses */
	afs_YFSVL_GetEndpoints	= 64002,	/* YFS Get FS & Vol server addresses */
	afs_VL_GetCapabilities	= 65537,	/* AFS Get VL server capabilities */
};

enum afs_edit_dir_op {
	afs_edit_dir_create,
	afs_edit_dir_create_error,
	afs_edit_dir_create_inval,
	afs_edit_dir_create_nospc,
	afs_edit_dir_delete,
	afs_edit_dir_delete_error,
	afs_edit_dir_delete_inval,
	afs_edit_dir_delete_noent,
};

enum afs_edit_dir_reason {
	afs_edit_dir_for_create,
	afs_edit_dir_for_link,
	afs_edit_dir_for_mkdir,
	afs_edit_dir_for_rename,
	afs_edit_dir_for_rmdir,
	afs_edit_dir_for_symlink,
	afs_edit_dir_for_unlink,
};

#endif /* end __AFS_DECLARE_TRACE_ENUMS_ONCE_ONLY */

/*
 * Declare tracing information enums and their string mappings for display.
 */
#define afs_call_traces \
	EM(afs_call_trace_alloc,		"ALLOC") \
	EM(afs_call_trace_free,			"FREE ") \
	EM(afs_call_trace_put,			"PUT  ") \
	EM(afs_call_trace_wake,			"WAKE ") \
	E_(afs_call_trace_work,			"WORK ")

#define afs_fs_operations \
	EM(afs_FS_FetchData,			"FS.FetchData") \
	EM(afs_FS_FetchStatus,			"FS.FetchStatus") \
	EM(afs_FS_StoreData,			"FS.StoreData") \
	EM(afs_FS_StoreStatus,			"FS.StoreStatus") \
	EM(afs_FS_RemoveFile,			"FS.RemoveFile") \
	EM(afs_FS_CreateFile,			"FS.CreateFile") \
	EM(afs_FS_Rename,			"FS.Rename") \
	EM(afs_FS_Symlink,			"FS.Symlink") \
	EM(afs_FS_Link,				"FS.Link") \
	EM(afs_FS_MakeDir,			"FS.MakeDir") \
	EM(afs_FS_RemoveDir,			"FS.RemoveDir") \
	EM(afs_FS_GetVolumeInfo,		"FS.GetVolumeInfo") \
	EM(afs_FS_GetVolumeStatus,		"FS.GetVolumeStatus") \
	EM(afs_FS_GetRootVolume,		"FS.GetRootVolume") \
	EM(afs_FS_SetLock,			"FS.SetLock") \
	EM(afs_FS_ExtendLock,			"FS.ExtendLock") \
	EM(afs_FS_ReleaseLock,			"FS.ReleaseLock") \
	EM(afs_FS_Lookup,			"FS.Lookup") \
	EM(afs_FS_InlineBulkStatus,		"FS.InlineBulkStatus") \
	EM(afs_FS_FetchData64,			"FS.FetchData64") \
	EM(afs_FS_StoreData64,			"FS.StoreData64") \
	EM(afs_FS_GiveUpAllCallBacks,		"FS.GiveUpAllCallBacks") \
	E_(afs_FS_GetCapabilities,		"FS.GetCapabilities")

#define afs_vl_operations \
	EM(afs_VL_GetEntryByNameU,		"VL.GetEntryByNameU") \
	EM(afs_VL_GetAddrsU,			"VL.GetAddrsU") \
	EM(afs_YFSVL_GetEndpoints,		"YFSVL.GetEndpoints") \
	E_(afs_VL_GetCapabilities,		"VL.GetCapabilities")

#define afs_edit_dir_ops				  \
	EM(afs_edit_dir_create,			"create") \
	EM(afs_edit_dir_create_error,		"c_fail") \
	EM(afs_edit_dir_create_inval,		"c_invl") \
	EM(afs_edit_dir_create_nospc,		"c_nspc") \
	EM(afs_edit_dir_delete,			"delete") \
	EM(afs_edit_dir_delete_error,		"d_err ") \
	EM(afs_edit_dir_delete_inval,		"d_invl") \
	E_(afs_edit_dir_delete_noent,		"d_nent")

#define afs_edit_dir_reasons				  \
	EM(afs_edit_dir_for_create,		"Create") \
	EM(afs_edit_dir_for_link,		"Link  ") \
	EM(afs_edit_dir_for_mkdir,		"MkDir ") \
	EM(afs_edit_dir_for_rename,		"Rename") \
	EM(afs_edit_dir_for_rmdir,		"RmDir ") \
	EM(afs_edit_dir_for_symlink,		"Symlnk") \
	E_(afs_edit_dir_for_unlink,		"Unlink")


/*
 * Export enum symbols via userspace.
 */
#undef EM
#undef E_
#define EM(a, b) TRACE_DEFINE_ENUM(a);
#define E_(a, b) TRACE_DEFINE_ENUM(a);

afs_call_traces;
afs_fs_operations;
afs_vl_operations;
afs_edit_dir_ops;
afs_edit_dir_reasons;

/*
 * Now redefine the EM() and E_() macros to map the enums to the strings that
 * will be printed in the output.
 */
#undef EM
#undef E_
#define EM(a, b)	{ a, b },
#define E_(a, b)	{ a, b }

TRACE_EVENT(afs_recv_data,
	    TP_PROTO(struct afs_call *call, unsigned count, unsigned offset,
		     bool want_more, int ret),

	    TP_ARGS(call, count, offset, want_more, ret),

	    TP_STRUCT__entry(
		    __field(unsigned int,		call		)
		    __field(enum afs_call_state,	state		)
		    __field(unsigned int,		count		)
		    __field(unsigned int,		offset		)
		    __field(unsigned short,		unmarshall	)
		    __field(bool,			want_more	)
		    __field(int,			ret		)
			     ),

	    TP_fast_assign(
		    __entry->call	= call->debug_id;
		    __entry->state	= call->state;
		    __entry->unmarshall	= call->unmarshall;
		    __entry->count	= count;
		    __entry->offset	= offset;
		    __entry->want_more	= want_more;
		    __entry->ret	= ret;
			   ),

	    TP_printk("c=%08x s=%u u=%u %u/%u wm=%u ret=%d",
		      __entry->call,
		      __entry->state, __entry->unmarshall,
		      __entry->offset, __entry->count,
		      __entry->want_more, __entry->ret)
	    );

TRACE_EVENT(afs_notify_call,
	    TP_PROTO(struct rxrpc_call *rxcall, struct afs_call *call),

	    TP_ARGS(rxcall, call),

	    TP_STRUCT__entry(
		    __field(unsigned int,		call		)
		    __field(enum afs_call_state,	state		)
		    __field(unsigned short,		unmarshall	)
			     ),

	    TP_fast_assign(
		    __entry->call	= call->debug_id;
		    __entry->state	= call->state;
		    __entry->unmarshall	= call->unmarshall;
			   ),

	    TP_printk("c=%08x s=%u u=%u",
		      __entry->call,
		      __entry->state, __entry->unmarshall)
	    );

TRACE_EVENT(afs_cb_call,
	    TP_PROTO(struct afs_call *call),

	    TP_ARGS(call),

	    TP_STRUCT__entry(
		    __field(unsigned int,		call		)
		    __field(const char *,		name		)
		    __field(u32,			op		)
			     ),

	    TP_fast_assign(
		    __entry->call	= call->debug_id;
		    __entry->name	= call->type->name;
		    __entry->op		= call->operation_ID;
			   ),

	    TP_printk("c=%08x %s o=%u",
		      __entry->call,
		      __entry->name,
		      __entry->op)
	    );

TRACE_EVENT(afs_call,
	    TP_PROTO(struct afs_call *call, enum afs_call_trace op,
		     int usage, int outstanding, const void *where),

	    TP_ARGS(call, op, usage, outstanding, where),

	    TP_STRUCT__entry(
		    __field(unsigned int,		call		)
		    __field(int,			op		)
		    __field(int,			usage		)
		    __field(int,			outstanding	)
		    __field(const void *,		where		)
			     ),

	    TP_fast_assign(
		    __entry->call = call->debug_id;
		    __entry->op = op;
		    __entry->usage = usage;
		    __entry->outstanding = outstanding;
		    __entry->where = where;
			   ),

	    TP_printk("c=%08x %s u=%d o=%d sp=%pSR",
		      __entry->call,
		      __print_symbolic(__entry->op, afs_call_traces),
		      __entry->usage,
		      __entry->outstanding,
		      __entry->where)
	    );

TRACE_EVENT(afs_make_fs_call,
	    TP_PROTO(struct afs_call *call, const struct afs_fid *fid),

	    TP_ARGS(call, fid),

	    TP_STRUCT__entry(
		    __field(unsigned int,		call		)
		    __field(enum afs_fs_operation,	op		)
		    __field_struct(struct afs_fid,	fid		)
			     ),

	    TP_fast_assign(
		    __entry->call = call->debug_id;
		    __entry->op = call->operation_ID;
		    if (fid) {
			    __entry->fid = *fid;
		    } else {
			    __entry->fid.vid = 0;
			    __entry->fid.vnode = 0;
			    __entry->fid.unique = 0;
		    }
			   ),

	    TP_printk("c=%08x %06x:%06x:%06x %s",
		      __entry->call,
		      __entry->fid.vid,
		      __entry->fid.vnode,
		      __entry->fid.unique,
		      __print_symbolic(__entry->op, afs_fs_operations))
	    );

TRACE_EVENT(afs_make_vl_call,
	    TP_PROTO(struct afs_call *call),

	    TP_ARGS(call),

	    TP_STRUCT__entry(
		    __field(unsigned int,		call		)
		    __field(enum afs_vl_operation,	op		)
			     ),

	    TP_fast_assign(
		    __entry->call = call->debug_id;
		    __entry->op = call->operation_ID;
			   ),

	    TP_printk("c=%08x %s",
		      __entry->call,
		      __print_symbolic(__entry->op, afs_vl_operations))
	    );

TRACE_EVENT(afs_call_done,
	    TP_PROTO(struct afs_call *call),

	    TP_ARGS(call),

	    TP_STRUCT__entry(
		    __field(unsigned int,		call		)
		    __field(struct rxrpc_call *,	rx_call		)
		    __field(int,			ret		)
		    __field(u32,			abort_code	)
			     ),

	    TP_fast_assign(
		    __entry->call = call->debug_id;
		    __entry->rx_call = call->rxcall;
		    __entry->ret = call->error;
		    __entry->abort_code = call->abort_code;
			   ),

	    TP_printk("   c=%08x ret=%d ab=%d [%p]",
		      __entry->call,
		      __entry->ret,
		      __entry->abort_code,
		      __entry->rx_call)
	    );

TRACE_EVENT(afs_send_pages,
	    TP_PROTO(struct afs_call *call, struct msghdr *msg,
		     pgoff_t first, pgoff_t last, unsigned int offset),

	    TP_ARGS(call, msg, first, last, offset),

	    TP_STRUCT__entry(
		    __field(unsigned int,		call		)
		    __field(pgoff_t,			first		)
		    __field(pgoff_t,			last		)
		    __field(unsigned int,		nr		)
		    __field(unsigned int,		bytes		)
		    __field(unsigned int,		offset		)
		    __field(unsigned int,		flags		)
			     ),

	    TP_fast_assign(
		    __entry->call = call->debug_id;
		    __entry->first = first;
		    __entry->last = last;
		    __entry->nr = msg->msg_iter.nr_segs;
		    __entry->bytes = msg->msg_iter.count;
		    __entry->offset = offset;
		    __entry->flags = msg->msg_flags;
			   ),

	    TP_printk(" c=%08x %lx-%lx-%lx b=%x o=%x f=%x",
		      __entry->call,
		      __entry->first, __entry->first + __entry->nr - 1, __entry->last,
		      __entry->bytes, __entry->offset,
		      __entry->flags)
	    );

TRACE_EVENT(afs_sent_pages,
	    TP_PROTO(struct afs_call *call, pgoff_t first, pgoff_t last,
		     pgoff_t cursor, int ret),

	    TP_ARGS(call, first, last, cursor, ret),

	    TP_STRUCT__entry(
		    __field(unsigned int,		call		)
		    __field(pgoff_t,			first		)
		    __field(pgoff_t,			last		)
		    __field(pgoff_t,			cursor		)
		    __field(int,			ret		)
			     ),

	    TP_fast_assign(
		    __entry->call = call->debug_id;
		    __entry->first = first;
		    __entry->last = last;
		    __entry->cursor = cursor;
		    __entry->ret = ret;
			   ),

	    TP_printk(" c=%08x %lx-%lx c=%lx r=%d",
		      __entry->call,
		      __entry->first, __entry->last,
		      __entry->cursor, __entry->ret)
	    );

TRACE_EVENT(afs_dir_check_failed,
	    TP_PROTO(struct afs_vnode *vnode, loff_t off, loff_t i_size),

	    TP_ARGS(vnode, off, i_size),

	    TP_STRUCT__entry(
		    __field(struct afs_vnode *,		vnode		)
		    __field(loff_t,			off		)
		    __field(loff_t,			i_size		)
			     ),

	    TP_fast_assign(
		    __entry->vnode = vnode;
		    __entry->off = off;
		    __entry->i_size = i_size;
			   ),

	    TP_printk("vn=%p %llx/%llx",
		      __entry->vnode, __entry->off, __entry->i_size)
	    );

/*
 * We use page->private to hold the amount of the page that we've written to,
 * splitting the field into two parts.  However, we need to represent a range
 * 0...PAGE_SIZE inclusive, so we can't support 64K pages on a 32-bit system.
 */
#if PAGE_SIZE > 32768
#define AFS_PRIV_MAX	0xffffffff
#define AFS_PRIV_SHIFT	32
#else
#define AFS_PRIV_MAX	0xffff
#define AFS_PRIV_SHIFT	16
#endif

TRACE_EVENT(afs_page_dirty,
	    TP_PROTO(struct afs_vnode *vnode, const char *where,
		     pgoff_t page, unsigned long priv),

	    TP_ARGS(vnode, where, page, priv),

	    TP_STRUCT__entry(
		    __field(struct afs_vnode *,		vnode		)
		    __field(const char *,		where		)
		    __field(pgoff_t,			page		)
		    __field(unsigned long,		priv		)
			     ),

	    TP_fast_assign(
		    __entry->vnode = vnode;
		    __entry->where = where;
		    __entry->page = page;
		    __entry->priv = priv;
			   ),

	    TP_printk("vn=%p %lx %s %lu-%lu",
		      __entry->vnode, __entry->page, __entry->where,
		      __entry->priv & AFS_PRIV_MAX,
		      __entry->priv >> AFS_PRIV_SHIFT)
	    );

TRACE_EVENT(afs_call_state,
	    TP_PROTO(struct afs_call *call,
		     enum afs_call_state from,
		     enum afs_call_state to,
		     int ret, u32 remote_abort),

	    TP_ARGS(call, from, to, ret, remote_abort),

	    TP_STRUCT__entry(
		    __field(unsigned int,		call		)
		    __field(enum afs_call_state,	from		)
		    __field(enum afs_call_state,	to		)
		    __field(int,			ret		)
		    __field(u32,			abort		)
			     ),

	    TP_fast_assign(
		    __entry->call = call->debug_id;
		    __entry->from = from;
		    __entry->to = to;
		    __entry->ret = ret;
		    __entry->abort = remote_abort;
			   ),

	    TP_printk("c=%08x %u->%u r=%d ab=%d",
		      __entry->call,
		      __entry->from, __entry->to,
		      __entry->ret, __entry->abort)
	    );

TRACE_EVENT(afs_edit_dir,
	    TP_PROTO(struct afs_vnode *dvnode,
		     enum afs_edit_dir_reason why,
		     enum afs_edit_dir_op op,
		     unsigned int block,
		     unsigned int slot,
		     unsigned int f_vnode,
		     unsigned int f_unique,
		     const char *name),

	    TP_ARGS(dvnode, why, op, block, slot, f_vnode, f_unique, name),

	    TP_STRUCT__entry(
		    __field(unsigned int,		vnode		)
		    __field(unsigned int,		unique		)
		    __field(enum afs_edit_dir_reason,	why		)
		    __field(enum afs_edit_dir_op,	op		)
		    __field(unsigned int,		block		)
		    __field(unsigned short,		slot		)
		    __field(unsigned int,		f_vnode		)
		    __field(unsigned int,		f_unique	)
		    __array(char,			name, 18	)
			     ),

	    TP_fast_assign(
		    int __len = strlen(name);
		    __len = min(__len, 17);
		    __entry->vnode	= dvnode->fid.vnode;
		    __entry->unique	= dvnode->fid.unique;
		    __entry->why	= why;
		    __entry->op		= op;
		    __entry->block	= block;
		    __entry->slot	= slot;
		    __entry->f_vnode	= f_vnode;
		    __entry->f_unique	= f_unique;
		    memcpy(__entry->name, name, __len);
		    __entry->name[__len] = 0;
			   ),

	    TP_printk("d=%x:%x %s %s %u[%u] f=%x:%x %s",
		      __entry->vnode, __entry->unique,
		      __print_symbolic(__entry->why, afs_edit_dir_reasons),
		      __print_symbolic(__entry->op, afs_edit_dir_ops),
		      __entry->block, __entry->slot,
		      __entry->f_vnode, __entry->f_unique,
		      __entry->name)
	    );

#endif /* _TRACE_AFS_H */

/* This part must be outside protection */
#include <trace/define_trace.h>
Commit	Line	Data
8e8d7f13 DH	1	/* AFS tracepoints
	2	*
	3	* Copyright (C) 2016 Red Hat, Inc. All Rights Reserved.
	4	* Written by David Howells (dhowells@redhat.com)
	5	*
	6	* This program is free software; you can redistribute it and/or
	7	* modify it under the terms of the GNU General Public Licence
	8	* as published by the Free Software Foundation; either version
	9	* 2 of the Licence, or (at your option) any later version.
	10	*/
	11	#undef TRACE_SYSTEM
	12	#define TRACE_SYSTEM afs
	13
	14	#if !defined(_TRACE_AFS_H) \|\| defined(TRACE_HEADER_MULTI_READ)
	15	#define _TRACE_AFS_H
	16
	17	#include <linux/tracepoint.h>
	18
341f741f DH	19	/*
	20	* Define enums for tracing information.
	21	*/
	22	#ifndef __AFS_DECLARE_TRACE_ENUMS_ONCE_ONLY
	23	#define __AFS_DECLARE_TRACE_ENUMS_ONCE_ONLY
	24
	25	enum afs_call_trace {
	26	afs_call_trace_alloc,
	27	afs_call_trace_free,
	28	afs_call_trace_put,
	29	afs_call_trace_wake,
	30	afs_call_trace_work,
	31	};
	32
025db80c DH	33	enum afs_fs_operation {
	34	afs_FS_FetchData = 130, /* AFS Fetch file data */
	35	afs_FS_FetchStatus = 132, /* AFS Fetch file status */
	36	afs_FS_StoreData = 133, /* AFS Store file data */
	37	afs_FS_StoreStatus = 135, /* AFS Store file status */
	38	afs_FS_RemoveFile = 136, /* AFS Remove a file */
	39	afs_FS_CreateFile = 137, /* AFS Create a file */
	40	afs_FS_Rename = 138, /* AFS Rename or move a file or directory */
	41	afs_FS_Symlink = 139, /* AFS Create a symbolic link */
	42	afs_FS_Link = 140, /* AFS Create a hard link */
	43	afs_FS_MakeDir = 141, /* AFS Create a directory */
	44	afs_FS_RemoveDir = 142, /* AFS Remove a directory */
	45	afs_FS_GetVolumeInfo = 148, /* AFS Get information about a volume */
	46	afs_FS_GetVolumeStatus = 149, /* AFS Get volume status information */
	47	afs_FS_GetRootVolume = 151, /* AFS Get root volume name */
	48	afs_FS_SetLock = 156, /* AFS Request a file lock */
	49	afs_FS_ExtendLock = 157, /* AFS Extend a file lock */
	50	afs_FS_ReleaseLock = 158, /* AFS Release a file lock */
	51	afs_FS_Lookup = 161, /* AFS lookup file in directory */
5cf9dd55	52	afs_FS_InlineBulkStatus = 65536, /* AFS Fetch multiple file statuses with errors */
025db80c DH	53	afs_FS_FetchData64 = 65537, /* AFS Fetch file data */
	54	afs_FS_StoreData64 = 65538, /* AFS Store file data */
	55	afs_FS_GiveUpAllCallBacks = 65539, /* AFS Give up all our callbacks on a server */
	56	afs_FS_GetCapabilities = 65540, /* AFS Get FS server capabilities */
	57	};
	58
	59	enum afs_vl_operation {
	60	afs_VL_GetEntryByNameU = 527, /* AFS Get Vol Entry By Name operation ID */
	61	afs_VL_GetAddrsU = 533, /* AFS Get FS server addresses */
	62	afs_YFSVL_GetEndpoints = 64002, /* YFS Get FS & Vol server addresses */
	63	afs_VL_GetCapabilities = 65537, /* AFS Get VL server capabilities */
	64	};
	65
63a4681f DH	66	enum afs_edit_dir_op {
	67	afs_edit_dir_create,
	68	afs_edit_dir_create_error,
	69	afs_edit_dir_create_inval,
	70	afs_edit_dir_create_nospc,
	71	afs_edit_dir_delete,
	72	afs_edit_dir_delete_error,
	73	afs_edit_dir_delete_inval,
	74	afs_edit_dir_delete_noent,
	75	};
	76
	77	enum afs_edit_dir_reason {
	78	afs_edit_dir_for_create,
	79	afs_edit_dir_for_link,
	80	afs_edit_dir_for_mkdir,
	81	afs_edit_dir_for_rename,
	82	afs_edit_dir_for_rmdir,
	83	afs_edit_dir_for_symlink,
	84	afs_edit_dir_for_unlink,
	85	};
	86
341f741f DH	87	#endif /* end __AFS_DECLARE_TRACE_ENUMS_ONCE_ONLY */
	88
	89	/*
	90	* Declare tracing information enums and their string mappings for display.
	91	*/
	92	#define afs_call_traces \
	93	EM(afs_call_trace_alloc, "ALLOC") \
	94	EM(afs_call_trace_free, "FREE ") \
	95	EM(afs_call_trace_put, "PUT ") \
	96	EM(afs_call_trace_wake, "WAKE ") \
	97	E_(afs_call_trace_work, "WORK ")
	98
025db80c DH	99	#define afs_fs_operations \
	100	EM(afs_FS_FetchData, "FS.FetchData") \
	101	EM(afs_FS_FetchStatus, "FS.FetchStatus") \
	102	EM(afs_FS_StoreData, "FS.StoreData") \
	103	EM(afs_FS_StoreStatus, "FS.StoreStatus") \
	104	EM(afs_FS_RemoveFile, "FS.RemoveFile") \
	105	EM(afs_FS_CreateFile, "FS.CreateFile") \
	106	EM(afs_FS_Rename, "FS.Rename") \
	107	EM(afs_FS_Symlink, "FS.Symlink") \
	108	EM(afs_FS_Link, "FS.Link") \
	109	EM(afs_FS_MakeDir, "FS.MakeDir") \
	110	EM(afs_FS_RemoveDir, "FS.RemoveDir") \
	111	EM(afs_FS_GetVolumeInfo, "FS.GetVolumeInfo") \
	112	EM(afs_FS_GetVolumeStatus, "FS.GetVolumeStatus") \
	113	EM(afs_FS_GetRootVolume, "FS.GetRootVolume") \
	114	EM(afs_FS_SetLock, "FS.SetLock") \
	115	EM(afs_FS_ExtendLock, "FS.ExtendLock") \
	116	EM(afs_FS_ReleaseLock, "FS.ReleaseLock") \
	117	EM(afs_FS_Lookup, "FS.Lookup") \
5cf9dd55	118	EM(afs_FS_InlineBulkStatus, "FS.InlineBulkStatus") \
025db80c DH	119	EM(afs_FS_FetchData64, "FS.FetchData64") \
	120	EM(afs_FS_StoreData64, "FS.StoreData64") \
	121	EM(afs_FS_GiveUpAllCallBacks, "FS.GiveUpAllCallBacks") \
	122	E_(afs_FS_GetCapabilities, "FS.GetCapabilities")
	123
	124	#define afs_vl_operations \
	125	EM(afs_VL_GetEntryByNameU, "VL.GetEntryByNameU") \
	126	EM(afs_VL_GetAddrsU, "VL.GetAddrsU") \
	127	EM(afs_YFSVL_GetEndpoints, "YFSVL.GetEndpoints") \
	128	E_(afs_VL_GetCapabilities, "VL.GetCapabilities")
	129
63a4681f DH	130	#define afs_edit_dir_ops \
	131	EM(afs_edit_dir_create, "create") \
	132	EM(afs_edit_dir_create_error, "c_fail") \
	133	EM(afs_edit_dir_create_inval, "c_invl") \
	134	EM(afs_edit_dir_create_nospc, "c_nspc") \
	135	EM(afs_edit_dir_delete, "delete") \
	136	EM(afs_edit_dir_delete_error, "d_err ") \
	137	EM(afs_edit_dir_delete_inval, "d_invl") \
	138	E_(afs_edit_dir_delete_noent, "d_nent")
	139
	140	#define afs_edit_dir_reasons \
	141	EM(afs_edit_dir_for_create, "Create") \
	142	EM(afs_edit_dir_for_link, "Link ") \
	143	EM(afs_edit_dir_for_mkdir, "MkDir ") \
	144	EM(afs_edit_dir_for_rename, "Rename") \
	145	EM(afs_edit_dir_for_rmdir, "RmDir ") \
	146	EM(afs_edit_dir_for_symlink, "Symlnk") \
	147	E_(afs_edit_dir_for_unlink, "Unlink")
	148
025db80c	149
341f741f DH	150	/*
	151	* Export enum symbols via userspace.
	152	*/
	153	#undef EM
	154	#undef E_
	155	#define EM(a, b) TRACE_DEFINE_ENUM(a);
	156	#define E_(a, b) TRACE_DEFINE_ENUM(a);
	157
	158	afs_call_traces;
025db80c DH	159	afs_fs_operations;
025db80c DH	160	afs_vl_operations;
63a4681f DH	161	afs_edit_dir_ops;
63a4681f DH	162	afs_edit_dir_reasons;
341f741f DH	163
	164	/*
	165	* Now redefine the EM() and E_() macros to map the enums to the strings that
	166	* will be printed in the output.
	167	*/
	168	#undef EM
	169	#undef E_
	170	#define EM(a, b) { a, b },
	171	#define E_(a, b) { a, b }
	172
8e8d7f13 DH	173	TRACE_EVENT(afs_recv_data,
	174	TP_PROTO(struct afs_call *call, unsigned count, unsigned offset,
	175	bool want_more, int ret),
	176
	177	TP_ARGS(call, count, offset, want_more, ret),
	178
	179	TP_STRUCT__entry(
a25e21f0	180	__field(unsigned int, call )
8e8d7f13 DH	181	__field(enum afs_call_state, state )
	182	__field(unsigned int, count )
	183	__field(unsigned int, offset )
	184	__field(unsigned short, unmarshall )
	185	__field(bool, want_more )
	186	__field(int, ret )
	187	),
	188
	189	TP_fast_assign(
a25e21f0	190	__entry->call = call->debug_id;
8e8d7f13 DH	191	__entry->state = call->state;
	192	__entry->unmarshall = call->unmarshall;
	193	__entry->count = count;
	194	__entry->offset = offset;
	195	__entry->want_more = want_more;
	196	__entry->ret = ret;
	197	),
	198
a25e21f0	199	TP_printk("c=%08x s=%u u=%u %u/%u wm=%u ret=%d",
8e8d7f13 DH	200	__entry->call,
	201	__entry->state, __entry->unmarshall,
	202	__entry->offset, __entry->count,
	203	__entry->want_more, __entry->ret)
	204	);
	205
	206	TRACE_EVENT(afs_notify_call,
	207	TP_PROTO(struct rxrpc_call rxcall, struct afs_call call),
	208
	209	TP_ARGS(rxcall, call),
	210
	211	TP_STRUCT__entry(
a25e21f0	212	__field(unsigned int, call )
8e8d7f13 DH	213	__field(enum afs_call_state, state )
	214	__field(unsigned short, unmarshall )
	215	),
	216
	217	TP_fast_assign(
a25e21f0	218	__entry->call = call->debug_id;
8e8d7f13 DH	219	__entry->state = call->state;
	220	__entry->unmarshall = call->unmarshall;
	221	),
	222
a25e21f0	223	TP_printk("c=%08x s=%u u=%u",
8e8d7f13 DH	224	__entry->call,
	225	__entry->state, __entry->unmarshall)
	226	);
	227
	228	TRACE_EVENT(afs_cb_call,
	229	TP_PROTO(struct afs_call *call),
	230
	231	TP_ARGS(call),
	232
	233	TP_STRUCT__entry(
a25e21f0	234	__field(unsigned int, call )
8e8d7f13 DH	235	__field(const char *, name )
	236	__field(u32, op )
	237	),
	238
	239	TP_fast_assign(
a25e21f0	240	__entry->call = call->debug_id;
8e8d7f13 DH	241	__entry->name = call->type->name;
	242	__entry->op = call->operation_ID;
	243	),
	244
a25e21f0	245	TP_printk("c=%08x %s o=%u",
8e8d7f13 DH	246	__entry->call,
	247	__entry->name,
	248	__entry->op)
	249	);
	250
341f741f DH	251	TRACE_EVENT(afs_call,
	252	TP_PROTO(struct afs_call *call, enum afs_call_trace op,
	253	int usage, int outstanding, const void *where),
	254
	255	TP_ARGS(call, op, usage, outstanding, where),
	256
	257	TP_STRUCT__entry(
a25e21f0	258	__field(unsigned int, call )
341f741f DH	259	__field(int, op )
	260	__field(int, usage )
	261	__field(int, outstanding )
	262	__field(const void *, where )
	263	),
	264
	265	TP_fast_assign(
a25e21f0	266	__entry->call = call->debug_id;
341f741f DH	267	__entry->op = op;
	268	__entry->usage = usage;
	269	__entry->outstanding = outstanding;
	270	__entry->where = where;
	271	),
	272
a25e21f0	273	TP_printk("c=%08x %s u=%d o=%d sp=%pSR",
341f741f DH	274	__entry->call,
	275	__print_symbolic(__entry->op, afs_call_traces),
	276	__entry->usage,
	277	__entry->outstanding,
	278	__entry->where)
	279	);
	280
025db80c DH	281	TRACE_EVENT(afs_make_fs_call,
	282	TP_PROTO(struct afs_call call, const struct afs_fid fid),
	283
	284	TP_ARGS(call, fid),
	285
	286	TP_STRUCT__entry(
a25e21f0	287	__field(unsigned int, call )
025db80c DH	288	__field(enum afs_fs_operation, op )
	289	__field_struct(struct afs_fid, fid )
	290	),
	291
	292	TP_fast_assign(
a25e21f0	293	__entry->call = call->debug_id;
025db80c DH	294	__entry->op = call->operation_ID;
	295	if (fid) {
	296	__entry->fid = *fid;
	297	} else {
	298	__entry->fid.vid = 0;
	299	__entry->fid.vnode = 0;
	300	__entry->fid.unique = 0;
	301	}
	302	),
	303
a25e21f0	304	TP_printk("c=%08x %06x:%06x:%06x %s",
025db80c DH	305	__entry->call,
	306	__entry->fid.vid,
	307	__entry->fid.vnode,
	308	__entry->fid.unique,
	309	__print_symbolic(__entry->op, afs_fs_operations))
	310	);
	311
	312	TRACE_EVENT(afs_make_vl_call,
	313	TP_PROTO(struct afs_call *call),
	314
	315	TP_ARGS(call),
	316
	317	TP_STRUCT__entry(
a25e21f0	318	__field(unsigned int, call )
025db80c DH	319	__field(enum afs_vl_operation, op )
	320	),
	321
	322	TP_fast_assign(
a25e21f0	323	__entry->call = call->debug_id;
025db80c DH	324	__entry->op = call->operation_ID;
	325	),
	326
a25e21f0	327	TP_printk("c=%08x %s",
025db80c DH	328	__entry->call,
	329	__print_symbolic(__entry->op, afs_vl_operations))
	330	);
	331
	332	TRACE_EVENT(afs_call_done,
	333	TP_PROTO(struct afs_call *call),
	334
	335	TP_ARGS(call),
	336
	337	TP_STRUCT__entry(
a25e21f0	338	__field(unsigned int, call )
025db80c DH	339	__field(struct rxrpc_call *, rx_call )
	340	__field(int, ret )
	341	__field(u32, abort_code )
	342	),
	343
	344	TP_fast_assign(
a25e21f0	345	__entry->call = call->debug_id;
025db80c DH	346	__entry->rx_call = call->rxcall;
	347	__entry->ret = call->error;
	348	__entry->abort_code = call->abort_code;
	349	),
	350
a25e21f0	351	TP_printk(" c=%08x ret=%d ab=%d [%p]",
025db80c DH	352	__entry->call,
	353	__entry->ret,
	354	__entry->abort_code,
	355	__entry->rx_call)
	356	);
	357
2c099014 DH	358	TRACE_EVENT(afs_send_pages,
	359	TP_PROTO(struct afs_call call, struct msghdr msg,
	360	pgoff_t first, pgoff_t last, unsigned int offset),
	361
	362	TP_ARGS(call, msg, first, last, offset),
	363
	364	TP_STRUCT__entry(
a25e21f0	365	__field(unsigned int, call )
2c099014 DH	366	__field(pgoff_t, first )
	367	__field(pgoff_t, last )
	368	__field(unsigned int, nr )
	369	__field(unsigned int, bytes )
	370	__field(unsigned int, offset )
	371	__field(unsigned int, flags )
	372	),
	373
	374	TP_fast_assign(
a25e21f0	375	__entry->call = call->debug_id;
2c099014 DH	376	__entry->first = first;
	377	__entry->last = last;
	378	__entry->nr = msg->msg_iter.nr_segs;
	379	__entry->bytes = msg->msg_iter.count;
	380	__entry->offset = offset;
	381	__entry->flags = msg->msg_flags;
	382	),
	383
a25e21f0	384	TP_printk(" c=%08x %lx-%lx-%lx b=%x o=%x f=%x",
2c099014 DH	385	__entry->call,
	386	__entry->first, __entry->first + __entry->nr - 1, __entry->last,
	387	__entry->bytes, __entry->offset,
	388	__entry->flags)
	389	);
	390
	391	TRACE_EVENT(afs_sent_pages,
	392	TP_PROTO(struct afs_call *call, pgoff_t first, pgoff_t last,
	393	pgoff_t cursor, int ret),
	394
	395	TP_ARGS(call, first, last, cursor, ret),
	396
	397	TP_STRUCT__entry(
a25e21f0	398	__field(unsigned int, call )
2c099014 DH	399	__field(pgoff_t, first )
	400	__field(pgoff_t, last )
	401	__field(pgoff_t, cursor )
	402	__field(int, ret )
	403	),
	404
	405	TP_fast_assign(
a25e21f0	406	__entry->call = call->debug_id;
2c099014 DH	407	__entry->first = first;
	408	__entry->last = last;
	409	__entry->cursor = cursor;
	410	__entry->ret = ret;
	411	),
	412
a25e21f0	413	TP_printk(" c=%08x %lx-%lx c=%lx r=%d",
2c099014 DH	414	__entry->call,
	415	__entry->first, __entry->last,
	416	__entry->cursor, __entry->ret)
	417	);
	418
dab17c1a DH	419	TRACE_EVENT(afs_dir_check_failed,
	420	TP_PROTO(struct afs_vnode *vnode, loff_t off, loff_t i_size),
	421
	422	TP_ARGS(vnode, off, i_size),
	423
	424	TP_STRUCT__entry(
	425	__field(struct afs_vnode *, vnode )
	426	__field(loff_t, off )
	427	__field(loff_t, i_size )
	428	),
	429
	430	TP_fast_assign(
	431	__entry->vnode = vnode;
	432	__entry->off = off;
	433	__entry->i_size = i_size;
	434	),
	435
	436	TP_printk("vn=%p %llx/%llx",
	437	__entry->vnode, __entry->off, __entry->i_size)
	438	);
	439
13524ab3 DH	440	/*
	441	* We use page->private to hold the amount of the page that we've written to,
	442	* splitting the field into two parts. However, we need to represent a range
	443	* 0...PAGE_SIZE inclusive, so we can't support 64K pages on a 32-bit system.
	444	*/
	445	#if PAGE_SIZE > 32768
	446	#define AFS_PRIV_MAX 0xffffffff
	447	#define AFS_PRIV_SHIFT 32
	448	#else
	449	#define AFS_PRIV_MAX 0xffff
	450	#define AFS_PRIV_SHIFT 16
	451	#endif
	452
	453	TRACE_EVENT(afs_page_dirty,
	454	TP_PROTO(struct afs_vnode vnode, const char where,
	455	pgoff_t page, unsigned long priv),
	456
	457	TP_ARGS(vnode, where, page, priv),
	458
	459	TP_STRUCT__entry(
	460	__field(struct afs_vnode *, vnode )
	461	__field(const char *, where )
	462	__field(pgoff_t, page )
	463	__field(unsigned long, priv )
	464	),
	465
	466	TP_fast_assign(
	467	__entry->vnode = vnode;
	468	__entry->where = where;
	469	__entry->page = page;
	470	__entry->priv = priv;
	471	),
	472
	473	TP_printk("vn=%p %lx %s %lu-%lu",
	474	__entry->vnode, __entry->page, __entry->where,
	475	__entry->priv & AFS_PRIV_MAX,
	476	__entry->priv >> AFS_PRIV_SHIFT)
	477	);
	478
98bf40cd DH	479	TRACE_EVENT(afs_call_state,
	480	TP_PROTO(struct afs_call *call,
	481	enum afs_call_state from,
	482	enum afs_call_state to,
	483	int ret, u32 remote_abort),
	484
	485	TP_ARGS(call, from, to, ret, remote_abort),
	486
	487	TP_STRUCT__entry(
a25e21f0	488	__field(unsigned int, call )
98bf40cd DH	489	__field(enum afs_call_state, from )
	490	__field(enum afs_call_state, to )
	491	__field(int, ret )
	492	__field(u32, abort )
	493	),
	494
	495	TP_fast_assign(
a25e21f0	496	__entry->call = call->debug_id;
98bf40cd DH	497	__entry->from = from;
	498	__entry->to = to;
	499	__entry->ret = ret;
	500	__entry->abort = remote_abort;
	501	),
	502
a25e21f0	503	TP_printk("c=%08x %u->%u r=%d ab=%d",
98bf40cd DH	504	__entry->call,
	505	__entry->from, __entry->to,
	506	__entry->ret, __entry->abort)
	507	);
	508
63a4681f DH	509	TRACE_EVENT(afs_edit_dir,
	510	TP_PROTO(struct afs_vnode *dvnode,
	511	enum afs_edit_dir_reason why,
	512	enum afs_edit_dir_op op,
	513	unsigned int block,
	514	unsigned int slot,
	515	unsigned int f_vnode,
	516	unsigned int f_unique,
	517	const char *name),
	518
	519	TP_ARGS(dvnode, why, op, block, slot, f_vnode, f_unique, name),
	520
	521	TP_STRUCT__entry(
	522	__field(unsigned int, vnode )
	523	__field(unsigned int, unique )
	524	__field(enum afs_edit_dir_reason, why )
	525	__field(enum afs_edit_dir_op, op )
	526	__field(unsigned int, block )
	527	__field(unsigned short, slot )
	528	__field(unsigned int, f_vnode )
	529	__field(unsigned int, f_unique )
	530	__array(char, name, 18 )
	531	),
	532
	533	TP_fast_assign(
	534	int __len = strlen(name);
	535	__len = min(__len, 17);
	536	__entry->vnode = dvnode->fid.vnode;
	537	__entry->unique = dvnode->fid.unique;
	538	__entry->why = why;
	539	__entry->op = op;
	540	__entry->block = block;
	541	__entry->slot = slot;
	542	__entry->f_vnode = f_vnode;
	543	__entry->f_unique = f_unique;
	544	memcpy(__entry->name, name, __len);
	545	__entry->name[__len] = 0;
	546	),
	547
	548	TP_printk("d=%x:%x %s %s %u[%u] f=%x:%x %s",
	549	__entry->vnode, __entry->unique,
	550	__print_symbolic(__entry->why, afs_edit_dir_reasons),
	551	__print_symbolic(__entry->op, afs_edit_dir_ops),
	552	__entry->block, __entry->slot,
	553	__entry->f_vnode, __entry->f_unique,
	554	__entry->name)
	555	);
	556
8e8d7f13 DH	557	#endif /* _TRACE_AFS_H */
	558
	559	/* This part must be outside protection */
	560	#include <trace/define_trace.h>