1/* SPDX-License-Identifier: GPL-2.0 */ 2/* 3 * fs/hmdfs/hmdfs_trace.h 4 * 5 * Copyright (c) 2020-2021 Huawei Device Co., Ltd. 6 */ 7 8#undef TRACE_SYSTEM 9#define TRACE_SYSTEM hmdfs 10 11#if !defined(__HMDFS_TRACE_H__) || defined(TRACE_HEADER_MULTI_READ) 12 13#define __HMDFS_TRACE_H__ 14 15#include <linux/tracepoint.h> 16#include "comm/protocol.h" 17#include "hmdfs_dentryfile.h" 18#include "hmdfs_client.h" 19#include "hmdfs_device_view.h" 20#include "hmdfs_merge_view.h" 21#include "client_writeback.h" 22 23TRACE_EVENT(hmdfs_permission, 24 25 TP_PROTO(unsigned long ino), 26 27 TP_ARGS(ino), 28 29 TP_STRUCT__entry(__field(unsigned long, ino)), 30 31 TP_fast_assign(__entry->ino = ino;), 32 33 TP_printk("permission check for ino %lu failed", __entry->ino)); 34 35/* communication */ 36TRACE_EVENT(hmdfs_recv_mesg_callback, 37 38 TP_PROTO(struct hmdfs_head_cmd *cmd), 39 40 TP_ARGS(cmd), 41 42 TP_STRUCT__entry( 43 __field(__u32, msg_id) 44 __field(__u32, magic) 45 __field(__u16, command) 46 __field(__u16, cmd_flag) 47 __field(__u32, data_len) 48 __field(__u32, ret_code) 49 ), 50 51 TP_fast_assign( 52 __entry->msg_id = le32_to_cpu(cmd->msg_id); 53 __entry->magic = cmd->magic; 54 __entry->command = cmd->operations.command; 55 __entry->cmd_flag = cmd->operations.cmd_flag; 56 __entry->data_len = cmd->data_len; 57 __entry->ret_code = cmd->ret_code; 58 ), 59 60 TP_printk("msg_id:%u magic:%u command:%hu, cmd_flag:%hu, data_len:%u, ret_code:%u", 61 __entry->msg_id, __entry->magic, __entry->command, 62 __entry->cmd_flag, __entry->data_len, __entry->ret_code) 63); 64 65TRACE_EVENT(hmdfs_tcp_send_message, 66 67 TP_PROTO(struct hmdfs_head_cmd *cmd), 68 69 TP_ARGS(cmd), 70 71 TP_STRUCT__entry( 72 __field(__u32, msg_id) 73 __field(__u32, magic) 74 __field(__u16, command) 75 __field(__u16, cmd_flag) 76 __field(__u32, data_len) 77 __field(__u32, ret_code) 78 ), 79 80 TP_fast_assign( 81 __entry->msg_id = le32_to_cpu(cmd->msg_id); 82 __entry->magic = cmd->magic; 83 __entry->command = cmd->operations.command; 84 __entry->cmd_flag = cmd->operations.cmd_flag; 85 __entry->data_len = cmd->data_len; 86 __entry->ret_code = cmd->ret_code; 87 ), 88 89 TP_printk("msg_id:%u magic:%u command:%hu, cmd_flag:%hu, data_len:%u, ret_code:%u", 90 __entry->msg_id, __entry->magic, __entry->command, 91 __entry->cmd_flag, __entry->data_len, __entry->ret_code) 92); 93 94/* file system interface */ 95DECLARE_EVENT_CLASS(hmdfs_iterate_op_end, 96 97 TP_PROTO(struct dentry *__d, loff_t start_pos, loff_t end_pos, int err), 98 99 TP_ARGS(__d, start_pos, end_pos, err), 100 101 TP_STRUCT__entry( 102 __string(name_str, __d->d_name.name) 103 __field(loff_t, start) 104 __field(loff_t, end) 105 __field(int, err) 106 ), 107 108 TP_fast_assign( 109 __assign_str(name_str, __d->d_name.name); 110 __entry->start = start_pos; 111 __entry->end = end_pos; 112 __entry->err = err; 113 ), 114 115 TP_printk("dentry[%s] start_pos:%llx, end_pos:%llx, err:%d", 116 __get_str(name_str), __entry->start, 117 __entry->end, __entry->err) 118); 119 120#define define_hmdfs_iterate_op_end_event(event_name) \ 121 DEFINE_EVENT(hmdfs_iterate_op_end, event_name, \ 122 TP_PROTO(struct dentry *__d, loff_t start_pos, \ 123 loff_t end_pos, int err), \ 124 TP_ARGS(__d, start_pos, end_pos, err)) 125 126define_hmdfs_iterate_op_end_event(hmdfs_iterate_local); 127define_hmdfs_iterate_op_end_event(hmdfs_iterate_remote); 128define_hmdfs_iterate_op_end_event(hmdfs_iterate_merge); 129 130 131TRACE_EVENT(hmdfs_lookup, 132 133 TP_PROTO(struct inode *dir, struct dentry *dentry, unsigned int flags), 134 135 TP_ARGS(dir, dentry, flags), 136 137 TP_STRUCT__entry( 138 __field(ino_t, ino) 139 __string(name_str, dentry->d_name.name) 140 __field(unsigned int, flags) 141 ), 142 143 TP_fast_assign( 144 __entry->ino = dir->i_ino; 145 __assign_str(name_str, dentry->d_name.name); 146 __entry->flags = flags; 147 ), 148 149 TP_printk("parent_ino = %lu, name:%s, flags:%u", 150 __entry->ino, __get_str(name_str), __entry->flags) 151); 152 153DECLARE_EVENT_CLASS(hmdfs_lookup_op_end, 154 155 TP_PROTO(struct inode *dir, struct dentry *dentry, int err), 156 157 TP_ARGS(dir, dentry, err), 158 159 TP_STRUCT__entry( 160 __field(ino_t, ino) 161 __string(name_str, dentry->d_name.name) 162 __field(int, err) 163 ), 164 165 TP_fast_assign( 166 __entry->ino = dir->i_ino; 167 __assign_str(name_str, dentry->d_name.name); 168 __entry->err = err; 169 ), 170 171 TP_printk("parent_ino = %lu, name:%s, err:%d", 172 __entry->ino, __get_str(name_str), __entry->err) 173); 174 175#define define_hmdfs_lookup_op_end_event(event_name) \ 176 DEFINE_EVENT(hmdfs_lookup_op_end, event_name, \ 177 TP_PROTO(struct inode *dir, struct dentry *dentry, \ 178 int err), \ 179 TP_ARGS(dir, dentry, err)) 180 181 182define_hmdfs_lookup_op_end_event(hmdfs_root_lookup); 183define_hmdfs_lookup_op_end_event(hmdfs_root_lookup_end); 184 185define_hmdfs_lookup_op_end_event(hmdfs_device_lookup); 186define_hmdfs_lookup_op_end_event(hmdfs_device_lookup_end); 187 188define_hmdfs_lookup_op_end_event(hmdfs_lookup_local); 189define_hmdfs_lookup_op_end_event(hmdfs_lookup_local_end); 190define_hmdfs_lookup_op_end_event(hmdfs_mkdir_local); 191define_hmdfs_lookup_op_end_event(hmdfs_rmdir_local); 192define_hmdfs_lookup_op_end_event(hmdfs_create_local); 193 194define_hmdfs_lookup_op_end_event(hmdfs_lookup_remote); 195define_hmdfs_lookup_op_end_event(hmdfs_lookup_remote_end); 196define_hmdfs_lookup_op_end_event(hmdfs_mkdir_remote); 197define_hmdfs_lookup_op_end_event(hmdfs_rmdir_remote); 198define_hmdfs_lookup_op_end_event(hmdfs_create_remote); 199 200define_hmdfs_lookup_op_end_event(hmdfs_lookup_merge); 201define_hmdfs_lookup_op_end_event(hmdfs_lookup_merge_end); 202define_hmdfs_lookup_op_end_event(hmdfs_mkdir_merge); 203define_hmdfs_lookup_op_end_event(hmdfs_rmdir_merge); 204define_hmdfs_lookup_op_end_event(hmdfs_create_merge); 205 206define_hmdfs_lookup_op_end_event(hmdfs_get_link_local); 207define_hmdfs_lookup_op_end_event(hmdfs_lookup_share); 208define_hmdfs_lookup_op_end_event(hmdfs_lookup_share_end); 209 210TRACE_EVENT(hmdfs_show_comrade, 211 212 TP_PROTO(struct dentry *d, struct dentry *lo_d, uint64_t devid), 213 214 TP_ARGS(d, lo_d, devid), 215 216 TP_STRUCT__entry( 217 __string(name, d->d_name.name) 218 __string(lo_name, lo_d->d_name.name) 219 __field(uint64_t, devid) 220 ), 221 222 TP_fast_assign( 223 __assign_str(name, d->d_name.name) 224 __assign_str(lo_name, lo_d->d_name.name) 225 __entry->devid = devid; 226 ), 227 228 TP_printk("parent_name:%s -> lo_d_name:%s, lo_d_devid:%llu", 229 __get_str(name), __get_str(lo_name), __entry->devid) 230); 231 232DECLARE_EVENT_CLASS(hmdfs_rename_op_end, 233 234 TP_PROTO(struct inode *olddir, struct dentry *olddentry, 235 struct inode *newdir, struct dentry *newdentry, 236 unsigned int flags), 237 238 TP_ARGS(olddir, olddentry, newdir, newdentry, flags), 239 240 TP_STRUCT__entry( 241 __field(ino_t, oldino) 242 __string(oldname_str, olddentry->d_name.name) 243 __field(ino_t, newino) 244 __string(newname_str, newdentry->d_name.name) 245 __field(unsigned int, flags) 246 ), 247 248 TP_fast_assign( 249 __entry->oldino = olddir->i_ino; 250 __assign_str(oldname_str, olddentry->d_name.name); 251 __entry->newino = newdir->i_ino; 252 __assign_str(newname_str, newdentry->d_name.name); 253 __entry->flags = flags; 254 ), 255 256 TP_printk("old_pino = %lu, oldname:%s; new_pino = %lu, newname:%s, flags:%u", 257 __entry->oldino, __get_str(oldname_str), 258 __entry->newino, __get_str(newname_str), __entry->flags) 259); 260 261#define define_hmdfs_rename_op_end_event(event_name) \ 262 DEFINE_EVENT(hmdfs_rename_op_end, event_name, \ 263 TP_PROTO(struct inode *olddir, struct dentry *olddentry, \ 264 struct inode *newdir, struct dentry *newdentry, \ 265 unsigned int flags), \ 266 TP_ARGS(olddir, olddentry, newdir, newdentry, flags)) 267 268define_hmdfs_rename_op_end_event(hmdfs_rename_local); 269define_hmdfs_rename_op_end_event(hmdfs_rename_remote); 270define_hmdfs_rename_op_end_event(hmdfs_rename_merge); 271 272TRACE_EVENT(hmdfs_statfs, 273 274 TP_PROTO(struct dentry *d, uint8_t type), 275 276 TP_ARGS(d, type), 277 278 TP_STRUCT__entry( 279 __string(name, d->d_name.name) 280 __field(uint8_t, type) 281 ), 282 283 TP_fast_assign( 284 __assign_str(name, d->d_name.name) 285 __entry->type = type; 286 ), 287 288 TP_printk("dentry_name:%s, lo_d_devid:%u", 289 __get_str(name), __entry->type) 290); 291 292 293 294TRACE_EVENT(hmdfs_balance_dirty_pages_ratelimited, 295 296 TP_PROTO(struct hmdfs_sb_info *sbi, 297 struct hmdfs_writeback *hwb, 298 int bdp_ratelimits), 299 300 TP_ARGS(sbi, hwb, bdp_ratelimits), 301 302 TP_STRUCT__entry( 303 __array(char, dst, 128) 304 __field(int, nr_dirtied) 305 __field(int, nr_dirtied_pause) 306 __field(int, dirty_exceeded) 307 __field(long long, bdp_ratelimits) 308 __field(long, ratelimit_pages) 309 ), 310 311 TP_fast_assign( 312 strlcpy(__entry->dst, sbi->local_dst, 128); 313 314 __entry->nr_dirtied = current->nr_dirtied; 315 __entry->nr_dirtied_pause = current->nr_dirtied_pause; 316 __entry->dirty_exceeded = hwb->dirty_exceeded; 317 __entry->bdp_ratelimits = bdp_ratelimits; 318 __entry->ratelimit_pages = hwb->ratelimit_pages; 319 ), 320 321 TP_printk("hmdfs dst:%s nr_dirtied=%d nr_dirtied_pause=%d dirty_exceeded=%d bdp_ratelimits=%lld ratelimit_pages=%ld", 322 __entry->dst, __entry->nr_dirtied, __entry->nr_dirtied_pause, 323 __entry->dirty_exceeded, __entry->bdp_ratelimits, 324 __entry->ratelimit_pages) 325); 326 327TRACE_EVENT(hmdfs_balance_dirty_pages, 328 329 TP_PROTO(struct hmdfs_sb_info *sbi, 330 struct bdi_writeback *wb, 331 struct hmdfs_dirty_throttle_control *hdtc, 332 unsigned long pause, 333 unsigned long start_time), 334 335 TP_ARGS(sbi, wb, hdtc, pause, start_time), 336 337 TP_STRUCT__entry( 338 __array(char, dst, 128) 339 __field(unsigned long, write_bw) 340 __field(unsigned long, avg_write_bw) 341 __field(unsigned long, file_bg_thresh) 342 __field(unsigned long, fs_bg_thresh) 343 __field(unsigned long, file_thresh) 344 __field(unsigned long, fs_thresh) 345 __field(unsigned long, file_nr_dirty) 346 __field(unsigned long, fs_nr_dirty) 347 __field(unsigned long, file_nr_rec) 348 __field(unsigned long, fs_nr_rec) 349 __field(unsigned long, pause) 350 __field(unsigned long, paused) 351 ), 352 353 TP_fast_assign( 354 strlcpy(__entry->dst, sbi->local_dst, 128); 355 356 __entry->write_bw = wb->write_bandwidth; 357 __entry->avg_write_bw = wb->avg_write_bandwidth; 358 __entry->file_bg_thresh = hdtc->file_bg_thresh; 359 __entry->fs_bg_thresh = hdtc->fs_bg_thresh; 360 __entry->file_thresh = hdtc->file_thresh; 361 __entry->fs_thresh = hdtc->fs_thresh; 362 __entry->file_nr_dirty = hdtc->file_nr_dirty; 363 __entry->fs_nr_dirty = hdtc->fs_nr_dirty; 364 __entry->file_nr_rec = hdtc->file_nr_reclaimable; 365 __entry->fs_nr_rec = hdtc->fs_nr_reclaimable; 366 __entry->pause = pause * 1000 / HZ; 367 __entry->paused = (jiffies - start_time) * 368 1000 / HZ; 369 ), 370 371 TP_printk("hmdfs dst:%s write_bw=%lu, awrite_bw=%lu, bg_thresh=%lu,%lu thresh=%lu,%lu dirty=%lu,%lu reclaimable=%lu,%lu pause=%lu paused=%lu", 372 __entry->dst, __entry->write_bw, __entry->avg_write_bw, 373 __entry->file_bg_thresh, __entry->fs_bg_thresh, 374 __entry->file_thresh, __entry->fs_thresh, 375 __entry->file_nr_dirty, __entry->fs_nr_dirty, 376 __entry->file_nr_rec, __entry->fs_nr_rec, 377 __entry->pause, __entry->paused 378 ) 379); 380 381TRACE_EVENT(hmdfs_start_srv_wb, 382 383 TP_PROTO(struct hmdfs_sb_info *sbi, int dirty_pages, 384 unsigned int dirty_thresh_pg), 385 386 TP_ARGS(sbi, dirty_pages, dirty_thresh_pg), 387 388 TP_STRUCT__entry( 389 __array(char, src, 128) 390 __field(int, dirty_pages) 391 __field(unsigned int, dirty_thresh_pg) 392 ), 393 394 TP_fast_assign( 395 strlcpy(__entry->src, sbi->local_src, 128); 396 __entry->dirty_pages = dirty_pages; 397 __entry->dirty_thresh_pg = dirty_thresh_pg; 398 ), 399 400 TP_printk("hmdfs src: %s, start writeback dirty pages. writeback %d pages dirty_thresh is %d pages", 401 __entry->src, __entry->dirty_pages, __entry->dirty_thresh_pg) 402); 403 404TRACE_EVENT(hmdfs_fsync_enter_remote, 405 406 TP_PROTO(struct hmdfs_sb_info *sbi, unsigned long long device_id, 407 unsigned long long remote_ino, int datasync), 408 409 TP_ARGS(sbi, device_id, remote_ino, datasync), 410 411 TP_STRUCT__entry( 412 __array(char, src, 128) 413 __field(uint64_t, device_id) 414 __field(uint64_t, remote_ino) 415 __field(int, datasync) 416 ), 417 418 TP_fast_assign( 419 strlcpy(__entry->src, sbi->local_src, 128); 420 __entry->device_id = device_id; 421 __entry->remote_ino = remote_ino; 422 __entry->datasync = datasync; 423 ), 424 425 TP_printk("hmdfs: src %s, start remote fsync file(remote dev_id=%llu,ino=%llu), datasync=%d", 426 __entry->src, __entry->device_id, 427 __entry->remote_ino, __entry->datasync) 428); 429 430TRACE_EVENT(hmdfs_fsync_exit_remote, 431 432 TP_PROTO(struct hmdfs_sb_info *sbi, unsigned long long device_id, 433 unsigned long long remote_ino, unsigned int timeout, int err), 434 435 TP_ARGS(sbi, device_id, remote_ino, timeout, err), 436 437 TP_STRUCT__entry( 438 __array(char, src, 128) 439 __field(uint64_t, device_id) 440 __field(uint64_t, remote_ino) 441 __field(uint32_t, timeout) 442 __field(int, err) 443 ), 444 445 TP_fast_assign( 446 strlcpy(__entry->src, sbi->local_src, 128); 447 __entry->device_id = device_id; 448 __entry->remote_ino = remote_ino; 449 __entry->timeout = timeout; 450 __entry->err = err; 451 ), 452 453 TP_printk("hmdfs: src %s, finish remote fsync file(remote dev_id=%llu,ino=%llu), timeout=%u, err=%d", 454 __entry->src, __entry->device_id, __entry->remote_ino, 455 __entry->timeout, __entry->err) 456); 457 458TRACE_EVENT(hmdfs_syncfs_enter, 459 460 TP_PROTO(struct hmdfs_sb_info *sbi), 461 462 TP_ARGS(sbi), 463 464 TP_STRUCT__entry( 465 __array(char, src, 128) 466 ), 467 468 TP_fast_assign( 469 strlcpy(__entry->src, sbi->local_src, 128); 470 ), 471 472 TP_printk("hmdfs: src %s, start syncfs", __entry->src) 473); 474 475TRACE_EVENT(hmdfs_syncfs_exit, 476 477 TP_PROTO(struct hmdfs_sb_info *sbi, int remain_count, 478 unsigned int timeout, int err), 479 480 TP_ARGS(sbi, remain_count, timeout, err), 481 482 TP_STRUCT__entry( 483 __array(char, src, 128) 484 __field(int, remain_count) 485 __field(uint32_t, timeout) 486 __field(int, err) 487 ), 488 489 TP_fast_assign( 490 strlcpy(__entry->src, sbi->local_src, 128); 491 __entry->remain_count = remain_count; 492 __entry->timeout = timeout; 493 __entry->err = err; 494 ), 495 496 TP_printk("hmdfs: src %s, finish syncfs(timeout=%u), remain %d remote devices to response, err=%d", 497 __entry->src, __entry->timeout, 498 __entry->remain_count, __entry->err) 499); 500 501TRACE_EVENT(hmdfs_server_release, 502 503 TP_PROTO(struct hmdfs_peer *con, uint32_t file_id, 504 uint64_t file_ver, int err), 505 506 TP_ARGS(con, file_id, file_ver, err), 507 508 TP_STRUCT__entry( 509 __array(char, src, 128) 510 __field(uint32_t, file_id) 511 __field(uint64_t, file_ver) 512 __field(uint64_t, device_id) 513 __field(int, err) 514 ), 515 516 TP_fast_assign( 517 strlcpy(__entry->src, con->sbi->local_src, 128); 518 __entry->file_id = file_id; 519 __entry->file_ver = file_ver; 520 __entry->device_id = con->device_id; 521 __entry->err = err; 522 ), 523 524 TP_printk("hmdfs: src %s, server release file, fid=%u, fid_ver=%llu, remote_dev=%llu, err=%d", 525 __entry->src, __entry->file_id, __entry->file_ver, 526 __entry->device_id, __entry->err) 527); 528 529TRACE_EVENT(hmdfs_readpages_cloud, 530 531 TP_PROTO(unsigned int nr_pages, int err), 532 533 TP_ARGS(nr_pages, err), 534 535 TP_STRUCT__entry( 536 __field(unsigned int, nr_pages) 537 __field(int, err) 538 ), 539 540 TP_fast_assign( 541 __entry->nr_pages = nr_pages; 542 __entry->err = err; 543 ), 544 545 TP_printk("nr_pages:%u, lo_d_devid:%d", 546 __entry->nr_pages, __entry->err) 547); 548 549TRACE_EVENT(hmdfs_do_readpages_cloud_begin, 550 551 TP_PROTO(int cnt, loff_t pos), 552 553 TP_ARGS(cnt, pos), 554 555 TP_STRUCT__entry( 556 __field(int, cnt) 557 __field(loff_t, pos) 558 ), 559 560 TP_fast_assign( 561 __entry->cnt = cnt; 562 __entry->pos = pos; 563 ), 564 565 TP_printk("cnt:%d, pos:%llx", 566 __entry->cnt, __entry->pos) 567); 568 569TRACE_EVENT(hmdfs_do_readpages_cloud_end, 570 571 TP_PROTO(int cnt, loff_t pos, int ret), 572 573 TP_ARGS(cnt, pos, ret), 574 575 TP_STRUCT__entry( 576 __field(int, cnt) 577 __field(loff_t, pos) 578 __field(int, ret) 579 ), 580 581 TP_fast_assign( 582 __entry->cnt = cnt; 583 __entry->pos = pos; 584 __entry->ret = ret; 585 ), 586 587 TP_printk("cnt:%d, pos:%llx", 588 __entry->cnt, __entry->pos, __entry->ret) 589); 590 591TRACE_EVENT(hmdfs_client_recv_readpage, 592 593 TP_PROTO(struct hmdfs_peer *con, unsigned long long remote_ino, 594 unsigned long page_index, int err), 595 596 TP_ARGS(con, remote_ino, page_index, err), 597 598 TP_STRUCT__entry( 599 __array(char, src, 128) 600 __field(uint64_t, remote_ino) 601 __field(unsigned long, page_index) 602 __field(uint64_t, device_id) 603 __field(int, err) 604 ), 605 606 TP_fast_assign( 607 strlcpy(__entry->src, con->sbi->local_src, 128); 608 __entry->remote_ino = remote_ino; 609 __entry->page_index = page_index; 610 __entry->device_id = con->device_id; 611 __entry->err = err; 612 ), 613 614 TP_printk("hmdfs: src %s, client readpage callback from remote device %llu, remote_ino=%llu, page_idx=%lu, err=%d", 615 __entry->src, __entry->device_id, 616 __entry->remote_ino, __entry->page_index, __entry->err) 617); 618 619TRACE_EVENT(hmdfs_writepage_cb_enter, 620 621 TP_PROTO(struct hmdfs_peer *con, unsigned long long remote_ino, 622 unsigned long page_index, int err), 623 624 TP_ARGS(con, remote_ino, page_index, err), 625 626 TP_STRUCT__entry( 627 __array(char, src, 128) 628 __field(uint64_t, remote_ino) 629 __field(unsigned long, page_index) 630 __field(uint64_t, device_id) 631 __field(int, err) 632 ), 633 634 TP_fast_assign( 635 strlcpy(__entry->src, con->sbi->local_src, 128); 636 __entry->remote_ino = remote_ino; 637 __entry->page_index = page_index; 638 __entry->device_id = con->device_id; 639 __entry->err = err; 640 ), 641 642 TP_printk("hmdfs: src %s, writepage_cb start, return from remote device %llu, remote_ino=%llu, page_idx=%lu, err=%d", 643 __entry->src, __entry->device_id, 644 __entry->remote_ino, __entry->page_index, __entry->err) 645); 646 647TRACE_EVENT(hmdfs_writepage_cb_exit, 648 649 TP_PROTO(struct hmdfs_peer *con, unsigned long long remote_ino, 650 unsigned long page_index, int err), 651 652 TP_ARGS(con, remote_ino, page_index, err), 653 654 TP_STRUCT__entry( 655 __array(char, src, 128) 656 __field(uint64_t, remote_ino) 657 __field(unsigned long, page_index) 658 __field(uint64_t, device_id) 659 __field(int, err) 660 ), 661 662 TP_fast_assign( 663 strlcpy(__entry->src, con->sbi->local_src, 128); 664 __entry->remote_ino = remote_ino; 665 __entry->page_index = page_index; 666 __entry->device_id = con->device_id; 667 __entry->err = err; 668 ), 669 670 TP_printk("hmdfs: src %s, writepage_cb exit, return from remote device %llu, remote_ino=%llu, page_index=%lu, err=%d", 671 __entry->src, __entry->device_id, 672 __entry->remote_ino, __entry->page_index, __entry->err) 673); 674 675TRACE_EVENT(hmdfs_server_rebuild_dents, 676 677 TP_PROTO(struct hmdfs_dcache_header *__h, int err), 678 679 TP_ARGS(__h, err), 680 681 TP_STRUCT__entry( 682 __field(uint64_t, crtime) 683 __field(uint64_t, crtime_nsec) 684 __field(uint64_t, ctime) 685 __field(uint64_t, ctime_nsec) 686 __field(uint64_t, num) 687 __field(int, err) 688 ), 689 690 TP_fast_assign( 691 __entry->crtime = le64_to_cpu(__h->dcache_crtime); 692 __entry->crtime_nsec = le64_to_cpu(__h->dcache_crtime_nsec); 693 __entry->ctime = le64_to_cpu(__h->dentry_ctime); 694 __entry->ctime_nsec = le64_to_cpu(__h->dentry_ctime_nsec); 695 __entry->num = le64_to_cpu(__h->num); 696 __entry->err = err; 697 ), 698 699 TP_printk("dcache crtime %llu:%llu ctime %llu:%llu has %llu dentry err %d", 700 __entry->crtime, __entry->crtime_nsec, __entry->ctime, 701 __entry->ctime_nsec, __entry->num, __entry->err) 702); 703 704TRACE_EVENT(hmdfs_server_readdir, 705 706 TP_PROTO(struct readdir_request *req), 707 708 TP_ARGS(req), 709 710 TP_STRUCT__entry( 711 __string(path, req->path) 712 ), 713 714 TP_fast_assign( 715 __assign_str(path, req->path); 716 ), 717 718 TP_printk("hmdfs_server_readdir %s", __get_str(path)) 719); 720 721TRACE_EVENT(hmdfs_open_final_remote, 722 723 TP_PROTO(struct hmdfs_inode_info *info, 724 struct hmdfs_open_ret *open_ret, 725 struct file *file, 726 int reason), 727 728 TP_ARGS(info, open_ret, file, reason), 729 730 TP_STRUCT__entry( 731 __array(char, file_path, MAX_FILTER_STR_VAL) 732 __field(uint32_t, reason) 733 __field(uint32_t, file_id) 734 __field(uint64_t, file_ver) 735 __field(uint64_t, remote_file_size) 736 __field(uint64_t, remote_ino) 737 __field(uint64_t, remote_ctime) 738 __field(uint64_t, remote_ctime_nsec) 739 __field(uint64_t, remote_stable_ctime) 740 __field(uint64_t, remote_stable_ctime_nsec) 741 __field(uint64_t, local_file_size) 742 __field(uint64_t, local_ino) 743 __field(uint64_t, local_ctime) 744 __field(uint64_t, local_ctime_nsec) 745 __field(uint64_t, local_stable_ctime) 746 __field(uint64_t, local_stable_ctime_nsec) 747 ), 748 749 TP_fast_assign( 750 strlcpy(__entry->file_path, file->f_path.dentry->d_name.name, 751 MAX_FILTER_STR_VAL); 752 __entry->reason = reason; 753 __entry->file_id = open_ret->fid.id; 754 __entry->file_ver = open_ret->fid.ver; 755 __entry->remote_file_size = open_ret->file_size; 756 __entry->remote_ino = open_ret->ino; 757 __entry->remote_ctime = open_ret->remote_ctime.tv_sec; 758 __entry->remote_ctime_nsec = open_ret->remote_ctime.tv_nsec; 759 __entry->remote_stable_ctime = open_ret->stable_ctime.tv_sec; 760 __entry->remote_stable_ctime_nsec = 761 open_ret->stable_ctime.tv_nsec; 762 __entry->local_file_size = info->vfs_inode.i_size; 763 __entry->local_ino = info->remote_ino; 764 __entry->local_ctime = info->remote_ctime.tv_sec; 765 __entry->local_ctime_nsec = info->remote_ctime.tv_nsec; 766 __entry->local_stable_ctime = info->stable_ctime.tv_sec; 767 __entry->local_stable_ctime_nsec = info->stable_ctime.tv_nsec; 768 ), 769 770 TP_printk("file path: %s, file id: %u, file ver: %llu, reason: %d, file size: %llu/%llu, ino: %llu/%llu, ctime: %llu.%llu/%llu.%llu, stable_ctime: %llu.%llu/%llu.%llu from remote/local", 771 __entry->file_path, __entry->file_id, __entry->file_ver, 772 __entry->reason, __entry->remote_file_size, 773 __entry->local_file_size, __entry->remote_ino, 774 __entry->local_ino, __entry->remote_ctime, 775 __entry->remote_ctime_nsec, __entry->local_ctime, 776 __entry->local_ctime_nsec, __entry->remote_stable_ctime, 777 __entry->remote_stable_ctime_nsec, 778 __entry->local_stable_ctime, __entry->local_stable_ctime_nsec) 779); 780 781TRACE_EVENT(hmdfs_server_open_enter, 782 783 TP_PROTO(struct hmdfs_peer *con, 784 struct open_request *recv), 785 786 TP_ARGS(con, recv), 787 788 TP_STRUCT__entry( 789 __array(char, open_path, MAX_FILTER_STR_VAL) 790 __array(char, dst_path, MAX_FILTER_STR_VAL) 791 __field(uint32_t, file_type) 792 ), 793 794 TP_fast_assign( 795 strlcpy(__entry->open_path, recv->buf, MAX_FILTER_STR_VAL); 796 strlcpy(__entry->dst_path, con->sbi->local_dst, 797 MAX_FILTER_STR_VAL); 798 __entry->file_type = recv->file_type; 799 ), 800 801 TP_printk("server open file %s from %s, file_type is %u", 802 __entry->open_path, __entry->dst_path, 803 __entry->file_type) 804); 805 806TRACE_EVENT(hmdfs_server_open_exit, 807 808 TP_PROTO(struct hmdfs_peer *con, 809 struct open_response *resp, 810 struct file *file, 811 int ret), 812 813 TP_ARGS(con, resp, file, ret), 814 815 TP_STRUCT__entry( 816 __array(char, file_path, MAX_FILTER_STR_VAL) 817 __array(char, src_path, MAX_FILTER_STR_VAL) 818 __field(uint32_t, file_id) 819 __field(uint64_t, file_size) 820 __field(uint64_t, ino) 821 __field(uint64_t, ctime) 822 __field(uint64_t, ctime_nsec) 823 __field(uint64_t, stable_ctime) 824 __field(uint64_t, stable_ctime_nsec) 825 __field(int, retval) 826 ), 827 828 TP_fast_assign( 829 if (file) 830 strlcpy(__entry->file_path, 831 file->f_path.dentry->d_name.name, 832 MAX_FILTER_STR_VAL); 833 else 834 strlcpy(__entry->file_path, "null", MAX_FILTER_STR_VAL); 835 strlcpy(__entry->src_path, con->sbi->local_src, 836 MAX_FILTER_STR_VAL); 837 __entry->file_id = resp ? resp->file_id : UINT_MAX; 838 __entry->file_size = resp ? resp->file_size : ULLONG_MAX; 839 __entry->ino = resp ? resp->ino : 0; 840 __entry->ctime = resp ? resp->ctime : 0; 841 __entry->ctime_nsec = resp ? resp->ctime_nsec : 0; 842 __entry->stable_ctime = resp ? resp->stable_ctime : 0; 843 __entry->stable_ctime_nsec = resp ? resp->stable_ctime_nsec : 0; 844 __entry->retval = ret; 845 ), 846 847 TP_printk("server file %s is opened from %s, open result: %d, file id: %u, file size: %llu, ino: %llu, ctime: %llu.%llu, stable ctime: %llu.%llu", 848 __entry->file_path, __entry->src_path, 849 __entry->retval, __entry->file_id, 850 __entry->file_size, __entry->ino, __entry->ctime, 851 __entry->ctime_nsec, __entry->stable_ctime, 852 __entry->stable_ctime_nsec) 853); 854 855TRACE_EVENT(hmdfs_merge_lookup_work_enter, 856 857 TP_PROTO(struct merge_lookup_work *ml_work), 858 859 TP_ARGS(ml_work), 860 861 TP_STRUCT__entry( 862 __field(int, devid) 863 __string(name, ml_work->name) 864 __field(unsigned int, flags) 865 ), 866 867 TP_fast_assign( 868 __entry->devid = ml_work->devid; 869 __assign_str(name, ml_work->name); 870 __entry->flags = ml_work->flags; 871 ), 872 873 TP_printk("devid = %d, name:%s, flags:%u", 874 __entry->devid, 875 __get_str(name), 876 __entry->flags) 877); 878 879TRACE_EVENT(hmdfs_merge_lookup_work_exit, 880 881 TP_PROTO(struct merge_lookup_work *ml_work, int found), 882 883 TP_ARGS(ml_work, found), 884 885 TP_STRUCT__entry( 886 __field(int, devid) 887 __string(name, ml_work->name) 888 __field(unsigned int, flags) 889 __field(int, found) 890 ), 891 892 TP_fast_assign( 893 __entry->devid = ml_work->devid; 894 __assign_str(name, ml_work->name); 895 __entry->flags = ml_work->flags; 896 __entry->found = found; 897 ), 898 899 TP_printk("devid = %d, name:%s, flags:%u, found:%d", 900 __entry->devid, 901 __get_str(name), 902 __entry->flags, 903 __entry->found) 904); 905 906TRACE_EVENT(hmdfs_merge_update_dentry_info_enter, 907 908 TP_PROTO(struct dentry *src_dentry, struct dentry *dst_dentry), 909 910 TP_ARGS(src_dentry, dst_dentry), 911 912 TP_STRUCT__entry( 913 __string(src_name, src_dentry->d_name.name) 914 __string(dst_name, dst_dentry->d_name.name) 915 ), 916 917 TP_fast_assign( 918 __assign_str(src_name, src_dentry->d_name.name); 919 __assign_str(dst_name, dst_dentry->d_name.name); 920 ), 921 922 TP_printk("src name:%s, dst name:%s", 923 __get_str(src_name), 924 __get_str(dst_name)) 925); 926 927TRACE_EVENT(hmdfs_merge_update_dentry_info_exit, 928 929 TP_PROTO(struct dentry *src_dentry, struct dentry *dst_dentry), 930 931 TP_ARGS(src_dentry, dst_dentry), 932 933 TP_STRUCT__entry( 934 __string(src_name, src_dentry->d_name.name) 935 __string(dst_name, dst_dentry->d_name.name) 936 ), 937 938 TP_fast_assign( 939 __assign_str(src_name, src_dentry->d_name.name); 940 __assign_str(dst_name, dst_dentry->d_name.name); 941 ), 942 943 TP_printk("src name:%s, dst name:%s", 944 __get_str(src_name), 945 __get_str(dst_name)) 946); 947 948#endif 949 950#undef TRACE_INCLUDE_PATH 951#undef TRACE_INCLUDE_FILE 952#define TRACE_INCLUDE_PATH . 953#define TRACE_INCLUDE_FILE hmdfs_trace 954#include <trace/define_trace.h> 955