Loading...
1/* SPDX-License-Identifier: GPL-2.0-or-later */
2/* AFS tracepoints
3 *
4 * Copyright (C) 2016 Red Hat, Inc. All Rights Reserved.
5 * Written by David Howells (dhowells@redhat.com)
6 */
7#undef TRACE_SYSTEM
8#define TRACE_SYSTEM afs
9
10#if !defined(_TRACE_AFS_H) || defined(TRACE_HEADER_MULTI_READ)
11#define _TRACE_AFS_H
12
13#include <linux/tracepoint.h>
14
15/*
16 * Define enums for tracing information.
17 */
18#ifndef __AFS_DECLARE_TRACE_ENUMS_ONCE_ONLY
19#define __AFS_DECLARE_TRACE_ENUMS_ONCE_ONLY
20
21enum afs_call_trace {
22 afs_call_trace_alloc,
23 afs_call_trace_free,
24 afs_call_trace_get,
25 afs_call_trace_put,
26 afs_call_trace_wake,
27 afs_call_trace_work,
28};
29
30enum afs_server_trace {
31 afs_server_trace_alloc,
32 afs_server_trace_callback,
33 afs_server_trace_destroy,
34 afs_server_trace_free,
35 afs_server_trace_gc,
36 afs_server_trace_get_by_uuid,
37 afs_server_trace_get_caps,
38 afs_server_trace_get_install,
39 afs_server_trace_get_new_cbi,
40 afs_server_trace_give_up_cb,
41 afs_server_trace_put_call,
42 afs_server_trace_put_cbi,
43 afs_server_trace_put_find_rsq,
44 afs_server_trace_put_slist,
45 afs_server_trace_put_slist_isort,
46 afs_server_trace_put_uuid_rsq,
47 afs_server_trace_update,
48};
49
50enum afs_fs_operation {
51 afs_FS_FetchData = 130, /* AFS Fetch file data */
52 afs_FS_FetchACL = 131, /* AFS Fetch file ACL */
53 afs_FS_FetchStatus = 132, /* AFS Fetch file status */
54 afs_FS_StoreData = 133, /* AFS Store file data */
55 afs_FS_StoreACL = 134, /* AFS Store file ACL */
56 afs_FS_StoreStatus = 135, /* AFS Store file status */
57 afs_FS_RemoveFile = 136, /* AFS Remove a file */
58 afs_FS_CreateFile = 137, /* AFS Create a file */
59 afs_FS_Rename = 138, /* AFS Rename or move a file or directory */
60 afs_FS_Symlink = 139, /* AFS Create a symbolic link */
61 afs_FS_Link = 140, /* AFS Create a hard link */
62 afs_FS_MakeDir = 141, /* AFS Create a directory */
63 afs_FS_RemoveDir = 142, /* AFS Remove a directory */
64 afs_FS_GetVolumeInfo = 148, /* AFS Get information about a volume */
65 afs_FS_GetVolumeStatus = 149, /* AFS Get volume status information */
66 afs_FS_GetRootVolume = 151, /* AFS Get root volume name */
67 afs_FS_SetLock = 156, /* AFS Request a file lock */
68 afs_FS_ExtendLock = 157, /* AFS Extend a file lock */
69 afs_FS_ReleaseLock = 158, /* AFS Release a file lock */
70 afs_FS_Lookup = 161, /* AFS lookup file in directory */
71 afs_FS_InlineBulkStatus = 65536, /* AFS Fetch multiple file statuses with errors */
72 afs_FS_FetchData64 = 65537, /* AFS Fetch file data */
73 afs_FS_StoreData64 = 65538, /* AFS Store file data */
74 afs_FS_GiveUpAllCallBacks = 65539, /* AFS Give up all our callbacks on a server */
75 afs_FS_GetCapabilities = 65540, /* AFS Get FS server capabilities */
76
77 yfs_FS_FetchData = 130, /* YFS Fetch file data */
78 yfs_FS_FetchACL = 64131, /* YFS Fetch file ACL */
79 yfs_FS_FetchStatus = 64132, /* YFS Fetch file status */
80 yfs_FS_StoreACL = 64134, /* YFS Store file ACL */
81 yfs_FS_StoreStatus = 64135, /* YFS Store file status */
82 yfs_FS_RemoveFile = 64136, /* YFS Remove a file */
83 yfs_FS_CreateFile = 64137, /* YFS Create a file */
84 yfs_FS_Rename = 64138, /* YFS Rename or move a file or directory */
85 yfs_FS_Symlink = 64139, /* YFS Create a symbolic link */
86 yfs_FS_Link = 64140, /* YFS Create a hard link */
87 yfs_FS_MakeDir = 64141, /* YFS Create a directory */
88 yfs_FS_RemoveDir = 64142, /* YFS Remove a directory */
89 yfs_FS_GetVolumeStatus = 64149, /* YFS Get volume status information */
90 yfs_FS_SetVolumeStatus = 64150, /* YFS Set volume status information */
91 yfs_FS_SetLock = 64156, /* YFS Request a file lock */
92 yfs_FS_ExtendLock = 64157, /* YFS Extend a file lock */
93 yfs_FS_ReleaseLock = 64158, /* YFS Release a file lock */
94 yfs_FS_Lookup = 64161, /* YFS lookup file in directory */
95 yfs_FS_FlushCPS = 64165,
96 yfs_FS_FetchOpaqueACL = 64168,
97 yfs_FS_WhoAmI = 64170,
98 yfs_FS_RemoveACL = 64171,
99 yfs_FS_RemoveFile2 = 64173,
100 yfs_FS_StoreOpaqueACL2 = 64174,
101 yfs_FS_InlineBulkStatus = 64536, /* YFS Fetch multiple file statuses with errors */
102 yfs_FS_FetchData64 = 64537, /* YFS Fetch file data */
103 yfs_FS_StoreData64 = 64538, /* YFS Store file data */
104 yfs_FS_UpdateSymlink = 64540,
105};
106
107enum afs_vl_operation {
108 afs_VL_GetEntryByNameU = 527, /* AFS Get Vol Entry By Name operation ID */
109 afs_VL_GetAddrsU = 533, /* AFS Get FS server addresses */
110 afs_YFSVL_GetEndpoints = 64002, /* YFS Get FS & Vol server addresses */
111 afs_VL_GetCapabilities = 65537, /* AFS Get VL server capabilities */
112};
113
114enum afs_edit_dir_op {
115 afs_edit_dir_create,
116 afs_edit_dir_create_error,
117 afs_edit_dir_create_inval,
118 afs_edit_dir_create_nospc,
119 afs_edit_dir_delete,
120 afs_edit_dir_delete_error,
121 afs_edit_dir_delete_inval,
122 afs_edit_dir_delete_noent,
123};
124
125enum afs_edit_dir_reason {
126 afs_edit_dir_for_create,
127 afs_edit_dir_for_link,
128 afs_edit_dir_for_mkdir,
129 afs_edit_dir_for_rename_0,
130 afs_edit_dir_for_rename_1,
131 afs_edit_dir_for_rename_2,
132 afs_edit_dir_for_rmdir,
133 afs_edit_dir_for_silly_0,
134 afs_edit_dir_for_silly_1,
135 afs_edit_dir_for_symlink,
136 afs_edit_dir_for_unlink,
137};
138
139enum afs_eproto_cause {
140 afs_eproto_bad_status,
141 afs_eproto_cb_count,
142 afs_eproto_cb_fid_count,
143 afs_eproto_file_type,
144 afs_eproto_ibulkst_cb_count,
145 afs_eproto_ibulkst_count,
146 afs_eproto_motd_len,
147 afs_eproto_offline_msg_len,
148 afs_eproto_volname_len,
149 afs_eproto_yvl_fsendpt4_len,
150 afs_eproto_yvl_fsendpt6_len,
151 afs_eproto_yvl_fsendpt_num,
152 afs_eproto_yvl_fsendpt_type,
153 afs_eproto_yvl_vlendpt4_len,
154 afs_eproto_yvl_vlendpt6_len,
155 afs_eproto_yvl_vlendpt_type,
156};
157
158enum afs_io_error {
159 afs_io_error_cm_reply,
160 afs_io_error_extract,
161 afs_io_error_fs_probe_fail,
162 afs_io_error_vl_lookup_fail,
163 afs_io_error_vl_probe_fail,
164};
165
166enum afs_file_error {
167 afs_file_error_dir_bad_magic,
168 afs_file_error_dir_big,
169 afs_file_error_dir_missing_page,
170 afs_file_error_dir_over_end,
171 afs_file_error_dir_small,
172 afs_file_error_dir_unmarked_ext,
173 afs_file_error_mntpt,
174 afs_file_error_writeback_fail,
175};
176
177enum afs_flock_event {
178 afs_flock_acquired,
179 afs_flock_callback_break,
180 afs_flock_defer_unlock,
181 afs_flock_extend_fail,
182 afs_flock_fail_other,
183 afs_flock_fail_perm,
184 afs_flock_no_lockers,
185 afs_flock_release_fail,
186 afs_flock_silly_delete,
187 afs_flock_timestamp,
188 afs_flock_try_to_lock,
189 afs_flock_vfs_lock,
190 afs_flock_vfs_locking,
191 afs_flock_waited,
192 afs_flock_waiting,
193 afs_flock_work_extending,
194 afs_flock_work_retry,
195 afs_flock_work_unlocking,
196 afs_flock_would_block,
197};
198
199enum afs_flock_operation {
200 afs_flock_op_copy_lock,
201 afs_flock_op_flock,
202 afs_flock_op_grant,
203 afs_flock_op_lock,
204 afs_flock_op_release_lock,
205 afs_flock_op_return_ok,
206 afs_flock_op_return_eagain,
207 afs_flock_op_return_edeadlk,
208 afs_flock_op_return_error,
209 afs_flock_op_set_lock,
210 afs_flock_op_unlock,
211 afs_flock_op_wake,
212};
213
214enum afs_cb_break_reason {
215 afs_cb_break_no_break,
216 afs_cb_break_for_callback,
217 afs_cb_break_for_deleted,
218 afs_cb_break_for_lapsed,
219 afs_cb_break_for_unlink,
220 afs_cb_break_for_vsbreak,
221 afs_cb_break_for_volume_callback,
222 afs_cb_break_for_zap,
223};
224
225#endif /* end __AFS_DECLARE_TRACE_ENUMS_ONCE_ONLY */
226
227/*
228 * Declare tracing information enums and their string mappings for display.
229 */
230#define afs_call_traces \
231 EM(afs_call_trace_alloc, "ALLOC") \
232 EM(afs_call_trace_free, "FREE ") \
233 EM(afs_call_trace_get, "GET ") \
234 EM(afs_call_trace_put, "PUT ") \
235 EM(afs_call_trace_wake, "WAKE ") \
236 E_(afs_call_trace_work, "WORK ")
237
238#define afs_server_traces \
239 EM(afs_server_trace_alloc, "ALLOC ") \
240 EM(afs_server_trace_callback, "CALLBACK ") \
241 EM(afs_server_trace_destroy, "DESTROY ") \
242 EM(afs_server_trace_free, "FREE ") \
243 EM(afs_server_trace_gc, "GC ") \
244 EM(afs_server_trace_get_by_uuid, "GET uuid ") \
245 EM(afs_server_trace_get_caps, "GET caps ") \
246 EM(afs_server_trace_get_install, "GET inst ") \
247 EM(afs_server_trace_get_new_cbi, "GET cbi ") \
248 EM(afs_server_trace_give_up_cb, "giveup-cb") \
249 EM(afs_server_trace_put_call, "PUT call ") \
250 EM(afs_server_trace_put_cbi, "PUT cbi ") \
251 EM(afs_server_trace_put_find_rsq, "PUT f-rsq") \
252 EM(afs_server_trace_put_slist, "PUT slist") \
253 EM(afs_server_trace_put_slist_isort, "PUT isort") \
254 EM(afs_server_trace_put_uuid_rsq, "PUT u-req") \
255 E_(afs_server_trace_update, "UPDATE")
256
257#define afs_fs_operations \
258 EM(afs_FS_FetchData, "FS.FetchData") \
259 EM(afs_FS_FetchStatus, "FS.FetchStatus") \
260 EM(afs_FS_StoreData, "FS.StoreData") \
261 EM(afs_FS_StoreStatus, "FS.StoreStatus") \
262 EM(afs_FS_RemoveFile, "FS.RemoveFile") \
263 EM(afs_FS_CreateFile, "FS.CreateFile") \
264 EM(afs_FS_Rename, "FS.Rename") \
265 EM(afs_FS_Symlink, "FS.Symlink") \
266 EM(afs_FS_Link, "FS.Link") \
267 EM(afs_FS_MakeDir, "FS.MakeDir") \
268 EM(afs_FS_RemoveDir, "FS.RemoveDir") \
269 EM(afs_FS_GetVolumeInfo, "FS.GetVolumeInfo") \
270 EM(afs_FS_GetVolumeStatus, "FS.GetVolumeStatus") \
271 EM(afs_FS_GetRootVolume, "FS.GetRootVolume") \
272 EM(afs_FS_SetLock, "FS.SetLock") \
273 EM(afs_FS_ExtendLock, "FS.ExtendLock") \
274 EM(afs_FS_ReleaseLock, "FS.ReleaseLock") \
275 EM(afs_FS_Lookup, "FS.Lookup") \
276 EM(afs_FS_InlineBulkStatus, "FS.InlineBulkStatus") \
277 EM(afs_FS_FetchData64, "FS.FetchData64") \
278 EM(afs_FS_StoreData64, "FS.StoreData64") \
279 EM(afs_FS_GiveUpAllCallBacks, "FS.GiveUpAllCallBacks") \
280 EM(afs_FS_GetCapabilities, "FS.GetCapabilities") \
281 EM(yfs_FS_FetchACL, "YFS.FetchACL") \
282 EM(yfs_FS_FetchStatus, "YFS.FetchStatus") \
283 EM(yfs_FS_StoreACL, "YFS.StoreACL") \
284 EM(yfs_FS_StoreStatus, "YFS.StoreStatus") \
285 EM(yfs_FS_RemoveFile, "YFS.RemoveFile") \
286 EM(yfs_FS_CreateFile, "YFS.CreateFile") \
287 EM(yfs_FS_Rename, "YFS.Rename") \
288 EM(yfs_FS_Symlink, "YFS.Symlink") \
289 EM(yfs_FS_Link, "YFS.Link") \
290 EM(yfs_FS_MakeDir, "YFS.MakeDir") \
291 EM(yfs_FS_RemoveDir, "YFS.RemoveDir") \
292 EM(yfs_FS_GetVolumeStatus, "YFS.GetVolumeStatus") \
293 EM(yfs_FS_SetVolumeStatus, "YFS.SetVolumeStatus") \
294 EM(yfs_FS_SetLock, "YFS.SetLock") \
295 EM(yfs_FS_ExtendLock, "YFS.ExtendLock") \
296 EM(yfs_FS_ReleaseLock, "YFS.ReleaseLock") \
297 EM(yfs_FS_Lookup, "YFS.Lookup") \
298 EM(yfs_FS_FlushCPS, "YFS.FlushCPS") \
299 EM(yfs_FS_FetchOpaqueACL, "YFS.FetchOpaqueACL") \
300 EM(yfs_FS_WhoAmI, "YFS.WhoAmI") \
301 EM(yfs_FS_RemoveACL, "YFS.RemoveACL") \
302 EM(yfs_FS_RemoveFile2, "YFS.RemoveFile2") \
303 EM(yfs_FS_StoreOpaqueACL2, "YFS.StoreOpaqueACL2") \
304 EM(yfs_FS_InlineBulkStatus, "YFS.InlineBulkStatus") \
305 EM(yfs_FS_FetchData64, "YFS.FetchData64") \
306 EM(yfs_FS_StoreData64, "YFS.StoreData64") \
307 E_(yfs_FS_UpdateSymlink, "YFS.UpdateSymlink")
308
309#define afs_vl_operations \
310 EM(afs_VL_GetEntryByNameU, "VL.GetEntryByNameU") \
311 EM(afs_VL_GetAddrsU, "VL.GetAddrsU") \
312 EM(afs_YFSVL_GetEndpoints, "YFSVL.GetEndpoints") \
313 E_(afs_VL_GetCapabilities, "VL.GetCapabilities")
314
315#define afs_edit_dir_ops \
316 EM(afs_edit_dir_create, "create") \
317 EM(afs_edit_dir_create_error, "c_fail") \
318 EM(afs_edit_dir_create_inval, "c_invl") \
319 EM(afs_edit_dir_create_nospc, "c_nspc") \
320 EM(afs_edit_dir_delete, "delete") \
321 EM(afs_edit_dir_delete_error, "d_err ") \
322 EM(afs_edit_dir_delete_inval, "d_invl") \
323 E_(afs_edit_dir_delete_noent, "d_nent")
324
325#define afs_edit_dir_reasons \
326 EM(afs_edit_dir_for_create, "Create") \
327 EM(afs_edit_dir_for_link, "Link ") \
328 EM(afs_edit_dir_for_mkdir, "MkDir ") \
329 EM(afs_edit_dir_for_rename_0, "Renam0") \
330 EM(afs_edit_dir_for_rename_1, "Renam1") \
331 EM(afs_edit_dir_for_rename_2, "Renam2") \
332 EM(afs_edit_dir_for_rmdir, "RmDir ") \
333 EM(afs_edit_dir_for_silly_0, "S_Ren0") \
334 EM(afs_edit_dir_for_silly_1, "S_Ren1") \
335 EM(afs_edit_dir_for_symlink, "Symlnk") \
336 E_(afs_edit_dir_for_unlink, "Unlink")
337
338#define afs_eproto_causes \
339 EM(afs_eproto_bad_status, "BadStatus") \
340 EM(afs_eproto_cb_count, "CbCount") \
341 EM(afs_eproto_cb_fid_count, "CbFidCount") \
342 EM(afs_eproto_file_type, "FileTYpe") \
343 EM(afs_eproto_ibulkst_cb_count, "IBS.CbCount") \
344 EM(afs_eproto_ibulkst_count, "IBS.FidCount") \
345 EM(afs_eproto_motd_len, "MotdLen") \
346 EM(afs_eproto_offline_msg_len, "OfflineMsgLen") \
347 EM(afs_eproto_volname_len, "VolNameLen") \
348 EM(afs_eproto_yvl_fsendpt4_len, "YVL.FsEnd4Len") \
349 EM(afs_eproto_yvl_fsendpt6_len, "YVL.FsEnd6Len") \
350 EM(afs_eproto_yvl_fsendpt_num, "YVL.FsEndCount") \
351 EM(afs_eproto_yvl_fsendpt_type, "YVL.FsEndType") \
352 EM(afs_eproto_yvl_vlendpt4_len, "YVL.VlEnd4Len") \
353 EM(afs_eproto_yvl_vlendpt6_len, "YVL.VlEnd6Len") \
354 E_(afs_eproto_yvl_vlendpt_type, "YVL.VlEndType")
355
356#define afs_io_errors \
357 EM(afs_io_error_cm_reply, "CM_REPLY") \
358 EM(afs_io_error_extract, "EXTRACT") \
359 EM(afs_io_error_fs_probe_fail, "FS_PROBE_FAIL") \
360 EM(afs_io_error_vl_lookup_fail, "VL_LOOKUP_FAIL") \
361 E_(afs_io_error_vl_probe_fail, "VL_PROBE_FAIL")
362
363#define afs_file_errors \
364 EM(afs_file_error_dir_bad_magic, "DIR_BAD_MAGIC") \
365 EM(afs_file_error_dir_big, "DIR_BIG") \
366 EM(afs_file_error_dir_missing_page, "DIR_MISSING_PAGE") \
367 EM(afs_file_error_dir_over_end, "DIR_ENT_OVER_END") \
368 EM(afs_file_error_dir_small, "DIR_SMALL") \
369 EM(afs_file_error_dir_unmarked_ext, "DIR_UNMARKED_EXT") \
370 EM(afs_file_error_mntpt, "MNTPT_READ_FAILED") \
371 E_(afs_file_error_writeback_fail, "WRITEBACK_FAILED")
372
373#define afs_flock_types \
374 EM(F_RDLCK, "RDLCK") \
375 EM(F_WRLCK, "WRLCK") \
376 E_(F_UNLCK, "UNLCK")
377
378#define afs_flock_states \
379 EM(AFS_VNODE_LOCK_NONE, "NONE") \
380 EM(AFS_VNODE_LOCK_WAITING_FOR_CB, "WAIT_FOR_CB") \
381 EM(AFS_VNODE_LOCK_SETTING, "SETTING") \
382 EM(AFS_VNODE_LOCK_GRANTED, "GRANTED") \
383 EM(AFS_VNODE_LOCK_EXTENDING, "EXTENDING") \
384 EM(AFS_VNODE_LOCK_NEED_UNLOCK, "NEED_UNLOCK") \
385 EM(AFS_VNODE_LOCK_UNLOCKING, "UNLOCKING") \
386 E_(AFS_VNODE_LOCK_DELETED, "DELETED")
387
388#define afs_flock_events \
389 EM(afs_flock_acquired, "Acquired") \
390 EM(afs_flock_callback_break, "Callback") \
391 EM(afs_flock_defer_unlock, "D-Unlock") \
392 EM(afs_flock_extend_fail, "Ext_Fail") \
393 EM(afs_flock_fail_other, "ErrOther") \
394 EM(afs_flock_fail_perm, "ErrPerm ") \
395 EM(afs_flock_no_lockers, "NoLocker") \
396 EM(afs_flock_release_fail, "Rel_Fail") \
397 EM(afs_flock_silly_delete, "SillyDel") \
398 EM(afs_flock_timestamp, "Timestmp") \
399 EM(afs_flock_try_to_lock, "TryToLck") \
400 EM(afs_flock_vfs_lock, "VFSLock ") \
401 EM(afs_flock_vfs_locking, "VFSLking") \
402 EM(afs_flock_waited, "Waited ") \
403 EM(afs_flock_waiting, "Waiting ") \
404 EM(afs_flock_work_extending, "Extendng") \
405 EM(afs_flock_work_retry, "Retry ") \
406 EM(afs_flock_work_unlocking, "Unlcking") \
407 E_(afs_flock_would_block, "EWOULDBL")
408
409#define afs_flock_operations \
410 EM(afs_flock_op_copy_lock, "COPY ") \
411 EM(afs_flock_op_flock, "->flock ") \
412 EM(afs_flock_op_grant, "GRANT ") \
413 EM(afs_flock_op_lock, "->lock ") \
414 EM(afs_flock_op_release_lock, "RELEASE ") \
415 EM(afs_flock_op_return_ok, "<-OK ") \
416 EM(afs_flock_op_return_edeadlk, "<-EDEADL") \
417 EM(afs_flock_op_return_eagain, "<-EAGAIN") \
418 EM(afs_flock_op_return_error, "<-ERROR ") \
419 EM(afs_flock_op_set_lock, "SET ") \
420 EM(afs_flock_op_unlock, "UNLOCK ") \
421 E_(afs_flock_op_wake, "WAKE ")
422
423#define afs_cb_break_reasons \
424 EM(afs_cb_break_no_break, "no-break") \
425 EM(afs_cb_break_for_callback, "break-cb") \
426 EM(afs_cb_break_for_deleted, "break-del") \
427 EM(afs_cb_break_for_lapsed, "break-lapsed") \
428 EM(afs_cb_break_for_unlink, "break-unlink") \
429 EM(afs_cb_break_for_vsbreak, "break-vs") \
430 EM(afs_cb_break_for_volume_callback, "break-v-cb") \
431 E_(afs_cb_break_for_zap, "break-zap")
432
433/*
434 * Export enum symbols via userspace.
435 */
436#undef EM
437#undef E_
438#define EM(a, b) TRACE_DEFINE_ENUM(a);
439#define E_(a, b) TRACE_DEFINE_ENUM(a);
440
441afs_call_traces;
442afs_server_traces;
443afs_fs_operations;
444afs_vl_operations;
445afs_edit_dir_ops;
446afs_edit_dir_reasons;
447afs_eproto_causes;
448afs_io_errors;
449afs_file_errors;
450afs_flock_types;
451afs_flock_operations;
452afs_cb_break_reasons;
453
454/*
455 * Now redefine the EM() and E_() macros to map the enums to the strings that
456 * will be printed in the output.
457 */
458#undef EM
459#undef E_
460#define EM(a, b) { a, b },
461#define E_(a, b) { a, b }
462
463TRACE_EVENT(afs_receive_data,
464 TP_PROTO(struct afs_call *call, struct iov_iter *iter,
465 bool want_more, int ret),
466
467 TP_ARGS(call, iter, want_more, ret),
468
469 TP_STRUCT__entry(
470 __field(loff_t, remain )
471 __field(unsigned int, call )
472 __field(enum afs_call_state, state )
473 __field(unsigned short, unmarshall )
474 __field(bool, want_more )
475 __field(int, ret )
476 ),
477
478 TP_fast_assign(
479 __entry->call = call->debug_id;
480 __entry->state = call->state;
481 __entry->unmarshall = call->unmarshall;
482 __entry->remain = iov_iter_count(iter);
483 __entry->want_more = want_more;
484 __entry->ret = ret;
485 ),
486
487 TP_printk("c=%08x r=%llu u=%u w=%u s=%u ret=%d",
488 __entry->call,
489 __entry->remain,
490 __entry->unmarshall,
491 __entry->want_more,
492 __entry->state,
493 __entry->ret)
494 );
495
496TRACE_EVENT(afs_notify_call,
497 TP_PROTO(struct rxrpc_call *rxcall, struct afs_call *call),
498
499 TP_ARGS(rxcall, call),
500
501 TP_STRUCT__entry(
502 __field(unsigned int, call )
503 __field(enum afs_call_state, state )
504 __field(unsigned short, unmarshall )
505 ),
506
507 TP_fast_assign(
508 __entry->call = call->debug_id;
509 __entry->state = call->state;
510 __entry->unmarshall = call->unmarshall;
511 ),
512
513 TP_printk("c=%08x s=%u u=%u",
514 __entry->call,
515 __entry->state, __entry->unmarshall)
516 );
517
518TRACE_EVENT(afs_cb_call,
519 TP_PROTO(struct afs_call *call),
520
521 TP_ARGS(call),
522
523 TP_STRUCT__entry(
524 __field(unsigned int, call )
525 __field(const char *, name )
526 __field(u32, op )
527 ),
528
529 TP_fast_assign(
530 __entry->call = call->debug_id;
531 __entry->name = call->type->name;
532 __entry->op = call->operation_ID;
533 ),
534
535 TP_printk("c=%08x %s o=%u",
536 __entry->call,
537 __entry->name,
538 __entry->op)
539 );
540
541TRACE_EVENT(afs_call,
542 TP_PROTO(struct afs_call *call, enum afs_call_trace op,
543 int usage, int outstanding, const void *where),
544
545 TP_ARGS(call, op, usage, outstanding, where),
546
547 TP_STRUCT__entry(
548 __field(unsigned int, call )
549 __field(int, op )
550 __field(int, usage )
551 __field(int, outstanding )
552 __field(const void *, where )
553 ),
554
555 TP_fast_assign(
556 __entry->call = call->debug_id;
557 __entry->op = op;
558 __entry->usage = usage;
559 __entry->outstanding = outstanding;
560 __entry->where = where;
561 ),
562
563 TP_printk("c=%08x %s u=%d o=%d sp=%pSR",
564 __entry->call,
565 __print_symbolic(__entry->op, afs_call_traces),
566 __entry->usage,
567 __entry->outstanding,
568 __entry->where)
569 );
570
571TRACE_EVENT(afs_make_fs_call,
572 TP_PROTO(struct afs_call *call, const struct afs_fid *fid),
573
574 TP_ARGS(call, fid),
575
576 TP_STRUCT__entry(
577 __field(unsigned int, call )
578 __field(enum afs_fs_operation, op )
579 __field_struct(struct afs_fid, fid )
580 ),
581
582 TP_fast_assign(
583 __entry->call = call->debug_id;
584 __entry->op = call->operation_ID;
585 if (fid) {
586 __entry->fid = *fid;
587 } else {
588 __entry->fid.vid = 0;
589 __entry->fid.vnode = 0;
590 __entry->fid.unique = 0;
591 }
592 ),
593
594 TP_printk("c=%08x %06llx:%06llx:%06x %s",
595 __entry->call,
596 __entry->fid.vid,
597 __entry->fid.vnode,
598 __entry->fid.unique,
599 __print_symbolic(__entry->op, afs_fs_operations))
600 );
601
602TRACE_EVENT(afs_make_fs_calli,
603 TP_PROTO(struct afs_call *call, const struct afs_fid *fid,
604 unsigned int i),
605
606 TP_ARGS(call, fid, i),
607
608 TP_STRUCT__entry(
609 __field(unsigned int, call )
610 __field(unsigned int, i )
611 __field(enum afs_fs_operation, op )
612 __field_struct(struct afs_fid, fid )
613 ),
614
615 TP_fast_assign(
616 __entry->call = call->debug_id;
617 __entry->i = i;
618 __entry->op = call->operation_ID;
619 if (fid) {
620 __entry->fid = *fid;
621 } else {
622 __entry->fid.vid = 0;
623 __entry->fid.vnode = 0;
624 __entry->fid.unique = 0;
625 }
626 ),
627
628 TP_printk("c=%08x %06llx:%06llx:%06x %s i=%u",
629 __entry->call,
630 __entry->fid.vid,
631 __entry->fid.vnode,
632 __entry->fid.unique,
633 __print_symbolic(__entry->op, afs_fs_operations),
634 __entry->i)
635 );
636
637TRACE_EVENT(afs_make_fs_call1,
638 TP_PROTO(struct afs_call *call, const struct afs_fid *fid,
639 const char *name),
640
641 TP_ARGS(call, fid, name),
642
643 TP_STRUCT__entry(
644 __field(unsigned int, call )
645 __field(enum afs_fs_operation, op )
646 __field_struct(struct afs_fid, fid )
647 __array(char, name, 24 )
648 ),
649
650 TP_fast_assign(
651 int __len = strlen(name);
652 __len = min(__len, 23);
653 __entry->call = call->debug_id;
654 __entry->op = call->operation_ID;
655 if (fid) {
656 __entry->fid = *fid;
657 } else {
658 __entry->fid.vid = 0;
659 __entry->fid.vnode = 0;
660 __entry->fid.unique = 0;
661 }
662 memcpy(__entry->name, name, __len);
663 __entry->name[__len] = 0;
664 ),
665
666 TP_printk("c=%08x %06llx:%06llx:%06x %s \"%s\"",
667 __entry->call,
668 __entry->fid.vid,
669 __entry->fid.vnode,
670 __entry->fid.unique,
671 __print_symbolic(__entry->op, afs_fs_operations),
672 __entry->name)
673 );
674
675TRACE_EVENT(afs_make_fs_call2,
676 TP_PROTO(struct afs_call *call, const struct afs_fid *fid,
677 const char *name, const char *name2),
678
679 TP_ARGS(call, fid, name, name2),
680
681 TP_STRUCT__entry(
682 __field(unsigned int, call )
683 __field(enum afs_fs_operation, op )
684 __field_struct(struct afs_fid, fid )
685 __array(char, name, 24 )
686 __array(char, name2, 24 )
687 ),
688
689 TP_fast_assign(
690 int __len = strlen(name);
691 int __len2 = strlen(name2);
692 __len = min(__len, 23);
693 __len2 = min(__len2, 23);
694 __entry->call = call->debug_id;
695 __entry->op = call->operation_ID;
696 if (fid) {
697 __entry->fid = *fid;
698 } else {
699 __entry->fid.vid = 0;
700 __entry->fid.vnode = 0;
701 __entry->fid.unique = 0;
702 }
703 memcpy(__entry->name, name, __len);
704 __entry->name[__len] = 0;
705 memcpy(__entry->name2, name2, __len2);
706 __entry->name2[__len2] = 0;
707 ),
708
709 TP_printk("c=%08x %06llx:%06llx:%06x %s \"%s\" \"%s\"",
710 __entry->call,
711 __entry->fid.vid,
712 __entry->fid.vnode,
713 __entry->fid.unique,
714 __print_symbolic(__entry->op, afs_fs_operations),
715 __entry->name,
716 __entry->name2)
717 );
718
719TRACE_EVENT(afs_make_vl_call,
720 TP_PROTO(struct afs_call *call),
721
722 TP_ARGS(call),
723
724 TP_STRUCT__entry(
725 __field(unsigned int, call )
726 __field(enum afs_vl_operation, op )
727 ),
728
729 TP_fast_assign(
730 __entry->call = call->debug_id;
731 __entry->op = call->operation_ID;
732 ),
733
734 TP_printk("c=%08x %s",
735 __entry->call,
736 __print_symbolic(__entry->op, afs_vl_operations))
737 );
738
739TRACE_EVENT(afs_call_done,
740 TP_PROTO(struct afs_call *call),
741
742 TP_ARGS(call),
743
744 TP_STRUCT__entry(
745 __field(unsigned int, call )
746 __field(struct rxrpc_call *, rx_call )
747 __field(int, ret )
748 __field(u32, abort_code )
749 ),
750
751 TP_fast_assign(
752 __entry->call = call->debug_id;
753 __entry->rx_call = call->rxcall;
754 __entry->ret = call->error;
755 __entry->abort_code = call->abort_code;
756 ),
757
758 TP_printk(" c=%08x ret=%d ab=%d [%p]",
759 __entry->call,
760 __entry->ret,
761 __entry->abort_code,
762 __entry->rx_call)
763 );
764
765TRACE_EVENT(afs_send_pages,
766 TP_PROTO(struct afs_call *call, struct msghdr *msg,
767 pgoff_t first, pgoff_t last, unsigned int offset),
768
769 TP_ARGS(call, msg, first, last, offset),
770
771 TP_STRUCT__entry(
772 __field(unsigned int, call )
773 __field(pgoff_t, first )
774 __field(pgoff_t, last )
775 __field(unsigned int, nr )
776 __field(unsigned int, bytes )
777 __field(unsigned int, offset )
778 __field(unsigned int, flags )
779 ),
780
781 TP_fast_assign(
782 __entry->call = call->debug_id;
783 __entry->first = first;
784 __entry->last = last;
785 __entry->nr = msg->msg_iter.nr_segs;
786 __entry->bytes = msg->msg_iter.count;
787 __entry->offset = offset;
788 __entry->flags = msg->msg_flags;
789 ),
790
791 TP_printk(" c=%08x %lx-%lx-%lx b=%x o=%x f=%x",
792 __entry->call,
793 __entry->first, __entry->first + __entry->nr - 1, __entry->last,
794 __entry->bytes, __entry->offset,
795 __entry->flags)
796 );
797
798TRACE_EVENT(afs_sent_pages,
799 TP_PROTO(struct afs_call *call, pgoff_t first, pgoff_t last,
800 pgoff_t cursor, int ret),
801
802 TP_ARGS(call, first, last, cursor, ret),
803
804 TP_STRUCT__entry(
805 __field(unsigned int, call )
806 __field(pgoff_t, first )
807 __field(pgoff_t, last )
808 __field(pgoff_t, cursor )
809 __field(int, ret )
810 ),
811
812 TP_fast_assign(
813 __entry->call = call->debug_id;
814 __entry->first = first;
815 __entry->last = last;
816 __entry->cursor = cursor;
817 __entry->ret = ret;
818 ),
819
820 TP_printk(" c=%08x %lx-%lx c=%lx r=%d",
821 __entry->call,
822 __entry->first, __entry->last,
823 __entry->cursor, __entry->ret)
824 );
825
826TRACE_EVENT(afs_dir_check_failed,
827 TP_PROTO(struct afs_vnode *vnode, loff_t off, loff_t i_size),
828
829 TP_ARGS(vnode, off, i_size),
830
831 TP_STRUCT__entry(
832 __field(struct afs_vnode *, vnode )
833 __field(loff_t, off )
834 __field(loff_t, i_size )
835 ),
836
837 TP_fast_assign(
838 __entry->vnode = vnode;
839 __entry->off = off;
840 __entry->i_size = i_size;
841 ),
842
843 TP_printk("vn=%p %llx/%llx",
844 __entry->vnode, __entry->off, __entry->i_size)
845 );
846
847/*
848 * We use page->private to hold the amount of the page that we've written to,
849 * splitting the field into two parts. However, we need to represent a range
850 * 0...PAGE_SIZE inclusive, so we can't support 64K pages on a 32-bit system.
851 */
852#if PAGE_SIZE > 32768
853#define AFS_PRIV_MAX 0xffffffff
854#define AFS_PRIV_SHIFT 32
855#else
856#define AFS_PRIV_MAX 0xffff
857#define AFS_PRIV_SHIFT 16
858#endif
859
860TRACE_EVENT(afs_page_dirty,
861 TP_PROTO(struct afs_vnode *vnode, const char *where,
862 pgoff_t page, unsigned long priv),
863
864 TP_ARGS(vnode, where, page, priv),
865
866 TP_STRUCT__entry(
867 __field(struct afs_vnode *, vnode )
868 __field(const char *, where )
869 __field(pgoff_t, page )
870 __field(unsigned long, priv )
871 ),
872
873 TP_fast_assign(
874 __entry->vnode = vnode;
875 __entry->where = where;
876 __entry->page = page;
877 __entry->priv = priv;
878 ),
879
880 TP_printk("vn=%p %lx %s %lu-%lu",
881 __entry->vnode, __entry->page, __entry->where,
882 __entry->priv & AFS_PRIV_MAX,
883 __entry->priv >> AFS_PRIV_SHIFT)
884 );
885
886TRACE_EVENT(afs_call_state,
887 TP_PROTO(struct afs_call *call,
888 enum afs_call_state from,
889 enum afs_call_state to,
890 int ret, u32 remote_abort),
891
892 TP_ARGS(call, from, to, ret, remote_abort),
893
894 TP_STRUCT__entry(
895 __field(unsigned int, call )
896 __field(enum afs_call_state, from )
897 __field(enum afs_call_state, to )
898 __field(int, ret )
899 __field(u32, abort )
900 ),
901
902 TP_fast_assign(
903 __entry->call = call->debug_id;
904 __entry->from = from;
905 __entry->to = to;
906 __entry->ret = ret;
907 __entry->abort = remote_abort;
908 ),
909
910 TP_printk("c=%08x %u->%u r=%d ab=%d",
911 __entry->call,
912 __entry->from, __entry->to,
913 __entry->ret, __entry->abort)
914 );
915
916TRACE_EVENT(afs_lookup,
917 TP_PROTO(struct afs_vnode *dvnode, const struct qstr *name,
918 struct afs_vnode *vnode),
919
920 TP_ARGS(dvnode, name, vnode),
921
922 TP_STRUCT__entry(
923 __field_struct(struct afs_fid, dfid )
924 __field_struct(struct afs_fid, fid )
925 __array(char, name, 24 )
926 ),
927
928 TP_fast_assign(
929 int __len = min_t(int, name->len, 23);
930 __entry->dfid = dvnode->fid;
931 if (vnode) {
932 __entry->fid = vnode->fid;
933 } else {
934 __entry->fid.vid = 0;
935 __entry->fid.vnode = 0;
936 __entry->fid.unique = 0;
937 }
938 memcpy(__entry->name, name->name, __len);
939 __entry->name[__len] = 0;
940 ),
941
942 TP_printk("d=%llx:%llx:%x \"%s\" f=%llx:%x",
943 __entry->dfid.vid, __entry->dfid.vnode, __entry->dfid.unique,
944 __entry->name,
945 __entry->fid.vnode, __entry->fid.unique)
946 );
947
948TRACE_EVENT(afs_edit_dir,
949 TP_PROTO(struct afs_vnode *dvnode,
950 enum afs_edit_dir_reason why,
951 enum afs_edit_dir_op op,
952 unsigned int block,
953 unsigned int slot,
954 unsigned int f_vnode,
955 unsigned int f_unique,
956 const char *name),
957
958 TP_ARGS(dvnode, why, op, block, slot, f_vnode, f_unique, name),
959
960 TP_STRUCT__entry(
961 __field(unsigned int, vnode )
962 __field(unsigned int, unique )
963 __field(enum afs_edit_dir_reason, why )
964 __field(enum afs_edit_dir_op, op )
965 __field(unsigned int, block )
966 __field(unsigned short, slot )
967 __field(unsigned int, f_vnode )
968 __field(unsigned int, f_unique )
969 __array(char, name, 24 )
970 ),
971
972 TP_fast_assign(
973 int __len = strlen(name);
974 __len = min(__len, 23);
975 __entry->vnode = dvnode->fid.vnode;
976 __entry->unique = dvnode->fid.unique;
977 __entry->why = why;
978 __entry->op = op;
979 __entry->block = block;
980 __entry->slot = slot;
981 __entry->f_vnode = f_vnode;
982 __entry->f_unique = f_unique;
983 memcpy(__entry->name, name, __len);
984 __entry->name[__len] = 0;
985 ),
986
987 TP_printk("d=%x:%x %s %s %u[%u] f=%x:%x \"%s\"",
988 __entry->vnode, __entry->unique,
989 __print_symbolic(__entry->why, afs_edit_dir_reasons),
990 __print_symbolic(__entry->op, afs_edit_dir_ops),
991 __entry->block, __entry->slot,
992 __entry->f_vnode, __entry->f_unique,
993 __entry->name)
994 );
995
996TRACE_EVENT(afs_protocol_error,
997 TP_PROTO(struct afs_call *call, int error, enum afs_eproto_cause cause),
998
999 TP_ARGS(call, error, cause),
1000
1001 TP_STRUCT__entry(
1002 __field(unsigned int, call )
1003 __field(int, error )
1004 __field(enum afs_eproto_cause, cause )
1005 ),
1006
1007 TP_fast_assign(
1008 __entry->call = call ? call->debug_id : 0;
1009 __entry->error = error;
1010 __entry->cause = cause;
1011 ),
1012
1013 TP_printk("c=%08x r=%d %s",
1014 __entry->call, __entry->error,
1015 __print_symbolic(__entry->cause, afs_eproto_causes))
1016 );
1017
1018TRACE_EVENT(afs_io_error,
1019 TP_PROTO(unsigned int call, int error, enum afs_io_error where),
1020
1021 TP_ARGS(call, error, where),
1022
1023 TP_STRUCT__entry(
1024 __field(unsigned int, call )
1025 __field(int, error )
1026 __field(enum afs_io_error, where )
1027 ),
1028
1029 TP_fast_assign(
1030 __entry->call = call;
1031 __entry->error = error;
1032 __entry->where = where;
1033 ),
1034
1035 TP_printk("c=%08x r=%d %s",
1036 __entry->call, __entry->error,
1037 __print_symbolic(__entry->where, afs_io_errors))
1038 );
1039
1040TRACE_EVENT(afs_file_error,
1041 TP_PROTO(struct afs_vnode *vnode, int error, enum afs_file_error where),
1042
1043 TP_ARGS(vnode, error, where),
1044
1045 TP_STRUCT__entry(
1046 __field_struct(struct afs_fid, fid )
1047 __field(int, error )
1048 __field(enum afs_file_error, where )
1049 ),
1050
1051 TP_fast_assign(
1052 __entry->fid = vnode->fid;
1053 __entry->error = error;
1054 __entry->where = where;
1055 ),
1056
1057 TP_printk("%llx:%llx:%x r=%d %s",
1058 __entry->fid.vid, __entry->fid.vnode, __entry->fid.unique,
1059 __entry->error,
1060 __print_symbolic(__entry->where, afs_file_errors))
1061 );
1062
1063TRACE_EVENT(afs_cm_no_server,
1064 TP_PROTO(struct afs_call *call, struct sockaddr_rxrpc *srx),
1065
1066 TP_ARGS(call, srx),
1067
1068 TP_STRUCT__entry(
1069 __field(unsigned int, call )
1070 __field(unsigned int, op_id )
1071 __field_struct(struct sockaddr_rxrpc, srx )
1072 ),
1073
1074 TP_fast_assign(
1075 __entry->call = call->debug_id;
1076 __entry->op_id = call->operation_ID;
1077 memcpy(&__entry->srx, srx, sizeof(__entry->srx));
1078 ),
1079
1080 TP_printk("c=%08x op=%u %pISpc",
1081 __entry->call, __entry->op_id, &__entry->srx.transport)
1082 );
1083
1084TRACE_EVENT(afs_cm_no_server_u,
1085 TP_PROTO(struct afs_call *call, const uuid_t *uuid),
1086
1087 TP_ARGS(call, uuid),
1088
1089 TP_STRUCT__entry(
1090 __field(unsigned int, call )
1091 __field(unsigned int, op_id )
1092 __field_struct(uuid_t, uuid )
1093 ),
1094
1095 TP_fast_assign(
1096 __entry->call = call->debug_id;
1097 __entry->op_id = call->operation_ID;
1098 memcpy(&__entry->uuid, uuid, sizeof(__entry->uuid));
1099 ),
1100
1101 TP_printk("c=%08x op=%u %pU",
1102 __entry->call, __entry->op_id, &__entry->uuid)
1103 );
1104
1105TRACE_EVENT(afs_flock_ev,
1106 TP_PROTO(struct afs_vnode *vnode, struct file_lock *fl,
1107 enum afs_flock_event event, int error),
1108
1109 TP_ARGS(vnode, fl, event, error),
1110
1111 TP_STRUCT__entry(
1112 __field_struct(struct afs_fid, fid )
1113 __field(enum afs_flock_event, event )
1114 __field(enum afs_lock_state, state )
1115 __field(int, error )
1116 __field(unsigned int, debug_id )
1117 ),
1118
1119 TP_fast_assign(
1120 __entry->fid = vnode->fid;
1121 __entry->event = event;
1122 __entry->state = vnode->lock_state;
1123 __entry->error = error;
1124 __entry->debug_id = fl ? fl->fl_u.afs.debug_id : 0;
1125 ),
1126
1127 TP_printk("%llx:%llx:%x %04x %s s=%s e=%d",
1128 __entry->fid.vid, __entry->fid.vnode, __entry->fid.unique,
1129 __entry->debug_id,
1130 __print_symbolic(__entry->event, afs_flock_events),
1131 __print_symbolic(__entry->state, afs_flock_states),
1132 __entry->error)
1133 );
1134
1135TRACE_EVENT(afs_flock_op,
1136 TP_PROTO(struct afs_vnode *vnode, struct file_lock *fl,
1137 enum afs_flock_operation op),
1138
1139 TP_ARGS(vnode, fl, op),
1140
1141 TP_STRUCT__entry(
1142 __field_struct(struct afs_fid, fid )
1143 __field(loff_t, from )
1144 __field(loff_t, len )
1145 __field(enum afs_flock_operation, op )
1146 __field(unsigned char, type )
1147 __field(unsigned int, flags )
1148 __field(unsigned int, debug_id )
1149 ),
1150
1151 TP_fast_assign(
1152 __entry->fid = vnode->fid;
1153 __entry->from = fl->fl_start;
1154 __entry->len = fl->fl_end - fl->fl_start + 1;
1155 __entry->op = op;
1156 __entry->type = fl->fl_type;
1157 __entry->flags = fl->fl_flags;
1158 __entry->debug_id = fl->fl_u.afs.debug_id;
1159 ),
1160
1161 TP_printk("%llx:%llx:%x %04x %s t=%s R=%llx/%llx f=%x",
1162 __entry->fid.vid, __entry->fid.vnode, __entry->fid.unique,
1163 __entry->debug_id,
1164 __print_symbolic(__entry->op, afs_flock_operations),
1165 __print_symbolic(__entry->type, afs_flock_types),
1166 __entry->from, __entry->len, __entry->flags)
1167 );
1168
1169TRACE_EVENT(afs_reload_dir,
1170 TP_PROTO(struct afs_vnode *vnode),
1171
1172 TP_ARGS(vnode),
1173
1174 TP_STRUCT__entry(
1175 __field_struct(struct afs_fid, fid )
1176 ),
1177
1178 TP_fast_assign(
1179 __entry->fid = vnode->fid;
1180 ),
1181
1182 TP_printk("%llx:%llx:%x",
1183 __entry->fid.vid, __entry->fid.vnode, __entry->fid.unique)
1184 );
1185
1186TRACE_EVENT(afs_silly_rename,
1187 TP_PROTO(struct afs_vnode *vnode, bool done),
1188
1189 TP_ARGS(vnode, done),
1190
1191 TP_STRUCT__entry(
1192 __field_struct(struct afs_fid, fid )
1193 __field(bool, done )
1194 ),
1195
1196 TP_fast_assign(
1197 __entry->fid = vnode->fid;
1198 __entry->done = done;
1199 ),
1200
1201 TP_printk("%llx:%llx:%x done=%u",
1202 __entry->fid.vid, __entry->fid.vnode, __entry->fid.unique,
1203 __entry->done)
1204 );
1205
1206TRACE_EVENT(afs_get_tree,
1207 TP_PROTO(struct afs_cell *cell, struct afs_volume *volume),
1208
1209 TP_ARGS(cell, volume),
1210
1211 TP_STRUCT__entry(
1212 __field(u64, vid )
1213 __array(char, cell, 24 )
1214 __array(char, volume, 24 )
1215 ),
1216
1217 TP_fast_assign(
1218 int __len;
1219 __entry->vid = volume->vid;
1220 __len = min_t(int, cell->name_len, 23);
1221 memcpy(__entry->cell, cell->name, __len);
1222 __entry->cell[__len] = 0;
1223 __len = min_t(int, volume->name_len, 23);
1224 memcpy(__entry->volume, volume->name, __len);
1225 __entry->volume[__len] = 0;
1226 ),
1227
1228 TP_printk("--- MOUNT %s:%s %llx",
1229 __entry->cell, __entry->volume, __entry->vid)
1230 );
1231
1232TRACE_EVENT(afs_cb_break,
1233 TP_PROTO(struct afs_fid *fid, unsigned int cb_break,
1234 enum afs_cb_break_reason reason, bool skipped),
1235
1236 TP_ARGS(fid, cb_break, reason, skipped),
1237
1238 TP_STRUCT__entry(
1239 __field_struct(struct afs_fid, fid )
1240 __field(unsigned int, cb_break )
1241 __field(enum afs_cb_break_reason, reason )
1242 __field(bool, skipped )
1243 ),
1244
1245 TP_fast_assign(
1246 __entry->fid = *fid;
1247 __entry->cb_break = cb_break;
1248 __entry->reason = reason;
1249 __entry->skipped = skipped;
1250 ),
1251
1252 TP_printk("%llx:%llx:%x b=%x s=%u %s",
1253 __entry->fid.vid, __entry->fid.vnode, __entry->fid.unique,
1254 __entry->cb_break,
1255 __entry->skipped,
1256 __print_symbolic(__entry->reason, afs_cb_break_reasons))
1257 );
1258
1259TRACE_EVENT(afs_cb_miss,
1260 TP_PROTO(struct afs_fid *fid, enum afs_cb_break_reason reason),
1261
1262 TP_ARGS(fid, reason),
1263
1264 TP_STRUCT__entry(
1265 __field_struct(struct afs_fid, fid )
1266 __field(enum afs_cb_break_reason, reason )
1267 ),
1268
1269 TP_fast_assign(
1270 __entry->fid = *fid;
1271 __entry->reason = reason;
1272 ),
1273
1274 TP_printk(" %llx:%llx:%x %s",
1275 __entry->fid.vid, __entry->fid.vnode, __entry->fid.unique,
1276 __print_symbolic(__entry->reason, afs_cb_break_reasons))
1277 );
1278
1279TRACE_EVENT(afs_server,
1280 TP_PROTO(struct afs_server *server, int usage, enum afs_server_trace reason),
1281
1282 TP_ARGS(server, usage, reason),
1283
1284 TP_STRUCT__entry(
1285 __field(unsigned int, server )
1286 __field(int, usage )
1287 __field(int, reason )
1288 ),
1289
1290 TP_fast_assign(
1291 __entry->server = server->debug_id;
1292 __entry->usage = usage;
1293 __entry->reason = reason;
1294 ),
1295
1296 TP_printk("s=%08x %s u=%d",
1297 __entry->server,
1298 __print_symbolic(__entry->reason, afs_server_traces),
1299 __entry->usage)
1300 );
1301
1302#endif /* _TRACE_AFS_H */
1303
1304/* This part must be outside protection */
1305#include <trace/define_trace.h>
1/* SPDX-License-Identifier: GPL-2.0-or-later */
2/* AFS tracepoints
3 *
4 * Copyright (C) 2016 Red Hat, Inc. All Rights Reserved.
5 * Written by David Howells (dhowells@redhat.com)
6 */
7#undef TRACE_SYSTEM
8#define TRACE_SYSTEM afs
9
10#if !defined(_TRACE_AFS_H) || defined(TRACE_HEADER_MULTI_READ)
11#define _TRACE_AFS_H
12
13#include <linux/tracepoint.h>
14
15/*
16 * Define enums for tracing information.
17 */
18#ifndef __AFS_DECLARE_TRACE_ENUMS_ONCE_ONLY
19#define __AFS_DECLARE_TRACE_ENUMS_ONCE_ONLY
20
21enum afs_fs_operation {
22 afs_FS_FetchData = 130, /* AFS Fetch file data */
23 afs_FS_FetchACL = 131, /* AFS Fetch file ACL */
24 afs_FS_FetchStatus = 132, /* AFS Fetch file status */
25 afs_FS_StoreData = 133, /* AFS Store file data */
26 afs_FS_StoreACL = 134, /* AFS Store file ACL */
27 afs_FS_StoreStatus = 135, /* AFS Store file status */
28 afs_FS_RemoveFile = 136, /* AFS Remove a file */
29 afs_FS_CreateFile = 137, /* AFS Create a file */
30 afs_FS_Rename = 138, /* AFS Rename or move a file or directory */
31 afs_FS_Symlink = 139, /* AFS Create a symbolic link */
32 afs_FS_Link = 140, /* AFS Create a hard link */
33 afs_FS_MakeDir = 141, /* AFS Create a directory */
34 afs_FS_RemoveDir = 142, /* AFS Remove a directory */
35 afs_FS_GetVolumeInfo = 148, /* AFS Get information about a volume */
36 afs_FS_GetVolumeStatus = 149, /* AFS Get volume status information */
37 afs_FS_GetRootVolume = 151, /* AFS Get root volume name */
38 afs_FS_SetLock = 156, /* AFS Request a file lock */
39 afs_FS_ExtendLock = 157, /* AFS Extend a file lock */
40 afs_FS_ReleaseLock = 158, /* AFS Release a file lock */
41 afs_FS_Lookup = 161, /* AFS lookup file in directory */
42 afs_FS_InlineBulkStatus = 65536, /* AFS Fetch multiple file statuses with errors */
43 afs_FS_FetchData64 = 65537, /* AFS Fetch file data */
44 afs_FS_StoreData64 = 65538, /* AFS Store file data */
45 afs_FS_GiveUpAllCallBacks = 65539, /* AFS Give up all our callbacks on a server */
46 afs_FS_GetCapabilities = 65540, /* AFS Get FS server capabilities */
47
48 yfs_FS_FetchData = 130, /* YFS Fetch file data */
49 yfs_FS_FetchACL = 64131, /* YFS Fetch file ACL */
50 yfs_FS_FetchStatus = 64132, /* YFS Fetch file status */
51 yfs_FS_StoreACL = 64134, /* YFS Store file ACL */
52 yfs_FS_StoreStatus = 64135, /* YFS Store file status */
53 yfs_FS_RemoveFile = 64136, /* YFS Remove a file */
54 yfs_FS_CreateFile = 64137, /* YFS Create a file */
55 yfs_FS_Rename = 64138, /* YFS Rename or move a file or directory */
56 yfs_FS_Symlink = 64139, /* YFS Create a symbolic link */
57 yfs_FS_Link = 64140, /* YFS Create a hard link */
58 yfs_FS_MakeDir = 64141, /* YFS Create a directory */
59 yfs_FS_RemoveDir = 64142, /* YFS Remove a directory */
60 yfs_FS_GetVolumeStatus = 64149, /* YFS Get volume status information */
61 yfs_FS_SetVolumeStatus = 64150, /* YFS Set volume status information */
62 yfs_FS_SetLock = 64156, /* YFS Request a file lock */
63 yfs_FS_ExtendLock = 64157, /* YFS Extend a file lock */
64 yfs_FS_ReleaseLock = 64158, /* YFS Release a file lock */
65 yfs_FS_Lookup = 64161, /* YFS lookup file in directory */
66 yfs_FS_FlushCPS = 64165,
67 yfs_FS_FetchOpaqueACL = 64168,
68 yfs_FS_WhoAmI = 64170,
69 yfs_FS_RemoveACL = 64171,
70 yfs_FS_RemoveFile2 = 64173,
71 yfs_FS_StoreOpaqueACL2 = 64174,
72 yfs_FS_InlineBulkStatus = 64536, /* YFS Fetch multiple file statuses with errors */
73 yfs_FS_FetchData64 = 64537, /* YFS Fetch file data */
74 yfs_FS_StoreData64 = 64538, /* YFS Store file data */
75 yfs_FS_UpdateSymlink = 64540,
76};
77
78enum afs_vl_operation {
79 afs_VL_GetEntryByNameU = 527, /* AFS Get Vol Entry By Name operation ID */
80 afs_VL_GetAddrsU = 533, /* AFS Get FS server addresses */
81 afs_YFSVL_GetEndpoints = 64002, /* YFS Get FS & Vol server addresses */
82 afs_YFSVL_GetCellName = 64014, /* YFS Get actual cell name */
83 afs_VL_GetCapabilities = 65537, /* AFS Get VL server capabilities */
84};
85
86enum afs_cm_operation {
87 afs_CB_CallBack = 204, /* AFS break callback promises */
88 afs_CB_InitCallBackState = 205, /* AFS initialise callback state */
89 afs_CB_Probe = 206, /* AFS probe client */
90 afs_CB_GetLock = 207, /* AFS get contents of CM lock table */
91 afs_CB_GetCE = 208, /* AFS get cache file description */
92 afs_CB_GetXStatsVersion = 209, /* AFS get version of extended statistics */
93 afs_CB_GetXStats = 210, /* AFS get contents of extended statistics data */
94 afs_CB_InitCallBackState3 = 213, /* AFS initialise callback state, version 3 */
95 afs_CB_ProbeUuid = 214, /* AFS check the client hasn't rebooted */
96};
97
98enum yfs_cm_operation {
99 yfs_CB_Probe = 206, /* YFS probe client */
100 yfs_CB_GetLock = 207, /* YFS get contents of CM lock table */
101 yfs_CB_XStatsVersion = 209, /* YFS get version of extended statistics */
102 yfs_CB_GetXStats = 210, /* YFS get contents of extended statistics data */
103 yfs_CB_InitCallBackState3 = 213, /* YFS initialise callback state, version 3 */
104 yfs_CB_ProbeUuid = 214, /* YFS check the client hasn't rebooted */
105 yfs_CB_GetServerPrefs = 215,
106 yfs_CB_GetCellServDV = 216,
107 yfs_CB_GetLocalCell = 217,
108 yfs_CB_GetCacheConfig = 218,
109 yfs_CB_GetCellByNum = 65537,
110 yfs_CB_TellMeAboutYourself = 65538, /* get client capabilities */
111 yfs_CB_CallBack = 64204,
112};
113
114#endif /* end __AFS_DECLARE_TRACE_ENUMS_ONCE_ONLY */
115
116/*
117 * Declare tracing information enums and their string mappings for display.
118 */
119#define afs_call_traces \
120 EM(afs_call_trace_alloc, "ALLOC") \
121 EM(afs_call_trace_free, "FREE ") \
122 EM(afs_call_trace_get, "GET ") \
123 EM(afs_call_trace_put, "PUT ") \
124 EM(afs_call_trace_wake, "WAKE ") \
125 E_(afs_call_trace_work, "QUEUE")
126
127#define afs_server_traces \
128 EM(afs_server_trace_alloc, "ALLOC ") \
129 EM(afs_server_trace_callback, "CALLBACK ") \
130 EM(afs_server_trace_destroy, "DESTROY ") \
131 EM(afs_server_trace_free, "FREE ") \
132 EM(afs_server_trace_gc, "GC ") \
133 EM(afs_server_trace_get_by_addr, "GET addr ") \
134 EM(afs_server_trace_get_by_uuid, "GET uuid ") \
135 EM(afs_server_trace_get_caps, "GET caps ") \
136 EM(afs_server_trace_get_install, "GET inst ") \
137 EM(afs_server_trace_get_new_cbi, "GET cbi ") \
138 EM(afs_server_trace_get_probe, "GET probe") \
139 EM(afs_server_trace_give_up_cb, "giveup-cb") \
140 EM(afs_server_trace_purging, "PURGE ") \
141 EM(afs_server_trace_put_call, "PUT call ") \
142 EM(afs_server_trace_put_cbi, "PUT cbi ") \
143 EM(afs_server_trace_put_find_rsq, "PUT f-rsq") \
144 EM(afs_server_trace_put_probe, "PUT probe") \
145 EM(afs_server_trace_put_slist, "PUT slist") \
146 EM(afs_server_trace_put_slist_isort, "PUT isort") \
147 EM(afs_server_trace_put_uuid_rsq, "PUT u-req") \
148 E_(afs_server_trace_update, "UPDATE")
149
150#define afs_volume_traces \
151 EM(afs_volume_trace_alloc, "ALLOC ") \
152 EM(afs_volume_trace_free, "FREE ") \
153 EM(afs_volume_trace_get_alloc_sbi, "GET sbi-alloc ") \
154 EM(afs_volume_trace_get_callback, "GET callback ") \
155 EM(afs_volume_trace_get_cell_insert, "GET cell-insrt") \
156 EM(afs_volume_trace_get_new_op, "GET op-new ") \
157 EM(afs_volume_trace_get_query_alias, "GET cell-alias") \
158 EM(afs_volume_trace_put_callback, "PUT callback ") \
159 EM(afs_volume_trace_put_cell_dup, "PUT cell-dup ") \
160 EM(afs_volume_trace_put_cell_root, "PUT cell-root ") \
161 EM(afs_volume_trace_put_destroy_sbi, "PUT sbi-destry") \
162 EM(afs_volume_trace_put_free_fc, "PUT fc-free ") \
163 EM(afs_volume_trace_put_put_op, "PUT op-put ") \
164 EM(afs_volume_trace_put_query_alias, "PUT cell-alias") \
165 EM(afs_volume_trace_put_validate_fc, "PUT fc-validat") \
166 E_(afs_volume_trace_remove, "REMOVE ")
167
168#define afs_cell_traces \
169 EM(afs_cell_trace_alloc, "ALLOC ") \
170 EM(afs_cell_trace_free, "FREE ") \
171 EM(afs_cell_trace_get_queue_dns, "GET q-dns ") \
172 EM(afs_cell_trace_get_queue_manage, "GET q-mng ") \
173 EM(afs_cell_trace_get_queue_new, "GET q-new ") \
174 EM(afs_cell_trace_get_vol, "GET vol ") \
175 EM(afs_cell_trace_insert, "INSERT ") \
176 EM(afs_cell_trace_manage, "MANAGE ") \
177 EM(afs_cell_trace_put_candidate, "PUT candid") \
178 EM(afs_cell_trace_put_destroy, "PUT destry") \
179 EM(afs_cell_trace_put_queue_work, "PUT q-work") \
180 EM(afs_cell_trace_put_queue_fail, "PUT q-fail") \
181 EM(afs_cell_trace_put_vol, "PUT vol ") \
182 EM(afs_cell_trace_see_source, "SEE source") \
183 EM(afs_cell_trace_see_ws, "SEE ws ") \
184 EM(afs_cell_trace_unuse_alias, "UNU alias ") \
185 EM(afs_cell_trace_unuse_check_alias, "UNU chk-al") \
186 EM(afs_cell_trace_unuse_delete, "UNU delete") \
187 EM(afs_cell_trace_unuse_fc, "UNU fc ") \
188 EM(afs_cell_trace_unuse_lookup, "UNU lookup") \
189 EM(afs_cell_trace_unuse_mntpt, "UNU mntpt ") \
190 EM(afs_cell_trace_unuse_no_pin, "UNU no-pin") \
191 EM(afs_cell_trace_unuse_parse, "UNU parse ") \
192 EM(afs_cell_trace_unuse_pin, "UNU pin ") \
193 EM(afs_cell_trace_unuse_probe, "UNU probe ") \
194 EM(afs_cell_trace_unuse_sbi, "UNU sbi ") \
195 EM(afs_cell_trace_unuse_ws, "UNU ws ") \
196 EM(afs_cell_trace_use_alias, "USE alias ") \
197 EM(afs_cell_trace_use_check_alias, "USE chk-al") \
198 EM(afs_cell_trace_use_fc, "USE fc ") \
199 EM(afs_cell_trace_use_fc_alias, "USE fc-al ") \
200 EM(afs_cell_trace_use_lookup, "USE lookup") \
201 EM(afs_cell_trace_use_mntpt, "USE mntpt ") \
202 EM(afs_cell_trace_use_pin, "USE pin ") \
203 EM(afs_cell_trace_use_probe, "USE probe ") \
204 EM(afs_cell_trace_use_sbi, "USE sbi ") \
205 E_(afs_cell_trace_wait, "WAIT ")
206
207#define afs_alist_traces \
208 EM(afs_alist_trace_alloc, "ALLOC ") \
209 EM(afs_alist_trace_get_estate, "GET estate") \
210 EM(afs_alist_trace_get_vlgetcaps, "GET vgtcap") \
211 EM(afs_alist_trace_get_vlprobe, "GET vprobe") \
212 EM(afs_alist_trace_get_vlrotate_set, "GET vl-rot") \
213 EM(afs_alist_trace_put_estate, "PUT estate") \
214 EM(afs_alist_trace_put_getaddru, "PUT GtAdrU") \
215 EM(afs_alist_trace_put_parse_empty, "PUT p-empt") \
216 EM(afs_alist_trace_put_parse_error, "PUT p-err ") \
217 EM(afs_alist_trace_put_server_dup, "PUT sv-dup") \
218 EM(afs_alist_trace_put_server_oom, "PUT sv-oom") \
219 EM(afs_alist_trace_put_server_update, "PUT sv-upd") \
220 EM(afs_alist_trace_put_vlgetcaps, "PUT vgtcap") \
221 EM(afs_alist_trace_put_vlprobe, "PUT vprobe") \
222 EM(afs_alist_trace_put_vlrotate_end, "PUT vr-end") \
223 EM(afs_alist_trace_put_vlrotate_fail, "PUT vr-fai") \
224 EM(afs_alist_trace_put_vlrotate_next, "PUT vr-nxt") \
225 EM(afs_alist_trace_put_vlrotate_restart,"PUT vr-rst") \
226 EM(afs_alist_trace_put_vlserver, "PUT vlsrvr") \
227 EM(afs_alist_trace_put_vlserver_old, "PUT vs-old") \
228 E_(afs_alist_trace_free, "FREE ")
229
230#define afs_estate_traces \
231 EM(afs_estate_trace_alloc_probe, "ALLOC prob") \
232 EM(afs_estate_trace_alloc_server, "ALLOC srvr") \
233 EM(afs_estate_trace_get_server_state, "GET srv-st") \
234 EM(afs_estate_trace_get_getcaps, "GET getcap") \
235 EM(afs_estate_trace_put_getcaps, "PUT getcap") \
236 EM(afs_estate_trace_put_probe, "PUT probe ") \
237 EM(afs_estate_trace_put_server, "PUT server") \
238 EM(afs_estate_trace_put_server_state, "PUT srv-st") \
239 E_(afs_estate_trace_free, "FREE ")
240
241#define afs_fs_operations \
242 EM(afs_FS_FetchData, "FS.FetchData") \
243 EM(afs_FS_FetchStatus, "FS.FetchStatus") \
244 EM(afs_FS_StoreData, "FS.StoreData") \
245 EM(afs_FS_StoreStatus, "FS.StoreStatus") \
246 EM(afs_FS_RemoveFile, "FS.RemoveFile") \
247 EM(afs_FS_CreateFile, "FS.CreateFile") \
248 EM(afs_FS_Rename, "FS.Rename") \
249 EM(afs_FS_Symlink, "FS.Symlink") \
250 EM(afs_FS_Link, "FS.Link") \
251 EM(afs_FS_MakeDir, "FS.MakeDir") \
252 EM(afs_FS_RemoveDir, "FS.RemoveDir") \
253 EM(afs_FS_GetVolumeInfo, "FS.GetVolumeInfo") \
254 EM(afs_FS_GetVolumeStatus, "FS.GetVolumeStatus") \
255 EM(afs_FS_GetRootVolume, "FS.GetRootVolume") \
256 EM(afs_FS_SetLock, "FS.SetLock") \
257 EM(afs_FS_ExtendLock, "FS.ExtendLock") \
258 EM(afs_FS_ReleaseLock, "FS.ReleaseLock") \
259 EM(afs_FS_Lookup, "FS.Lookup") \
260 EM(afs_FS_InlineBulkStatus, "FS.InlineBulkStatus") \
261 EM(afs_FS_FetchData64, "FS.FetchData64") \
262 EM(afs_FS_StoreData64, "FS.StoreData64") \
263 EM(afs_FS_GiveUpAllCallBacks, "FS.GiveUpAllCallBacks") \
264 EM(afs_FS_GetCapabilities, "FS.GetCapabilities") \
265 EM(yfs_FS_FetchACL, "YFS.FetchACL") \
266 EM(yfs_FS_FetchStatus, "YFS.FetchStatus") \
267 EM(yfs_FS_StoreACL, "YFS.StoreACL") \
268 EM(yfs_FS_StoreStatus, "YFS.StoreStatus") \
269 EM(yfs_FS_RemoveFile, "YFS.RemoveFile") \
270 EM(yfs_FS_CreateFile, "YFS.CreateFile") \
271 EM(yfs_FS_Rename, "YFS.Rename") \
272 EM(yfs_FS_Symlink, "YFS.Symlink") \
273 EM(yfs_FS_Link, "YFS.Link") \
274 EM(yfs_FS_MakeDir, "YFS.MakeDir") \
275 EM(yfs_FS_RemoveDir, "YFS.RemoveDir") \
276 EM(yfs_FS_GetVolumeStatus, "YFS.GetVolumeStatus") \
277 EM(yfs_FS_SetVolumeStatus, "YFS.SetVolumeStatus") \
278 EM(yfs_FS_SetLock, "YFS.SetLock") \
279 EM(yfs_FS_ExtendLock, "YFS.ExtendLock") \
280 EM(yfs_FS_ReleaseLock, "YFS.ReleaseLock") \
281 EM(yfs_FS_Lookup, "YFS.Lookup") \
282 EM(yfs_FS_FlushCPS, "YFS.FlushCPS") \
283 EM(yfs_FS_FetchOpaqueACL, "YFS.FetchOpaqueACL") \
284 EM(yfs_FS_WhoAmI, "YFS.WhoAmI") \
285 EM(yfs_FS_RemoveACL, "YFS.RemoveACL") \
286 EM(yfs_FS_RemoveFile2, "YFS.RemoveFile2") \
287 EM(yfs_FS_StoreOpaqueACL2, "YFS.StoreOpaqueACL2") \
288 EM(yfs_FS_InlineBulkStatus, "YFS.InlineBulkStatus") \
289 EM(yfs_FS_FetchData64, "YFS.FetchData64") \
290 EM(yfs_FS_StoreData64, "YFS.StoreData64") \
291 E_(yfs_FS_UpdateSymlink, "YFS.UpdateSymlink")
292
293#define afs_vl_operations \
294 EM(afs_VL_GetEntryByNameU, "VL.GetEntryByNameU") \
295 EM(afs_VL_GetAddrsU, "VL.GetAddrsU") \
296 EM(afs_YFSVL_GetEndpoints, "YFSVL.GetEndpoints") \
297 EM(afs_YFSVL_GetCellName, "YFSVL.GetCellName") \
298 E_(afs_VL_GetCapabilities, "VL.GetCapabilities")
299
300#define afs_cm_operations \
301 EM(afs_CB_CallBack, "CB.CallBack") \
302 EM(afs_CB_InitCallBackState, "CB.InitCallBackState") \
303 EM(afs_CB_Probe, "CB.Probe") \
304 EM(afs_CB_GetLock, "CB.GetLock") \
305 EM(afs_CB_GetCE, "CB.GetCE") \
306 EM(afs_CB_GetXStatsVersion, "CB.GetXStatsVersion") \
307 EM(afs_CB_GetXStats, "CB.GetXStats") \
308 EM(afs_CB_InitCallBackState3, "CB.InitCallBackState3") \
309 E_(afs_CB_ProbeUuid, "CB.ProbeUuid")
310
311#define yfs_cm_operations \
312 EM(yfs_CB_Probe, "YFSCB.Probe") \
313 EM(yfs_CB_GetLock, "YFSCB.GetLock") \
314 EM(yfs_CB_XStatsVersion, "YFSCB.XStatsVersion") \
315 EM(yfs_CB_GetXStats, "YFSCB.GetXStats") \
316 EM(yfs_CB_InitCallBackState3, "YFSCB.InitCallBackState3") \
317 EM(yfs_CB_ProbeUuid, "YFSCB.ProbeUuid") \
318 EM(yfs_CB_GetServerPrefs, "YFSCB.GetServerPrefs") \
319 EM(yfs_CB_GetCellServDV, "YFSCB.GetCellServDV") \
320 EM(yfs_CB_GetLocalCell, "YFSCB.GetLocalCell") \
321 EM(yfs_CB_GetCacheConfig, "YFSCB.GetCacheConfig") \
322 EM(yfs_CB_GetCellByNum, "YFSCB.GetCellByNum") \
323 EM(yfs_CB_TellMeAboutYourself, "YFSCB.TellMeAboutYourself") \
324 E_(yfs_CB_CallBack, "YFSCB.CallBack")
325
326#define afs_edit_dir_ops \
327 EM(afs_edit_dir_create, "create") \
328 EM(afs_edit_dir_create_error, "c_fail") \
329 EM(afs_edit_dir_create_inval, "c_invl") \
330 EM(afs_edit_dir_create_nospc, "c_nspc") \
331 EM(afs_edit_dir_delete, "delete") \
332 EM(afs_edit_dir_delete_error, "d_err ") \
333 EM(afs_edit_dir_delete_inval, "d_invl") \
334 E_(afs_edit_dir_delete_noent, "d_nent")
335
336#define afs_edit_dir_reasons \
337 EM(afs_edit_dir_for_create, "Create") \
338 EM(afs_edit_dir_for_link, "Link ") \
339 EM(afs_edit_dir_for_mkdir, "MkDir ") \
340 EM(afs_edit_dir_for_rename_0, "Renam0") \
341 EM(afs_edit_dir_for_rename_1, "Renam1") \
342 EM(afs_edit_dir_for_rename_2, "Renam2") \
343 EM(afs_edit_dir_for_rmdir, "RmDir ") \
344 EM(afs_edit_dir_for_silly_0, "S_Ren0") \
345 EM(afs_edit_dir_for_silly_1, "S_Ren1") \
346 EM(afs_edit_dir_for_symlink, "Symlnk") \
347 E_(afs_edit_dir_for_unlink, "Unlink")
348
349#define afs_eproto_causes \
350 EM(afs_eproto_bad_status, "BadStatus") \
351 EM(afs_eproto_cb_count, "CbCount") \
352 EM(afs_eproto_cb_fid_count, "CbFidCount") \
353 EM(afs_eproto_cellname_len, "CellNameLen") \
354 EM(afs_eproto_file_type, "FileTYpe") \
355 EM(afs_eproto_ibulkst_cb_count, "IBS.CbCount") \
356 EM(afs_eproto_ibulkst_count, "IBS.FidCount") \
357 EM(afs_eproto_motd_len, "MotdLen") \
358 EM(afs_eproto_offline_msg_len, "OfflineMsgLen") \
359 EM(afs_eproto_volname_len, "VolNameLen") \
360 EM(afs_eproto_yvl_fsendpt4_len, "YVL.FsEnd4Len") \
361 EM(afs_eproto_yvl_fsendpt6_len, "YVL.FsEnd6Len") \
362 EM(afs_eproto_yvl_fsendpt_num, "YVL.FsEndCount") \
363 EM(afs_eproto_yvl_fsendpt_type, "YVL.FsEndType") \
364 EM(afs_eproto_yvl_vlendpt4_len, "YVL.VlEnd4Len") \
365 EM(afs_eproto_yvl_vlendpt6_len, "YVL.VlEnd6Len") \
366 E_(afs_eproto_yvl_vlendpt_type, "YVL.VlEndType")
367
368#define afs_io_errors \
369 EM(afs_io_error_cm_reply, "CM_REPLY") \
370 EM(afs_io_error_extract, "EXTRACT") \
371 EM(afs_io_error_fs_probe_fail, "FS_PROBE_FAIL") \
372 EM(afs_io_error_vl_lookup_fail, "VL_LOOKUP_FAIL") \
373 E_(afs_io_error_vl_probe_fail, "VL_PROBE_FAIL")
374
375#define afs_file_errors \
376 EM(afs_file_error_dir_bad_magic, "DIR_BAD_MAGIC") \
377 EM(afs_file_error_dir_big, "DIR_BIG") \
378 EM(afs_file_error_dir_missing_page, "DIR_MISSING_PAGE") \
379 EM(afs_file_error_dir_name_too_long, "DIR_NAME_TOO_LONG") \
380 EM(afs_file_error_dir_over_end, "DIR_ENT_OVER_END") \
381 EM(afs_file_error_dir_small, "DIR_SMALL") \
382 EM(afs_file_error_dir_unmarked_ext, "DIR_UNMARKED_EXT") \
383 EM(afs_file_error_mntpt, "MNTPT_READ_FAILED") \
384 E_(afs_file_error_writeback_fail, "WRITEBACK_FAILED")
385
386#define afs_flock_types \
387 EM(F_RDLCK, "RDLCK") \
388 EM(F_WRLCK, "WRLCK") \
389 E_(F_UNLCK, "UNLCK")
390
391#define afs_flock_states \
392 EM(AFS_VNODE_LOCK_NONE, "NONE") \
393 EM(AFS_VNODE_LOCK_WAITING_FOR_CB, "WAIT_FOR_CB") \
394 EM(AFS_VNODE_LOCK_SETTING, "SETTING") \
395 EM(AFS_VNODE_LOCK_GRANTED, "GRANTED") \
396 EM(AFS_VNODE_LOCK_EXTENDING, "EXTENDING") \
397 EM(AFS_VNODE_LOCK_NEED_UNLOCK, "NEED_UNLOCK") \
398 EM(AFS_VNODE_LOCK_UNLOCKING, "UNLOCKING") \
399 E_(AFS_VNODE_LOCK_DELETED, "DELETED")
400
401#define afs_flock_events \
402 EM(afs_flock_acquired, "Acquired") \
403 EM(afs_flock_callback_break, "Callback") \
404 EM(afs_flock_defer_unlock, "D-Unlock") \
405 EM(afs_flock_extend_fail, "Ext_Fail") \
406 EM(afs_flock_fail_other, "ErrOther") \
407 EM(afs_flock_fail_perm, "ErrPerm ") \
408 EM(afs_flock_no_lockers, "NoLocker") \
409 EM(afs_flock_release_fail, "Rel_Fail") \
410 EM(afs_flock_silly_delete, "SillyDel") \
411 EM(afs_flock_timestamp, "Timestmp") \
412 EM(afs_flock_try_to_lock, "TryToLck") \
413 EM(afs_flock_vfs_lock, "VFSLock ") \
414 EM(afs_flock_vfs_locking, "VFSLking") \
415 EM(afs_flock_waited, "Waited ") \
416 EM(afs_flock_waiting, "Waiting ") \
417 EM(afs_flock_work_extending, "Extendng") \
418 EM(afs_flock_work_retry, "Retry ") \
419 EM(afs_flock_work_unlocking, "Unlcking") \
420 E_(afs_flock_would_block, "EWOULDBL")
421
422#define afs_flock_operations \
423 EM(afs_flock_op_copy_lock, "COPY ") \
424 EM(afs_flock_op_flock, "->flock ") \
425 EM(afs_flock_op_grant, "GRANT ") \
426 EM(afs_flock_op_lock, "->lock ") \
427 EM(afs_flock_op_release_lock, "RELEASE ") \
428 EM(afs_flock_op_return_ok, "<-OK ") \
429 EM(afs_flock_op_return_edeadlk, "<-EDEADL") \
430 EM(afs_flock_op_return_eagain, "<-EAGAIN") \
431 EM(afs_flock_op_return_error, "<-ERROR ") \
432 EM(afs_flock_op_set_lock, "SET ") \
433 EM(afs_flock_op_unlock, "UNLOCK ") \
434 E_(afs_flock_op_wake, "WAKE ")
435
436#define afs_cb_break_reasons \
437 EM(afs_cb_break_no_break, "no-break") \
438 EM(afs_cb_break_for_callback, "break-cb") \
439 EM(afs_cb_break_for_creation_regress, "creation-regress") \
440 EM(afs_cb_break_for_deleted, "break-del") \
441 EM(afs_cb_break_for_s_reinit, "s-reinit") \
442 EM(afs_cb_break_for_unlink, "break-unlink") \
443 EM(afs_cb_break_for_update_regress, "update-regress") \
444 EM(afs_cb_break_for_volume_callback, "break-v-cb") \
445 EM(afs_cb_break_for_vos_release, "break-vos-release") \
446 E_(afs_cb_break_volume_excluded, "vol-excluded")
447
448#define afs_rotate_traces \
449 EM(afs_rotate_trace_aborted, "Abortd") \
450 EM(afs_rotate_trace_busy_sleep, "BsySlp") \
451 EM(afs_rotate_trace_check_vol_status, "VolStt") \
452 EM(afs_rotate_trace_failed, "Failed") \
453 EM(afs_rotate_trace_iter, "Iter ") \
454 EM(afs_rotate_trace_iterate_addr, "ItAddr") \
455 EM(afs_rotate_trace_next_server, "NextSv") \
456 EM(afs_rotate_trace_no_more_servers, "NoMore") \
457 EM(afs_rotate_trace_nomem, "Nomem ") \
458 EM(afs_rotate_trace_probe_error, "PrbErr") \
459 EM(afs_rotate_trace_probe_fileserver, "PrbFsv") \
460 EM(afs_rotate_trace_probe_none, "PrbNon") \
461 EM(afs_rotate_trace_probe_response, "PrbRsp") \
462 EM(afs_rotate_trace_probe_superseded, "PrbSup") \
463 EM(afs_rotate_trace_restart, "Rstart") \
464 EM(afs_rotate_trace_retry_server, "RtrySv") \
465 EM(afs_rotate_trace_selected_server, "SlctSv") \
466 EM(afs_rotate_trace_stale_lock, "StlLck") \
467 EM(afs_rotate_trace_start, "Start ") \
468 EM(afs_rotate_trace_stop, "Stop ") \
469 E_(afs_rotate_trace_stopped, "Stoppd")
470
471/*
472 * Generate enums for tracing information.
473 */
474#ifndef __AFS_GENERATE_TRACE_ENUMS_ONCE_ONLY
475#define __AFS_GENERATE_TRACE_ENUMS_ONCE_ONLY
476
477#undef EM
478#undef E_
479#define EM(a, b) a,
480#define E_(a, b) a
481
482enum afs_alist_trace { afs_alist_traces } __mode(byte);
483enum afs_call_trace { afs_call_traces } __mode(byte);
484enum afs_cb_break_reason { afs_cb_break_reasons } __mode(byte);
485enum afs_cell_trace { afs_cell_traces } __mode(byte);
486enum afs_edit_dir_op { afs_edit_dir_ops } __mode(byte);
487enum afs_edit_dir_reason { afs_edit_dir_reasons } __mode(byte);
488enum afs_eproto_cause { afs_eproto_causes } __mode(byte);
489enum afs_estate_trace { afs_estate_traces } __mode(byte);
490enum afs_file_error { afs_file_errors } __mode(byte);
491enum afs_flock_event { afs_flock_events } __mode(byte);
492enum afs_flock_operation { afs_flock_operations } __mode(byte);
493enum afs_io_error { afs_io_errors } __mode(byte);
494enum afs_rotate_trace { afs_rotate_traces } __mode(byte);
495enum afs_server_trace { afs_server_traces } __mode(byte);
496enum afs_volume_trace { afs_volume_traces } __mode(byte);
497
498#endif /* end __AFS_GENERATE_TRACE_ENUMS_ONCE_ONLY */
499
500/*
501 * Export enum symbols via userspace.
502 */
503#undef EM
504#undef E_
505#define EM(a, b) TRACE_DEFINE_ENUM(a);
506#define E_(a, b) TRACE_DEFINE_ENUM(a);
507
508afs_alist_traces;
509afs_call_traces;
510afs_cb_break_reasons;
511afs_cell_traces;
512afs_cm_operations;
513afs_edit_dir_ops;
514afs_edit_dir_reasons;
515afs_eproto_causes;
516afs_estate_traces;
517afs_file_errors;
518afs_flock_operations;
519afs_flock_types;
520afs_fs_operations;
521afs_io_errors;
522afs_rotate_traces;
523afs_server_traces;
524afs_vl_operations;
525yfs_cm_operations;
526
527/*
528 * Now redefine the EM() and E_() macros to map the enums to the strings that
529 * will be printed in the output.
530 */
531#undef EM
532#undef E_
533#define EM(a, b) { a, b },
534#define E_(a, b) { a, b }
535
536TRACE_EVENT(afs_receive_data,
537 TP_PROTO(struct afs_call *call, struct iov_iter *iter,
538 bool want_more, int ret),
539
540 TP_ARGS(call, iter, want_more, ret),
541
542 TP_STRUCT__entry(
543 __field(loff_t, remain)
544 __field(unsigned int, call)
545 __field(enum afs_call_state, state)
546 __field(unsigned short, unmarshall)
547 __field(bool, want_more)
548 __field(int, ret)
549 ),
550
551 TP_fast_assign(
552 __entry->call = call->debug_id;
553 __entry->state = call->state;
554 __entry->unmarshall = call->unmarshall;
555 __entry->remain = iov_iter_count(iter);
556 __entry->want_more = want_more;
557 __entry->ret = ret;
558 ),
559
560 TP_printk("c=%08x r=%llu u=%u w=%u s=%u ret=%d",
561 __entry->call,
562 __entry->remain,
563 __entry->unmarshall,
564 __entry->want_more,
565 __entry->state,
566 __entry->ret)
567 );
568
569TRACE_EVENT(afs_notify_call,
570 TP_PROTO(struct rxrpc_call *rxcall, struct afs_call *call),
571
572 TP_ARGS(rxcall, call),
573
574 TP_STRUCT__entry(
575 __field(unsigned int, call)
576 __field(enum afs_call_state, state)
577 __field(unsigned short, unmarshall)
578 ),
579
580 TP_fast_assign(
581 __entry->call = call->debug_id;
582 __entry->state = call->state;
583 __entry->unmarshall = call->unmarshall;
584 ),
585
586 TP_printk("c=%08x s=%u u=%u",
587 __entry->call,
588 __entry->state, __entry->unmarshall)
589 );
590
591TRACE_EVENT(afs_cb_call,
592 TP_PROTO(struct afs_call *call),
593
594 TP_ARGS(call),
595
596 TP_STRUCT__entry(
597 __field(unsigned int, call)
598 __field(u32, op)
599 __field(u16, service_id)
600 ),
601
602 TP_fast_assign(
603 __entry->call = call->debug_id;
604 __entry->op = call->operation_ID;
605 __entry->service_id = call->service_id;
606 ),
607
608 TP_printk("c=%08x %s",
609 __entry->call,
610 __entry->service_id == 2501 ?
611 __print_symbolic(__entry->op, yfs_cm_operations) :
612 __print_symbolic(__entry->op, afs_cm_operations))
613 );
614
615TRACE_EVENT(afs_call,
616 TP_PROTO(unsigned int call_debug_id, enum afs_call_trace op,
617 int ref, int outstanding, const void *where),
618
619 TP_ARGS(call_debug_id, op, ref, outstanding, where),
620
621 TP_STRUCT__entry(
622 __field(unsigned int, call)
623 __field(int, op)
624 __field(int, ref)
625 __field(int, outstanding)
626 __field(const void *, where)
627 ),
628
629 TP_fast_assign(
630 __entry->call = call_debug_id;
631 __entry->op = op;
632 __entry->ref = ref;
633 __entry->outstanding = outstanding;
634 __entry->where = where;
635 ),
636
637 TP_printk("c=%08x %s r=%d o=%d sp=%pSR",
638 __entry->call,
639 __print_symbolic(__entry->op, afs_call_traces),
640 __entry->ref,
641 __entry->outstanding,
642 __entry->where)
643 );
644
645TRACE_EVENT(afs_make_fs_call,
646 TP_PROTO(struct afs_call *call, const struct afs_fid *fid),
647
648 TP_ARGS(call, fid),
649
650 TP_STRUCT__entry(
651 __field(unsigned int, call)
652 __field(enum afs_fs_operation, op)
653 __field_struct(struct afs_fid, fid)
654 ),
655
656 TP_fast_assign(
657 __entry->call = call->debug_id;
658 __entry->op = call->operation_ID;
659 if (fid) {
660 __entry->fid = *fid;
661 } else {
662 __entry->fid.vid = 0;
663 __entry->fid.vnode = 0;
664 __entry->fid.unique = 0;
665 }
666 ),
667
668 TP_printk("c=%08x %06llx:%06llx:%06x %s",
669 __entry->call,
670 __entry->fid.vid,
671 __entry->fid.vnode,
672 __entry->fid.unique,
673 __print_symbolic(__entry->op, afs_fs_operations))
674 );
675
676TRACE_EVENT(afs_make_fs_calli,
677 TP_PROTO(struct afs_call *call, const struct afs_fid *fid,
678 unsigned int i),
679
680 TP_ARGS(call, fid, i),
681
682 TP_STRUCT__entry(
683 __field(unsigned int, call)
684 __field(unsigned int, i)
685 __field(enum afs_fs_operation, op)
686 __field_struct(struct afs_fid, fid)
687 ),
688
689 TP_fast_assign(
690 __entry->call = call->debug_id;
691 __entry->i = i;
692 __entry->op = call->operation_ID;
693 if (fid) {
694 __entry->fid = *fid;
695 } else {
696 __entry->fid.vid = 0;
697 __entry->fid.vnode = 0;
698 __entry->fid.unique = 0;
699 }
700 ),
701
702 TP_printk("c=%08x %06llx:%06llx:%06x %s i=%u",
703 __entry->call,
704 __entry->fid.vid,
705 __entry->fid.vnode,
706 __entry->fid.unique,
707 __print_symbolic(__entry->op, afs_fs_operations),
708 __entry->i)
709 );
710
711TRACE_EVENT(afs_make_fs_call1,
712 TP_PROTO(struct afs_call *call, const struct afs_fid *fid,
713 const struct qstr *name),
714
715 TP_ARGS(call, fid, name),
716
717 TP_STRUCT__entry(
718 __field(unsigned int, call)
719 __field(enum afs_fs_operation, op)
720 __field_struct(struct afs_fid, fid)
721 __array(char, name, 24)
722 ),
723
724 TP_fast_assign(
725 unsigned int __len = min_t(unsigned int, name->len, 23);
726 __entry->call = call->debug_id;
727 __entry->op = call->operation_ID;
728 if (fid) {
729 __entry->fid = *fid;
730 } else {
731 __entry->fid.vid = 0;
732 __entry->fid.vnode = 0;
733 __entry->fid.unique = 0;
734 }
735 memcpy(__entry->name, name->name, __len);
736 __entry->name[__len] = 0;
737 ),
738
739 TP_printk("c=%08x %06llx:%06llx:%06x %s \"%s\"",
740 __entry->call,
741 __entry->fid.vid,
742 __entry->fid.vnode,
743 __entry->fid.unique,
744 __print_symbolic(__entry->op, afs_fs_operations),
745 __entry->name)
746 );
747
748TRACE_EVENT(afs_make_fs_call2,
749 TP_PROTO(struct afs_call *call, const struct afs_fid *fid,
750 const struct qstr *name, const struct qstr *name2),
751
752 TP_ARGS(call, fid, name, name2),
753
754 TP_STRUCT__entry(
755 __field(unsigned int, call)
756 __field(enum afs_fs_operation, op)
757 __field_struct(struct afs_fid, fid)
758 __array(char, name, 24)
759 __array(char, name2, 24)
760 ),
761
762 TP_fast_assign(
763 unsigned int __len = min_t(unsigned int, name->len, 23);
764 unsigned int __len2 = min_t(unsigned int, name2->len, 23);
765 __entry->call = call->debug_id;
766 __entry->op = call->operation_ID;
767 if (fid) {
768 __entry->fid = *fid;
769 } else {
770 __entry->fid.vid = 0;
771 __entry->fid.vnode = 0;
772 __entry->fid.unique = 0;
773 }
774 memcpy(__entry->name, name->name, __len);
775 __entry->name[__len] = 0;
776 memcpy(__entry->name2, name2->name, __len2);
777 __entry->name2[__len2] = 0;
778 ),
779
780 TP_printk("c=%08x %06llx:%06llx:%06x %s \"%s\" \"%s\"",
781 __entry->call,
782 __entry->fid.vid,
783 __entry->fid.vnode,
784 __entry->fid.unique,
785 __print_symbolic(__entry->op, afs_fs_operations),
786 __entry->name,
787 __entry->name2)
788 );
789
790TRACE_EVENT(afs_make_vl_call,
791 TP_PROTO(struct afs_call *call),
792
793 TP_ARGS(call),
794
795 TP_STRUCT__entry(
796 __field(unsigned int, call)
797 __field(enum afs_vl_operation, op)
798 ),
799
800 TP_fast_assign(
801 __entry->call = call->debug_id;
802 __entry->op = call->operation_ID;
803 ),
804
805 TP_printk("c=%08x %s",
806 __entry->call,
807 __print_symbolic(__entry->op, afs_vl_operations))
808 );
809
810TRACE_EVENT(afs_call_done,
811 TP_PROTO(struct afs_call *call),
812
813 TP_ARGS(call),
814
815 TP_STRUCT__entry(
816 __field(unsigned int, call)
817 __field(struct rxrpc_call *, rx_call)
818 __field(int, ret)
819 __field(u32, abort_code)
820 ),
821
822 TP_fast_assign(
823 __entry->call = call->debug_id;
824 __entry->rx_call = call->rxcall;
825 __entry->ret = call->error;
826 __entry->abort_code = call->abort_code;
827 ),
828
829 TP_printk(" c=%08x ret=%d ab=%d [%p]",
830 __entry->call,
831 __entry->ret,
832 __entry->abort_code,
833 __entry->rx_call)
834 );
835
836TRACE_EVENT(afs_send_data,
837 TP_PROTO(struct afs_call *call, struct msghdr *msg),
838
839 TP_ARGS(call, msg),
840
841 TP_STRUCT__entry(
842 __field(unsigned int, call)
843 __field(unsigned int, flags)
844 __field(loff_t, offset)
845 __field(loff_t, count)
846 ),
847
848 TP_fast_assign(
849 __entry->call = call->debug_id;
850 __entry->flags = msg->msg_flags;
851 __entry->offset = msg->msg_iter.xarray_start + msg->msg_iter.iov_offset;
852 __entry->count = iov_iter_count(&msg->msg_iter);
853 ),
854
855 TP_printk(" c=%08x o=%llx n=%llx f=%x",
856 __entry->call, __entry->offset, __entry->count,
857 __entry->flags)
858 );
859
860TRACE_EVENT(afs_sent_data,
861 TP_PROTO(struct afs_call *call, struct msghdr *msg, int ret),
862
863 TP_ARGS(call, msg, ret),
864
865 TP_STRUCT__entry(
866 __field(unsigned int, call)
867 __field(int, ret)
868 __field(loff_t, offset)
869 __field(loff_t, count)
870 ),
871
872 TP_fast_assign(
873 __entry->call = call->debug_id;
874 __entry->ret = ret;
875 __entry->offset = msg->msg_iter.xarray_start + msg->msg_iter.iov_offset;
876 __entry->count = iov_iter_count(&msg->msg_iter);
877 ),
878
879 TP_printk(" c=%08x o=%llx n=%llx r=%x",
880 __entry->call, __entry->offset, __entry->count,
881 __entry->ret)
882 );
883
884TRACE_EVENT(afs_dir_check_failed,
885 TP_PROTO(struct afs_vnode *vnode, loff_t off, loff_t i_size),
886
887 TP_ARGS(vnode, off, i_size),
888
889 TP_STRUCT__entry(
890 __field(struct afs_vnode *, vnode)
891 __field(loff_t, off)
892 __field(loff_t, i_size)
893 ),
894
895 TP_fast_assign(
896 __entry->vnode = vnode;
897 __entry->off = off;
898 __entry->i_size = i_size;
899 ),
900
901 TP_printk("vn=%p %llx/%llx",
902 __entry->vnode, __entry->off, __entry->i_size)
903 );
904
905TRACE_EVENT(afs_call_state,
906 TP_PROTO(struct afs_call *call,
907 enum afs_call_state from,
908 enum afs_call_state to,
909 int ret, u32 remote_abort),
910
911 TP_ARGS(call, from, to, ret, remote_abort),
912
913 TP_STRUCT__entry(
914 __field(unsigned int, call)
915 __field(enum afs_call_state, from)
916 __field(enum afs_call_state, to)
917 __field(int, ret)
918 __field(u32, abort)
919 ),
920
921 TP_fast_assign(
922 __entry->call = call->debug_id;
923 __entry->from = from;
924 __entry->to = to;
925 __entry->ret = ret;
926 __entry->abort = remote_abort;
927 ),
928
929 TP_printk("c=%08x %u->%u r=%d ab=%d",
930 __entry->call,
931 __entry->from, __entry->to,
932 __entry->ret, __entry->abort)
933 );
934
935TRACE_EVENT(afs_lookup,
936 TP_PROTO(struct afs_vnode *dvnode, const struct qstr *name,
937 struct afs_fid *fid),
938
939 TP_ARGS(dvnode, name, fid),
940
941 TP_STRUCT__entry(
942 __field_struct(struct afs_fid, dfid)
943 __field_struct(struct afs_fid, fid)
944 __array(char, name, 24)
945 ),
946
947 TP_fast_assign(
948 int __len = min_t(int, name->len, 23);
949 __entry->dfid = dvnode->fid;
950 __entry->fid = *fid;
951 memcpy(__entry->name, name->name, __len);
952 __entry->name[__len] = 0;
953 ),
954
955 TP_printk("d=%llx:%llx:%x \"%s\" f=%llx:%x",
956 __entry->dfid.vid, __entry->dfid.vnode, __entry->dfid.unique,
957 __entry->name,
958 __entry->fid.vnode, __entry->fid.unique)
959 );
960
961TRACE_EVENT(afs_edit_dir,
962 TP_PROTO(struct afs_vnode *dvnode,
963 enum afs_edit_dir_reason why,
964 enum afs_edit_dir_op op,
965 unsigned int block,
966 unsigned int slot,
967 unsigned int f_vnode,
968 unsigned int f_unique,
969 const char *name),
970
971 TP_ARGS(dvnode, why, op, block, slot, f_vnode, f_unique, name),
972
973 TP_STRUCT__entry(
974 __field(unsigned int, vnode)
975 __field(unsigned int, unique)
976 __field(enum afs_edit_dir_reason, why)
977 __field(enum afs_edit_dir_op, op)
978 __field(unsigned int, block)
979 __field(unsigned short, slot)
980 __field(unsigned int, f_vnode)
981 __field(unsigned int, f_unique)
982 __array(char, name, 24)
983 ),
984
985 TP_fast_assign(
986 int __len = strlen(name);
987 __len = min(__len, 23);
988 __entry->vnode = dvnode->fid.vnode;
989 __entry->unique = dvnode->fid.unique;
990 __entry->why = why;
991 __entry->op = op;
992 __entry->block = block;
993 __entry->slot = slot;
994 __entry->f_vnode = f_vnode;
995 __entry->f_unique = f_unique;
996 memcpy(__entry->name, name, __len);
997 __entry->name[__len] = 0;
998 ),
999
1000 TP_printk("d=%x:%x %s %s %u[%u] f=%x:%x \"%s\"",
1001 __entry->vnode, __entry->unique,
1002 __print_symbolic(__entry->why, afs_edit_dir_reasons),
1003 __print_symbolic(__entry->op, afs_edit_dir_ops),
1004 __entry->block, __entry->slot,
1005 __entry->f_vnode, __entry->f_unique,
1006 __entry->name)
1007 );
1008
1009TRACE_EVENT(afs_protocol_error,
1010 TP_PROTO(struct afs_call *call, enum afs_eproto_cause cause),
1011
1012 TP_ARGS(call, cause),
1013
1014 TP_STRUCT__entry(
1015 __field(unsigned int, call)
1016 __field(enum afs_eproto_cause, cause)
1017 ),
1018
1019 TP_fast_assign(
1020 __entry->call = call ? call->debug_id : 0;
1021 __entry->cause = cause;
1022 ),
1023
1024 TP_printk("c=%08x %s",
1025 __entry->call,
1026 __print_symbolic(__entry->cause, afs_eproto_causes))
1027 );
1028
1029TRACE_EVENT(afs_io_error,
1030 TP_PROTO(unsigned int call, int error, enum afs_io_error where),
1031
1032 TP_ARGS(call, error, where),
1033
1034 TP_STRUCT__entry(
1035 __field(unsigned int, call)
1036 __field(int, error)
1037 __field(enum afs_io_error, where)
1038 ),
1039
1040 TP_fast_assign(
1041 __entry->call = call;
1042 __entry->error = error;
1043 __entry->where = where;
1044 ),
1045
1046 TP_printk("c=%08x r=%d %s",
1047 __entry->call, __entry->error,
1048 __print_symbolic(__entry->where, afs_io_errors))
1049 );
1050
1051TRACE_EVENT(afs_file_error,
1052 TP_PROTO(struct afs_vnode *vnode, int error, enum afs_file_error where),
1053
1054 TP_ARGS(vnode, error, where),
1055
1056 TP_STRUCT__entry(
1057 __field_struct(struct afs_fid, fid)
1058 __field(int, error)
1059 __field(enum afs_file_error, where)
1060 ),
1061
1062 TP_fast_assign(
1063 __entry->fid = vnode->fid;
1064 __entry->error = error;
1065 __entry->where = where;
1066 ),
1067
1068 TP_printk("%llx:%llx:%x r=%d %s",
1069 __entry->fid.vid, __entry->fid.vnode, __entry->fid.unique,
1070 __entry->error,
1071 __print_symbolic(__entry->where, afs_file_errors))
1072 );
1073
1074TRACE_EVENT(afs_bulkstat_error,
1075 TP_PROTO(struct afs_operation *op, struct afs_fid *fid, unsigned int index, s32 abort),
1076
1077 TP_ARGS(op, fid, index, abort),
1078
1079 TP_STRUCT__entry(
1080 __field_struct(struct afs_fid, fid)
1081 __field(unsigned int, op)
1082 __field(unsigned int, index)
1083 __field(s32, abort)
1084 ),
1085
1086 TP_fast_assign(
1087 __entry->op = op->debug_id;
1088 __entry->fid = *fid;
1089 __entry->index = index;
1090 __entry->abort = abort;
1091 ),
1092
1093 TP_printk("OP=%08x[%02x] %llx:%llx:%x a=%d",
1094 __entry->op, __entry->index,
1095 __entry->fid.vid, __entry->fid.vnode, __entry->fid.unique,
1096 __entry->abort)
1097 );
1098
1099TRACE_EVENT(afs_cm_no_server,
1100 TP_PROTO(struct afs_call *call, struct sockaddr_rxrpc *srx),
1101
1102 TP_ARGS(call, srx),
1103
1104 TP_STRUCT__entry(
1105 __field(unsigned int, call)
1106 __field(unsigned int, op_id)
1107 __field_struct(struct sockaddr_rxrpc, srx)
1108 ),
1109
1110 TP_fast_assign(
1111 __entry->call = call->debug_id;
1112 __entry->op_id = call->operation_ID;
1113 memcpy(&__entry->srx, srx, sizeof(__entry->srx));
1114 ),
1115
1116 TP_printk("c=%08x op=%u %pISpc",
1117 __entry->call, __entry->op_id, &__entry->srx.transport)
1118 );
1119
1120TRACE_EVENT(afs_cm_no_server_u,
1121 TP_PROTO(struct afs_call *call, const uuid_t *uuid),
1122
1123 TP_ARGS(call, uuid),
1124
1125 TP_STRUCT__entry(
1126 __field(unsigned int, call)
1127 __field(unsigned int, op_id)
1128 __field_struct(uuid_t, uuid)
1129 ),
1130
1131 TP_fast_assign(
1132 __entry->call = call->debug_id;
1133 __entry->op_id = call->operation_ID;
1134 memcpy(&__entry->uuid, uuid, sizeof(__entry->uuid));
1135 ),
1136
1137 TP_printk("c=%08x op=%u %pU",
1138 __entry->call, __entry->op_id, &__entry->uuid)
1139 );
1140
1141TRACE_EVENT(afs_flock_ev,
1142 TP_PROTO(struct afs_vnode *vnode, struct file_lock *fl,
1143 enum afs_flock_event event, int error),
1144
1145 TP_ARGS(vnode, fl, event, error),
1146
1147 TP_STRUCT__entry(
1148 __field_struct(struct afs_fid, fid)
1149 __field(enum afs_flock_event, event)
1150 __field(enum afs_lock_state, state)
1151 __field(int, error)
1152 __field(unsigned int, debug_id)
1153 ),
1154
1155 TP_fast_assign(
1156 __entry->fid = vnode->fid;
1157 __entry->event = event;
1158 __entry->state = vnode->lock_state;
1159 __entry->error = error;
1160 __entry->debug_id = fl ? fl->fl_u.afs.debug_id : 0;
1161 ),
1162
1163 TP_printk("%llx:%llx:%x %04x %s s=%s e=%d",
1164 __entry->fid.vid, __entry->fid.vnode, __entry->fid.unique,
1165 __entry->debug_id,
1166 __print_symbolic(__entry->event, afs_flock_events),
1167 __print_symbolic(__entry->state, afs_flock_states),
1168 __entry->error)
1169 );
1170
1171TRACE_EVENT(afs_flock_op,
1172 TP_PROTO(struct afs_vnode *vnode, struct file_lock *fl,
1173 enum afs_flock_operation op),
1174
1175 TP_ARGS(vnode, fl, op),
1176
1177 TP_STRUCT__entry(
1178 __field_struct(struct afs_fid, fid)
1179 __field(loff_t, from)
1180 __field(loff_t, len)
1181 __field(enum afs_flock_operation, op)
1182 __field(unsigned char, type)
1183 __field(unsigned int, flags)
1184 __field(unsigned int, debug_id)
1185 ),
1186
1187 TP_fast_assign(
1188 __entry->fid = vnode->fid;
1189 __entry->from = fl->fl_start;
1190 __entry->len = fl->fl_end - fl->fl_start + 1;
1191 __entry->op = op;
1192 __entry->type = fl->fl_type;
1193 __entry->flags = fl->fl_flags;
1194 __entry->debug_id = fl->fl_u.afs.debug_id;
1195 ),
1196
1197 TP_printk("%llx:%llx:%x %04x %s t=%s R=%llx/%llx f=%x",
1198 __entry->fid.vid, __entry->fid.vnode, __entry->fid.unique,
1199 __entry->debug_id,
1200 __print_symbolic(__entry->op, afs_flock_operations),
1201 __print_symbolic(__entry->type, afs_flock_types),
1202 __entry->from, __entry->len, __entry->flags)
1203 );
1204
1205TRACE_EVENT(afs_reload_dir,
1206 TP_PROTO(struct afs_vnode *vnode),
1207
1208 TP_ARGS(vnode),
1209
1210 TP_STRUCT__entry(
1211 __field_struct(struct afs_fid, fid)
1212 ),
1213
1214 TP_fast_assign(
1215 __entry->fid = vnode->fid;
1216 ),
1217
1218 TP_printk("%llx:%llx:%x",
1219 __entry->fid.vid, __entry->fid.vnode, __entry->fid.unique)
1220 );
1221
1222TRACE_EVENT(afs_silly_rename,
1223 TP_PROTO(struct afs_vnode *vnode, bool done),
1224
1225 TP_ARGS(vnode, done),
1226
1227 TP_STRUCT__entry(
1228 __field_struct(struct afs_fid, fid)
1229 __field(bool, done)
1230 ),
1231
1232 TP_fast_assign(
1233 __entry->fid = vnode->fid;
1234 __entry->done = done;
1235 ),
1236
1237 TP_printk("%llx:%llx:%x done=%u",
1238 __entry->fid.vid, __entry->fid.vnode, __entry->fid.unique,
1239 __entry->done)
1240 );
1241
1242TRACE_EVENT(afs_get_tree,
1243 TP_PROTO(struct afs_cell *cell, struct afs_volume *volume),
1244
1245 TP_ARGS(cell, volume),
1246
1247 TP_STRUCT__entry(
1248 __field(u64, vid)
1249 __array(char, cell, 24)
1250 __array(char, volume, 24)
1251 ),
1252
1253 TP_fast_assign(
1254 int __len;
1255 __entry->vid = volume->vid;
1256 __len = min_t(int, cell->name_len, 23);
1257 memcpy(__entry->cell, cell->name, __len);
1258 __entry->cell[__len] = 0;
1259 __len = min_t(int, volume->name_len, 23);
1260 memcpy(__entry->volume, volume->name, __len);
1261 __entry->volume[__len] = 0;
1262 ),
1263
1264 TP_printk("--- MOUNT %s:%s %llx",
1265 __entry->cell, __entry->volume, __entry->vid)
1266 );
1267
1268TRACE_EVENT(afs_cb_v_break,
1269 TP_PROTO(afs_volid_t vid, unsigned int cb_v_break,
1270 enum afs_cb_break_reason reason),
1271
1272 TP_ARGS(vid, cb_v_break, reason),
1273
1274 TP_STRUCT__entry(
1275 __field(afs_volid_t, vid)
1276 __field(unsigned int, cb_v_break)
1277 __field(enum afs_cb_break_reason, reason)
1278 ),
1279
1280 TP_fast_assign(
1281 __entry->vid = vid;
1282 __entry->cb_v_break = cb_v_break;
1283 __entry->reason = reason;
1284 ),
1285
1286 TP_printk("%llx vb=%x %s",
1287 __entry->vid,
1288 __entry->cb_v_break,
1289 __print_symbolic(__entry->reason, afs_cb_break_reasons))
1290 );
1291
1292TRACE_EVENT(afs_cb_break,
1293 TP_PROTO(struct afs_fid *fid, unsigned int cb_break,
1294 enum afs_cb_break_reason reason, bool skipped),
1295
1296 TP_ARGS(fid, cb_break, reason, skipped),
1297
1298 TP_STRUCT__entry(
1299 __field_struct(struct afs_fid, fid)
1300 __field(unsigned int, cb_break)
1301 __field(enum afs_cb_break_reason, reason)
1302 __field(bool, skipped)
1303 ),
1304
1305 TP_fast_assign(
1306 __entry->fid = *fid;
1307 __entry->cb_break = cb_break;
1308 __entry->reason = reason;
1309 __entry->skipped = skipped;
1310 ),
1311
1312 TP_printk("%llx:%llx:%x b=%x s=%u %s",
1313 __entry->fid.vid, __entry->fid.vnode, __entry->fid.unique,
1314 __entry->cb_break,
1315 __entry->skipped,
1316 __print_symbolic(__entry->reason, afs_cb_break_reasons))
1317 );
1318
1319TRACE_EVENT(afs_cb_miss,
1320 TP_PROTO(struct afs_fid *fid, enum afs_cb_break_reason reason),
1321
1322 TP_ARGS(fid, reason),
1323
1324 TP_STRUCT__entry(
1325 __field_struct(struct afs_fid, fid)
1326 __field(enum afs_cb_break_reason, reason)
1327 ),
1328
1329 TP_fast_assign(
1330 __entry->fid = *fid;
1331 __entry->reason = reason;
1332 ),
1333
1334 TP_printk(" %llx:%llx:%x %s",
1335 __entry->fid.vid, __entry->fid.vnode, __entry->fid.unique,
1336 __print_symbolic(__entry->reason, afs_cb_break_reasons))
1337 );
1338
1339TRACE_EVENT(afs_server,
1340 TP_PROTO(unsigned int server_debug_id, int ref, int active,
1341 enum afs_server_trace reason),
1342
1343 TP_ARGS(server_debug_id, ref, active, reason),
1344
1345 TP_STRUCT__entry(
1346 __field(unsigned int, server)
1347 __field(int, ref)
1348 __field(int, active)
1349 __field(int, reason)
1350 ),
1351
1352 TP_fast_assign(
1353 __entry->server = server_debug_id;
1354 __entry->ref = ref;
1355 __entry->active = active;
1356 __entry->reason = reason;
1357 ),
1358
1359 TP_printk("s=%08x %s u=%d a=%d",
1360 __entry->server,
1361 __print_symbolic(__entry->reason, afs_server_traces),
1362 __entry->ref,
1363 __entry->active)
1364 );
1365
1366TRACE_EVENT(afs_volume,
1367 TP_PROTO(afs_volid_t vid, int ref, enum afs_volume_trace reason),
1368
1369 TP_ARGS(vid, ref, reason),
1370
1371 TP_STRUCT__entry(
1372 __field(afs_volid_t, vid)
1373 __field(int, ref)
1374 __field(enum afs_volume_trace, reason)
1375 ),
1376
1377 TP_fast_assign(
1378 __entry->vid = vid;
1379 __entry->ref = ref;
1380 __entry->reason = reason;
1381 ),
1382
1383 TP_printk("V=%llx %s ur=%d",
1384 __entry->vid,
1385 __print_symbolic(__entry->reason, afs_volume_traces),
1386 __entry->ref)
1387 );
1388
1389TRACE_EVENT(afs_cell,
1390 TP_PROTO(unsigned int cell_debug_id, int ref, int active,
1391 enum afs_cell_trace reason),
1392
1393 TP_ARGS(cell_debug_id, ref, active, reason),
1394
1395 TP_STRUCT__entry(
1396 __field(unsigned int, cell)
1397 __field(int, ref)
1398 __field(int, active)
1399 __field(int, reason)
1400 ),
1401
1402 TP_fast_assign(
1403 __entry->cell = cell_debug_id;
1404 __entry->ref = ref;
1405 __entry->active = active;
1406 __entry->reason = reason;
1407 ),
1408
1409 TP_printk("L=%08x %s r=%d a=%d",
1410 __entry->cell,
1411 __print_symbolic(__entry->reason, afs_cell_traces),
1412 __entry->ref,
1413 __entry->active)
1414 );
1415
1416TRACE_EVENT(afs_alist,
1417 TP_PROTO(unsigned int alist_debug_id, int ref, enum afs_alist_trace reason),
1418
1419 TP_ARGS(alist_debug_id, ref, reason),
1420
1421 TP_STRUCT__entry(
1422 __field(unsigned int, alist)
1423 __field(int, ref)
1424 __field(int, active)
1425 __field(int, reason)
1426 ),
1427
1428 TP_fast_assign(
1429 __entry->alist = alist_debug_id;
1430 __entry->ref = ref;
1431 __entry->reason = reason;
1432 ),
1433
1434 TP_printk("AL=%08x %s r=%d",
1435 __entry->alist,
1436 __print_symbolic(__entry->reason, afs_alist_traces),
1437 __entry->ref)
1438 );
1439
1440TRACE_EVENT(afs_estate,
1441 TP_PROTO(unsigned int server_debug_id, unsigned int estate_debug_id,
1442 int ref, enum afs_estate_trace reason),
1443
1444 TP_ARGS(server_debug_id, estate_debug_id, ref, reason),
1445
1446 TP_STRUCT__entry(
1447 __field(unsigned int, server)
1448 __field(unsigned int, estate)
1449 __field(int, ref)
1450 __field(int, active)
1451 __field(int, reason)
1452 ),
1453
1454 TP_fast_assign(
1455 __entry->server = server_debug_id;
1456 __entry->estate = estate_debug_id;
1457 __entry->ref = ref;
1458 __entry->reason = reason;
1459 ),
1460
1461 TP_printk("ES=%08x[%x] %s r=%d",
1462 __entry->server,
1463 __entry->estate,
1464 __print_symbolic(__entry->reason, afs_estate_traces),
1465 __entry->ref)
1466 );
1467
1468TRACE_EVENT(afs_fs_probe,
1469 TP_PROTO(struct afs_server *server, bool tx, struct afs_endpoint_state *estate,
1470 unsigned int addr_index, int error, s32 abort_code, unsigned int rtt_us),
1471
1472 TP_ARGS(server, tx, estate, addr_index, error, abort_code, rtt_us),
1473
1474 TP_STRUCT__entry(
1475 __field(unsigned int, server)
1476 __field(unsigned int, estate)
1477 __field(bool, tx)
1478 __field(u16, addr_index)
1479 __field(short, error)
1480 __field(s32, abort_code)
1481 __field(unsigned int, rtt_us)
1482 __field_struct(struct sockaddr_rxrpc, srx)
1483 ),
1484
1485 TP_fast_assign(
1486 struct afs_addr_list *alist = estate->addresses;
1487 __entry->server = server->debug_id;
1488 __entry->estate = estate->probe_seq;
1489 __entry->tx = tx;
1490 __entry->addr_index = addr_index;
1491 __entry->error = error;
1492 __entry->abort_code = abort_code;
1493 __entry->rtt_us = rtt_us;
1494 memcpy(&__entry->srx, rxrpc_kernel_remote_srx(alist->addrs[addr_index].peer),
1495 sizeof(__entry->srx));
1496 ),
1497
1498 TP_printk("s=%08x %s pq=%x ax=%u e=%d ac=%d rtt=%d %pISpc",
1499 __entry->server, __entry->tx ? "tx" : "rx", __entry->estate,
1500 __entry->addr_index, __entry->error, __entry->abort_code, __entry->rtt_us,
1501 &__entry->srx.transport)
1502 );
1503
1504TRACE_EVENT(afs_vl_probe,
1505 TP_PROTO(struct afs_vlserver *server, bool tx, struct afs_addr_list *alist,
1506 unsigned int addr_index, int error, s32 abort_code, unsigned int rtt_us),
1507
1508 TP_ARGS(server, tx, alist, addr_index, error, abort_code, rtt_us),
1509
1510 TP_STRUCT__entry(
1511 __field(unsigned int, server)
1512 __field(bool, tx)
1513 __field(unsigned short, flags)
1514 __field(u16, addr_index)
1515 __field(short, error)
1516 __field(s32, abort_code)
1517 __field(unsigned int, rtt_us)
1518 __field_struct(struct sockaddr_rxrpc, srx)
1519 ),
1520
1521 TP_fast_assign(
1522 __entry->server = server->debug_id;
1523 __entry->tx = tx;
1524 __entry->addr_index = addr_index;
1525 __entry->error = error;
1526 __entry->abort_code = abort_code;
1527 __entry->rtt_us = rtt_us;
1528 memcpy(&__entry->srx, rxrpc_kernel_remote_srx(alist->addrs[addr_index].peer),
1529 sizeof(__entry->srx));
1530 ),
1531
1532 TP_printk("vl=%08x %s ax=%u e=%d ac=%d rtt=%d %pISpc",
1533 __entry->server, __entry->tx ? "tx" : "rx", __entry->addr_index,
1534 __entry->error, __entry->abort_code, __entry->rtt_us,
1535 &__entry->srx.transport)
1536 );
1537
1538TRACE_EVENT(afs_rotate,
1539 TP_PROTO(struct afs_operation *op, enum afs_rotate_trace reason, unsigned int extra),
1540
1541 TP_ARGS(op, reason, extra),
1542
1543 TP_STRUCT__entry(
1544 __field(unsigned int, op)
1545 __field(unsigned int, flags)
1546 __field(unsigned int, extra)
1547 __field(unsigned short, iteration)
1548 __field(short, server_index)
1549 __field(short, addr_index)
1550 __field(enum afs_rotate_trace, reason)
1551 ),
1552
1553 TP_fast_assign(
1554 __entry->op = op->debug_id;
1555 __entry->flags = op->flags;
1556 __entry->iteration = op->nr_iterations;
1557 __entry->server_index = op->server_index;
1558 __entry->addr_index = op->addr_index;
1559 __entry->reason = reason;
1560 __entry->extra = extra;
1561 ),
1562
1563 TP_printk("OP=%08x it=%02x %s fl=%x sx=%d ax=%d ext=%d",
1564 __entry->op,
1565 __entry->iteration,
1566 __print_symbolic(__entry->reason, afs_rotate_traces),
1567 __entry->flags,
1568 __entry->server_index,
1569 __entry->addr_index,
1570 __entry->extra)
1571 );
1572
1573TRACE_EVENT(afs_make_call,
1574 TP_PROTO(struct afs_call *call),
1575
1576 TP_ARGS(call),
1577
1578 TP_STRUCT__entry(
1579 __field(unsigned int, call)
1580 __field(bool, is_vl)
1581 __field(enum afs_fs_operation, op)
1582 __field_struct(struct afs_fid, fid)
1583 __field_struct(struct sockaddr_rxrpc, srx)
1584 ),
1585
1586 TP_fast_assign(
1587 __entry->call = call->debug_id;
1588 __entry->op = call->operation_ID;
1589 __entry->fid = call->fid;
1590 memcpy(&__entry->srx, rxrpc_kernel_remote_srx(call->peer),
1591 sizeof(__entry->srx));
1592 __entry->srx.srx_service = call->service_id;
1593 __entry->is_vl = (__entry->srx.srx_service == VL_SERVICE ||
1594 __entry->srx.srx_service == YFS_VL_SERVICE);
1595 ),
1596
1597 TP_printk("c=%08x %pISpc+%u %s %llx:%llx:%x",
1598 __entry->call,
1599 &__entry->srx.transport,
1600 __entry->srx.srx_service,
1601 __entry->is_vl ?
1602 __print_symbolic(__entry->op, afs_vl_operations) :
1603 __print_symbolic(__entry->op, afs_fs_operations),
1604 __entry->fid.vid,
1605 __entry->fid.vnode,
1606 __entry->fid.unique)
1607 );
1608
1609#endif /* _TRACE_AFS_H */
1610
1611/* This part must be outside protection */
1612#include <trace/define_trace.h>