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