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 23 TRACE_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 */ 36 TRACE_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 65 TRACE_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 */ 95 DECLARE_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 126 define_hmdfs_iterate_op_end_event(hmdfs_iterate_local); 127 define_hmdfs_iterate_op_end_event(hmdfs_iterate_remote); 128 define_hmdfs_iterate_op_end_event(hmdfs_iterate_merge); 129 130 131 TRACE_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 153 DECLARE_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 182 define_hmdfs_lookup_op_end_event(hmdfs_root_lookup); 183 define_hmdfs_lookup_op_end_event(hmdfs_root_lookup_end); 184 185 define_hmdfs_lookup_op_end_event(hmdfs_device_lookup); 186 define_hmdfs_lookup_op_end_event(hmdfs_device_lookup_end); 187 188 define_hmdfs_lookup_op_end_event(hmdfs_lookup_local); 189 define_hmdfs_lookup_op_end_event(hmdfs_lookup_local_end); 190 define_hmdfs_lookup_op_end_event(hmdfs_mkdir_local); 191 define_hmdfs_lookup_op_end_event(hmdfs_rmdir_local); 192 define_hmdfs_lookup_op_end_event(hmdfs_create_local); 193 194 define_hmdfs_lookup_op_end_event(hmdfs_lookup_remote); 195 define_hmdfs_lookup_op_end_event(hmdfs_lookup_remote_end); 196 define_hmdfs_lookup_op_end_event(hmdfs_mkdir_remote); 197 define_hmdfs_lookup_op_end_event(hmdfs_rmdir_remote); 198 define_hmdfs_lookup_op_end_event(hmdfs_create_remote); 199 200 define_hmdfs_lookup_op_end_event(hmdfs_lookup_merge); 201 define_hmdfs_lookup_op_end_event(hmdfs_lookup_merge_end); 202 define_hmdfs_lookup_op_end_event(hmdfs_mkdir_merge); 203 define_hmdfs_lookup_op_end_event(hmdfs_rmdir_merge); 204 define_hmdfs_lookup_op_end_event(hmdfs_create_merge); 205 206 define_hmdfs_lookup_op_end_event(hmdfs_lookup_share); 207 define_hmdfs_lookup_op_end_event(hmdfs_lookup_share_end); 208 209 TRACE_EVENT(hmdfs_show_comrade, 210 211 TP_PROTO(struct dentry *d, struct dentry *lo_d, uint64_t devid), 212 213 TP_ARGS(d, lo_d, devid), 214 215 TP_STRUCT__entry( 216 __string(name, d->d_name.name) 217 __string(lo_name, lo_d->d_name.name) 218 __field(uint64_t, devid) 219 ), 220 221 TP_fast_assign( 222 __assign_str(name, d->d_name.name) 223 __assign_str(lo_name, lo_d->d_name.name) 224 __entry->devid = devid; 225 ), 226 227 TP_printk("parent_name:%s -> lo_d_name:%s, lo_d_devid:%llu", 228 __get_str(name), __get_str(lo_name), __entry->devid) 229 ); 230 231 DECLARE_EVENT_CLASS(hmdfs_rename_op_end, 232 233 TP_PROTO(struct inode *olddir, struct dentry *olddentry, 234 struct inode *newdir, struct dentry *newdentry, 235 unsigned int flags), 236 237 TP_ARGS(olddir, olddentry, newdir, newdentry, flags), 238 239 TP_STRUCT__entry( 240 __field(ino_t, oldino) 241 __string(oldname_str, olddentry->d_name.name) 242 __field(ino_t, newino) 243 __string(newname_str, newdentry->d_name.name) 244 __field(unsigned int, flags) 245 ), 246 247 TP_fast_assign( 248 __entry->oldino = olddir->i_ino; 249 __assign_str(oldname_str, olddentry->d_name.name); 250 __entry->newino = newdir->i_ino; 251 __assign_str(newname_str, newdentry->d_name.name); 252 __entry->flags = flags; 253 ), 254 255 TP_printk("old_pino = %lu, oldname:%s; new_pino = %lu, newname:%s, flags:%u", 256 __entry->oldino, __get_str(oldname_str), 257 __entry->newino, __get_str(newname_str), __entry->flags) 258 ); 259 260 #define define_hmdfs_rename_op_end_event(event_name) \ 261 DEFINE_EVENT(hmdfs_rename_op_end, event_name, \ 262 TP_PROTO(struct inode *olddir, struct dentry *olddentry, \ 263 struct inode *newdir, struct dentry *newdentry, \ 264 unsigned int flags), \ 265 TP_ARGS(olddir, olddentry, newdir, newdentry, flags)) 266 267 define_hmdfs_rename_op_end_event(hmdfs_rename_local); 268 define_hmdfs_rename_op_end_event(hmdfs_rename_remote); 269 define_hmdfs_rename_op_end_event(hmdfs_rename_merge); 270 271 TRACE_EVENT(hmdfs_statfs, 272 273 TP_PROTO(struct dentry *d, uint8_t type), 274 275 TP_ARGS(d, type), 276 277 TP_STRUCT__entry( 278 __string(name, d->d_name.name) 279 __field(uint8_t, type) 280 ), 281 282 TP_fast_assign( 283 __assign_str(name, d->d_name.name) 284 __entry->type = type; 285 ), 286 287 TP_printk("dentry_name:%s, lo_d_devid:%u", 288 __get_str(name), __entry->type) 289 ); 290 291 292 293 TRACE_EVENT(hmdfs_balance_dirty_pages_ratelimited, 294 295 TP_PROTO(struct hmdfs_sb_info *sbi, 296 struct hmdfs_writeback *hwb, 297 int bdp_ratelimits), 298 299 TP_ARGS(sbi, hwb, bdp_ratelimits), 300 301 TP_STRUCT__entry( 302 __array(char, dst, 128) 303 __field(int, nr_dirtied) 304 __field(int, nr_dirtied_pause) 305 __field(int, dirty_exceeded) 306 __field(long long, bdp_ratelimits) 307 __field(long, ratelimit_pages) 308 ), 309 310 TP_fast_assign( 311 strlcpy(__entry->dst, sbi->local_dst, 128); 312 313 __entry->nr_dirtied = current->nr_dirtied; 314 __entry->nr_dirtied_pause = current->nr_dirtied_pause; 315 __entry->dirty_exceeded = hwb->dirty_exceeded; 316 __entry->bdp_ratelimits = bdp_ratelimits; 317 __entry->ratelimit_pages = hwb->ratelimit_pages; 318 ), 319 320 TP_printk("hmdfs dst:%s nr_dirtied=%d nr_dirtied_pause=%d dirty_exceeded=%d bdp_ratelimits=%lld ratelimit_pages=%ld", 321 __entry->dst, __entry->nr_dirtied, __entry->nr_dirtied_pause, 322 __entry->dirty_exceeded, __entry->bdp_ratelimits, 323 __entry->ratelimit_pages) 324 ); 325 326 TRACE_EVENT(hmdfs_balance_dirty_pages, 327 328 TP_PROTO(struct hmdfs_sb_info *sbi, 329 struct bdi_writeback *wb, 330 struct hmdfs_dirty_throttle_control *hdtc, 331 unsigned long pause, 332 unsigned long start_time), 333 334 TP_ARGS(sbi, wb, hdtc, pause, start_time), 335 336 TP_STRUCT__entry( 337 __array(char, dst, 128) 338 __field(unsigned long, write_bw) 339 __field(unsigned long, avg_write_bw) 340 __field(unsigned long, file_bg_thresh) 341 __field(unsigned long, fs_bg_thresh) 342 __field(unsigned long, file_thresh) 343 __field(unsigned long, fs_thresh) 344 __field(unsigned long, file_nr_dirty) 345 __field(unsigned long, fs_nr_dirty) 346 __field(unsigned long, file_nr_rec) 347 __field(unsigned long, fs_nr_rec) 348 __field(unsigned long, pause) 349 __field(unsigned long, paused) 350 ), 351 352 TP_fast_assign( 353 strlcpy(__entry->dst, sbi->local_dst, 128); 354 355 __entry->write_bw = wb->write_bandwidth; 356 __entry->avg_write_bw = wb->avg_write_bandwidth; 357 __entry->file_bg_thresh = hdtc->file_bg_thresh; 358 __entry->fs_bg_thresh = hdtc->fs_bg_thresh; 359 __entry->file_thresh = hdtc->file_thresh; 360 __entry->fs_thresh = hdtc->fs_thresh; 361 __entry->file_nr_dirty = hdtc->file_nr_dirty; 362 __entry->fs_nr_dirty = hdtc->fs_nr_dirty; 363 __entry->file_nr_rec = hdtc->file_nr_reclaimable; 364 __entry->fs_nr_rec = hdtc->fs_nr_reclaimable; 365 __entry->pause = pause * 1000 / HZ; 366 __entry->paused = (jiffies - start_time) * 367 1000 / HZ; 368 ), 369 370 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", 371 __entry->dst, __entry->write_bw, __entry->avg_write_bw, 372 __entry->file_bg_thresh, __entry->fs_bg_thresh, 373 __entry->file_thresh, __entry->fs_thresh, 374 __entry->file_nr_dirty, __entry->fs_nr_dirty, 375 __entry->file_nr_rec, __entry->fs_nr_rec, 376 __entry->pause, __entry->paused 377 ) 378 ); 379 380 TRACE_EVENT(hmdfs_start_srv_wb, 381 382 TP_PROTO(struct hmdfs_sb_info *sbi, int dirty_pages, 383 unsigned int dirty_thresh_pg), 384 385 TP_ARGS(sbi, dirty_pages, dirty_thresh_pg), 386 387 TP_STRUCT__entry( 388 __array(char, src, 128) 389 __field(int, dirty_pages) 390 __field(unsigned int, dirty_thresh_pg) 391 ), 392 393 TP_fast_assign( 394 strlcpy(__entry->src, sbi->local_src, 128); 395 __entry->dirty_pages = dirty_pages; 396 __entry->dirty_thresh_pg = dirty_thresh_pg; 397 ), 398 399 TP_printk("hmdfs src: %s, start writeback dirty pages. writeback %d pages dirty_thresh is %d pages", 400 __entry->src, __entry->dirty_pages, __entry->dirty_thresh_pg) 401 ); 402 403 TRACE_EVENT(hmdfs_fsync_enter_remote, 404 405 TP_PROTO(struct hmdfs_sb_info *sbi, unsigned long long device_id, 406 unsigned long long remote_ino, int datasync), 407 408 TP_ARGS(sbi, device_id, remote_ino, datasync), 409 410 TP_STRUCT__entry( 411 __array(char, src, 128) 412 __field(uint64_t, device_id) 413 __field(uint64_t, remote_ino) 414 __field(int, datasync) 415 ), 416 417 TP_fast_assign( 418 strlcpy(__entry->src, sbi->local_src, 128); 419 __entry->device_id = device_id; 420 __entry->remote_ino = remote_ino; 421 __entry->datasync = datasync; 422 ), 423 424 TP_printk("hmdfs: src %s, start remote fsync file(remote dev_id=%llu,ino=%llu), datasync=%d", 425 __entry->src, __entry->device_id, 426 __entry->remote_ino, __entry->datasync) 427 ); 428 429 TRACE_EVENT(hmdfs_fsync_exit_remote, 430 431 TP_PROTO(struct hmdfs_sb_info *sbi, unsigned long long device_id, 432 unsigned long long remote_ino, unsigned int timeout, int err), 433 434 TP_ARGS(sbi, device_id, remote_ino, timeout, err), 435 436 TP_STRUCT__entry( 437 __array(char, src, 128) 438 __field(uint64_t, device_id) 439 __field(uint64_t, remote_ino) 440 __field(uint32_t, timeout) 441 __field(int, err) 442 ), 443 444 TP_fast_assign( 445 strlcpy(__entry->src, sbi->local_src, 128); 446 __entry->device_id = device_id; 447 __entry->remote_ino = remote_ino; 448 __entry->timeout = timeout; 449 __entry->err = err; 450 ), 451 452 TP_printk("hmdfs: src %s, finish remote fsync file(remote dev_id=%llu,ino=%llu), timeout=%u, err=%d", 453 __entry->src, __entry->device_id, __entry->remote_ino, 454 __entry->timeout, __entry->err) 455 ); 456 457 TRACE_EVENT(hmdfs_syncfs_enter, 458 459 TP_PROTO(struct hmdfs_sb_info *sbi), 460 461 TP_ARGS(sbi), 462 463 TP_STRUCT__entry( 464 __array(char, src, 128) 465 ), 466 467 TP_fast_assign( 468 strlcpy(__entry->src, sbi->local_src, 128); 469 ), 470 471 TP_printk("hmdfs: src %s, start syncfs", __entry->src) 472 ); 473 474 TRACE_EVENT(hmdfs_syncfs_exit, 475 476 TP_PROTO(struct hmdfs_sb_info *sbi, int remain_count, 477 unsigned int timeout, int err), 478 479 TP_ARGS(sbi, remain_count, timeout, err), 480 481 TP_STRUCT__entry( 482 __array(char, src, 128) 483 __field(int, remain_count) 484 __field(uint32_t, timeout) 485 __field(int, err) 486 ), 487 488 TP_fast_assign( 489 strlcpy(__entry->src, sbi->local_src, 128); 490 __entry->remain_count = remain_count; 491 __entry->timeout = timeout; 492 __entry->err = err; 493 ), 494 495 TP_printk("hmdfs: src %s, finish syncfs(timeout=%u), remain %d remote devices to response, err=%d", 496 __entry->src, __entry->timeout, 497 __entry->remain_count, __entry->err) 498 ); 499 500 TRACE_EVENT(hmdfs_server_release, 501 502 TP_PROTO(struct hmdfs_peer *con, uint32_t file_id, 503 uint64_t file_ver, int err), 504 505 TP_ARGS(con, file_id, file_ver, err), 506 507 TP_STRUCT__entry( 508 __array(char, src, 128) 509 __field(uint32_t, file_id) 510 __field(uint64_t, file_ver) 511 __field(uint64_t, device_id) 512 __field(int, err) 513 ), 514 515 TP_fast_assign( 516 strlcpy(__entry->src, con->sbi->local_src, 128); 517 __entry->file_id = file_id; 518 __entry->file_ver = file_ver; 519 __entry->device_id = con->device_id; 520 __entry->err = err; 521 ), 522 523 TP_printk("hmdfs: src %s, server release file, fid=%u, fid_ver=%llu, remote_dev=%llu, err=%d", 524 __entry->src, __entry->file_id, __entry->file_ver, 525 __entry->device_id, __entry->err) 526 ); 527 528 TRACE_EVENT(hmdfs_client_recv_readpage, 529 530 TP_PROTO(struct hmdfs_peer *con, unsigned long long remote_ino, 531 unsigned long page_index, int err), 532 533 TP_ARGS(con, remote_ino, page_index, err), 534 535 TP_STRUCT__entry( 536 __array(char, src, 128) 537 __field(uint64_t, remote_ino) 538 __field(unsigned long, page_index) 539 __field(uint64_t, device_id) 540 __field(int, err) 541 ), 542 543 TP_fast_assign( 544 strlcpy(__entry->src, con->sbi->local_src, 128); 545 __entry->remote_ino = remote_ino; 546 __entry->page_index = page_index; 547 __entry->device_id = con->device_id; 548 __entry->err = err; 549 ), 550 551 TP_printk("hmdfs: src %s, client readpage callback from remote device %llu, remote_ino=%llu, page_idx=%lu, err=%d", 552 __entry->src, __entry->device_id, 553 __entry->remote_ino, __entry->page_index, __entry->err) 554 ); 555 556 TRACE_EVENT(hmdfs_writepage_cb_enter, 557 558 TP_PROTO(struct hmdfs_peer *con, unsigned long long remote_ino, 559 unsigned long page_index, int err), 560 561 TP_ARGS(con, remote_ino, page_index, err), 562 563 TP_STRUCT__entry( 564 __array(char, src, 128) 565 __field(uint64_t, remote_ino) 566 __field(unsigned long, page_index) 567 __field(uint64_t, device_id) 568 __field(int, err) 569 ), 570 571 TP_fast_assign( 572 strlcpy(__entry->src, con->sbi->local_src, 128); 573 __entry->remote_ino = remote_ino; 574 __entry->page_index = page_index; 575 __entry->device_id = con->device_id; 576 __entry->err = err; 577 ), 578 579 TP_printk("hmdfs: src %s, writepage_cb start, return from remote device %llu, remote_ino=%llu, page_idx=%lu, err=%d", 580 __entry->src, __entry->device_id, 581 __entry->remote_ino, __entry->page_index, __entry->err) 582 ); 583 584 TRACE_EVENT(hmdfs_writepage_cb_exit, 585 586 TP_PROTO(struct hmdfs_peer *con, unsigned long long remote_ino, 587 unsigned long page_index, int err), 588 589 TP_ARGS(con, remote_ino, page_index, err), 590 591 TP_STRUCT__entry( 592 __array(char, src, 128) 593 __field(uint64_t, remote_ino) 594 __field(unsigned long, page_index) 595 __field(uint64_t, device_id) 596 __field(int, err) 597 ), 598 599 TP_fast_assign( 600 strlcpy(__entry->src, con->sbi->local_src, 128); 601 __entry->remote_ino = remote_ino; 602 __entry->page_index = page_index; 603 __entry->device_id = con->device_id; 604 __entry->err = err; 605 ), 606 607 TP_printk("hmdfs: src %s, writepage_cb exit, return from remote device %llu, remote_ino=%llu, page_index=%lu, err=%d", 608 __entry->src, __entry->device_id, 609 __entry->remote_ino, __entry->page_index, __entry->err) 610 ); 611 612 TRACE_EVENT(hmdfs_server_rebuild_dents, 613 614 TP_PROTO(struct hmdfs_dcache_header *__h, int err), 615 616 TP_ARGS(__h, err), 617 618 TP_STRUCT__entry( 619 __field(uint64_t, crtime) 620 __field(uint64_t, crtime_nsec) 621 __field(uint64_t, ctime) 622 __field(uint64_t, ctime_nsec) 623 __field(uint64_t, num) 624 __field(int, err) 625 ), 626 627 TP_fast_assign( 628 __entry->crtime = le64_to_cpu(__h->dcache_crtime); 629 __entry->crtime_nsec = le64_to_cpu(__h->dcache_crtime_nsec); 630 __entry->ctime = le64_to_cpu(__h->dentry_ctime); 631 __entry->ctime_nsec = le64_to_cpu(__h->dentry_ctime_nsec); 632 __entry->num = le64_to_cpu(__h->num); 633 __entry->err = err; 634 ), 635 636 TP_printk("dcache crtime %llu:%llu ctime %llu:%llu has %llu dentry err %d", 637 __entry->crtime, __entry->crtime_nsec, __entry->ctime, 638 __entry->ctime_nsec, __entry->num, __entry->err) 639 ); 640 641 TRACE_EVENT(hmdfs_server_readdir, 642 643 TP_PROTO(struct readdir_request *req), 644 645 TP_ARGS(req), 646 647 TP_STRUCT__entry( 648 __string(path, req->path) 649 ), 650 651 TP_fast_assign( 652 __assign_str(path, req->path); 653 ), 654 655 TP_printk("hmdfs_server_readdir %s", __get_str(path)) 656 ); 657 658 TRACE_EVENT(hmdfs_open_final_remote, 659 660 TP_PROTO(struct hmdfs_inode_info *info, 661 struct hmdfs_open_ret *open_ret, 662 struct file *file, 663 int reason), 664 665 TP_ARGS(info, open_ret, file, reason), 666 667 TP_STRUCT__entry( 668 __array(char, file_path, MAX_FILTER_STR_VAL) 669 __field(uint32_t, reason) 670 __field(uint32_t, file_id) 671 __field(uint64_t, file_ver) 672 __field(uint64_t, remote_file_size) 673 __field(uint64_t, remote_ino) 674 __field(uint64_t, remote_ctime) 675 __field(uint64_t, remote_ctime_nsec) 676 __field(uint64_t, remote_stable_ctime) 677 __field(uint64_t, remote_stable_ctime_nsec) 678 __field(uint64_t, local_file_size) 679 __field(uint64_t, local_ino) 680 __field(uint64_t, local_ctime) 681 __field(uint64_t, local_ctime_nsec) 682 __field(uint64_t, local_stable_ctime) 683 __field(uint64_t, local_stable_ctime_nsec) 684 ), 685 686 TP_fast_assign( 687 strlcpy(__entry->file_path, file->f_path.dentry->d_name.name, 688 MAX_FILTER_STR_VAL); 689 __entry->reason = reason; 690 __entry->file_id = open_ret->fid.id; 691 __entry->file_ver = open_ret->fid.ver; 692 __entry->remote_file_size = open_ret->file_size; 693 __entry->remote_ino = open_ret->ino; 694 __entry->remote_ctime = open_ret->remote_ctime.tv_sec; 695 __entry->remote_ctime_nsec = open_ret->remote_ctime.tv_nsec; 696 __entry->remote_stable_ctime = open_ret->stable_ctime.tv_sec; 697 __entry->remote_stable_ctime_nsec = 698 open_ret->stable_ctime.tv_nsec; 699 __entry->local_file_size = info->vfs_inode.i_size; 700 __entry->local_ino = info->remote_ino; 701 __entry->local_ctime = info->remote_ctime.tv_sec; 702 __entry->local_ctime_nsec = info->remote_ctime.tv_nsec; 703 __entry->local_stable_ctime = info->stable_ctime.tv_sec; 704 __entry->local_stable_ctime_nsec = info->stable_ctime.tv_nsec; 705 ), 706 707 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", 708 __entry->file_path, __entry->file_id, __entry->file_ver, 709 __entry->reason, __entry->remote_file_size, 710 __entry->local_file_size, __entry->remote_ino, 711 __entry->local_ino, __entry->remote_ctime, 712 __entry->remote_ctime_nsec, __entry->local_ctime, 713 __entry->local_ctime_nsec, __entry->remote_stable_ctime, 714 __entry->remote_stable_ctime_nsec, 715 __entry->local_stable_ctime, __entry->local_stable_ctime_nsec) 716 ); 717 718 TRACE_EVENT(hmdfs_server_open_enter, 719 720 TP_PROTO(struct hmdfs_peer *con, 721 struct open_request *recv), 722 723 TP_ARGS(con, recv), 724 725 TP_STRUCT__entry( 726 __array(char, open_path, MAX_FILTER_STR_VAL) 727 __array(char, dst_path, MAX_FILTER_STR_VAL) 728 __field(uint32_t, file_type) 729 ), 730 731 TP_fast_assign( 732 strlcpy(__entry->open_path, recv->buf, MAX_FILTER_STR_VAL); 733 strlcpy(__entry->dst_path, con->sbi->local_dst, 734 MAX_FILTER_STR_VAL); 735 __entry->file_type = recv->file_type; 736 ), 737 738 TP_printk("server open file %s from %s, file_type is %u", 739 __entry->open_path, __entry->dst_path, 740 __entry->file_type) 741 ); 742 743 TRACE_EVENT(hmdfs_server_open_exit, 744 745 TP_PROTO(struct hmdfs_peer *con, 746 struct open_response *resp, 747 struct file *file, 748 int ret), 749 750 TP_ARGS(con, resp, file, ret), 751 752 TP_STRUCT__entry( 753 __array(char, file_path, MAX_FILTER_STR_VAL) 754 __array(char, src_path, MAX_FILTER_STR_VAL) 755 __field(uint32_t, file_id) 756 __field(uint64_t, file_size) 757 __field(uint64_t, ino) 758 __field(uint64_t, ctime) 759 __field(uint64_t, ctime_nsec) 760 __field(uint64_t, stable_ctime) 761 __field(uint64_t, stable_ctime_nsec) 762 __field(int, retval) 763 ), 764 765 TP_fast_assign( 766 if (file) 767 strlcpy(__entry->file_path, 768 file->f_path.dentry->d_name.name, 769 MAX_FILTER_STR_VAL); 770 else 771 strlcpy(__entry->file_path, "null", MAX_FILTER_STR_VAL); 772 strlcpy(__entry->src_path, con->sbi->local_src, 773 MAX_FILTER_STR_VAL); 774 __entry->file_id = resp ? resp->file_id : UINT_MAX; 775 __entry->file_size = resp ? resp->file_size : ULLONG_MAX; 776 __entry->ino = resp ? resp->ino : 0; 777 __entry->ctime = resp ? resp->ctime : 0; 778 __entry->ctime_nsec = resp ? resp->ctime_nsec : 0; 779 __entry->stable_ctime = resp ? resp->stable_ctime : 0; 780 __entry->stable_ctime_nsec = resp ? resp->stable_ctime_nsec : 0; 781 __entry->retval = ret; 782 ), 783 784 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", 785 __entry->file_path, __entry->src_path, 786 __entry->retval, __entry->file_id, 787 __entry->file_size, __entry->ino, __entry->ctime, 788 __entry->ctime_nsec, __entry->stable_ctime, 789 __entry->stable_ctime_nsec) 790 ); 791 792 TRACE_EVENT(hmdfs_merge_lookup_work_enter, 793 794 TP_PROTO(struct merge_lookup_work *ml_work), 795 796 TP_ARGS(ml_work), 797 798 TP_STRUCT__entry( 799 __field(int, devid) 800 __string(name, ml_work->name) 801 __field(unsigned int, flags) 802 ), 803 804 TP_fast_assign( 805 __entry->devid = ml_work->devid; 806 __assign_str(name, ml_work->name); 807 __entry->flags = ml_work->flags; 808 ), 809 810 TP_printk("devid = %d, name:%s, flags:%u", 811 __entry->devid, 812 __get_str(name), 813 __entry->flags) 814 ); 815 816 TRACE_EVENT(hmdfs_merge_lookup_work_exit, 817 818 TP_PROTO(struct merge_lookup_work *ml_work, int found), 819 820 TP_ARGS(ml_work, found), 821 822 TP_STRUCT__entry( 823 __field(int, devid) 824 __string(name, ml_work->name) 825 __field(unsigned int, flags) 826 __field(int, found) 827 ), 828 829 TP_fast_assign( 830 __entry->devid = ml_work->devid; 831 __assign_str(name, ml_work->name); 832 __entry->flags = ml_work->flags; 833 __entry->found = found; 834 ), 835 836 TP_printk("devid = %d, name:%s, flags:%u, found:%d", 837 __entry->devid, 838 __get_str(name), 839 __entry->flags, 840 __entry->found) 841 ); 842 843 TRACE_EVENT(hmdfs_merge_update_dentry_info_enter, 844 845 TP_PROTO(struct dentry *src_dentry, struct dentry *dst_dentry), 846 847 TP_ARGS(src_dentry, dst_dentry), 848 849 TP_STRUCT__entry( 850 __string(src_name, src_dentry->d_name.name) 851 __string(dst_name, dst_dentry->d_name.name) 852 ), 853 854 TP_fast_assign( 855 __assign_str(src_name, src_dentry->d_name.name); 856 __assign_str(dst_name, dst_dentry->d_name.name); 857 ), 858 859 TP_printk("src name:%s, dst name:%s", 860 __get_str(src_name), 861 __get_str(dst_name)) 862 ); 863 864 TRACE_EVENT(hmdfs_merge_update_dentry_info_exit, 865 866 TP_PROTO(struct dentry *src_dentry, struct dentry *dst_dentry), 867 868 TP_ARGS(src_dentry, dst_dentry), 869 870 TP_STRUCT__entry( 871 __string(src_name, src_dentry->d_name.name) 872 __string(dst_name, dst_dentry->d_name.name) 873 ), 874 875 TP_fast_assign( 876 __assign_str(src_name, src_dentry->d_name.name); 877 __assign_str(dst_name, dst_dentry->d_name.name); 878 ), 879 880 TP_printk("src name:%s, dst name:%s", 881 __get_str(src_name), 882 __get_str(dst_name)) 883 ); 884 885 #endif 886 887 #undef TRACE_INCLUDE_PATH 888 #undef TRACE_INCLUDE_FILE 889 #define TRACE_INCLUDE_PATH . 890 #define TRACE_INCLUDE_FILE hmdfs_trace 891 #include <trace/define_trace.h> 892