include/trace/events/sunrpc.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 #undef TRACE_SYSTEM
   3 #define TRACE_SYSTEM sunrpc
   4
   5 #if !defined(_TRACE_SUNRPC_H) || defined(TRACE_HEADER_MULTI_READ)
   6 #define _TRACE_SUNRPC_H
   7
   8 #include <linux/sunrpc/sched.h>
   9 #include <linux/sunrpc/clnt.h>
  10 #include <linux/sunrpc/svc.h>
  11 #include <linux/sunrpc/xprtsock.h>
  12 #include <linux/sunrpc/svc_xprt.h>
  13 #include <net/tcp_states.h>
  14 #include <linux/net.h>
  15 #include <linux/tracepoint.h>
  16
  17 DECLARE_EVENT_CLASS(rpc_task_status,
  18
  19         TP_PROTO(const struct rpc_task *task),
  20
  21         TP_ARGS(task),
  22
  23         TP_STRUCT__entry(
  24                 __field(unsigned int, task_id)
  25                 __field(unsigned int, client_id)
  26                 __field(int, status)
  27         ),
  28
  29         TP_fast_assign(
  30                 __entry->task_id = task->tk_pid;
  31                 __entry->client_id = task->tk_client->cl_clid;
  32                 __entry->status = task->tk_status;
  33         ),
  34
  35         TP_printk("task:%u@%u status=%d",
  36                 __entry->task_id, __entry->client_id,
  37                 __entry->status)
  38 );
  39 #define DEFINE_RPC_STATUS_EVENT(name) \
  40         DEFINE_EVENT(rpc_task_status, rpc_##name##_status, \
  41                         TP_PROTO( \
  42                                 const struct rpc_task *task \
  43                         ), \
  44                         TP_ARGS(task))
  45
  46 DEFINE_RPC_STATUS_EVENT(call);
  47 DEFINE_RPC_STATUS_EVENT(bind);
  48 DEFINE_RPC_STATUS_EVENT(connect);
  49
  50 TRACE_EVENT(rpc_request,
  51         TP_PROTO(const struct rpc_task *task),
  52
  53         TP_ARGS(task),
  54
  55         TP_STRUCT__entry(
  56                 __field(unsigned int, task_id)
  57                 __field(unsigned int, client_id)
  58                 __field(int, version)
  59                 __field(bool, async)
  60                 __string(progname, task->tk_client->cl_program->name)
  61                 __string(procname, rpc_proc_name(task))
  62         ),
  63
  64         TP_fast_assign(
  65                 __entry->task_id = task->tk_pid;
  66                 __entry->client_id = task->tk_client->cl_clid;
  67                 __entry->version = task->tk_client->cl_vers;
  68                 __entry->async = RPC_IS_ASYNC(task);
  69                 __assign_str(progname, task->tk_client->cl_program->name)
  70                 __assign_str(procname, rpc_proc_name(task))
  71         ),
  72
  73         TP_printk("task:%u@%u %sv%d %s (%ssync)",
  74                 __entry->task_id, __entry->client_id,
  75                 __get_str(progname), __entry->version,
  76                 __get_str(procname), __entry->async ? "a": ""
  77                 )
  78 );
  79
  80 TRACE_DEFINE_ENUM(RPC_TASK_ASYNC);
  81 TRACE_DEFINE_ENUM(RPC_TASK_SWAPPER);
  82 TRACE_DEFINE_ENUM(RPC_CALL_MAJORSEEN);
  83 TRACE_DEFINE_ENUM(RPC_TASK_ROOTCREDS);
  84 TRACE_DEFINE_ENUM(RPC_TASK_DYNAMIC);
  85 TRACE_DEFINE_ENUM(RPC_TASK_SOFT);
  86 TRACE_DEFINE_ENUM(RPC_TASK_SOFTCONN);
  87 TRACE_DEFINE_ENUM(RPC_TASK_SENT);
  88 TRACE_DEFINE_ENUM(RPC_TASK_TIMEOUT);
  89 TRACE_DEFINE_ENUM(RPC_TASK_NOCONNECT);
  90 TRACE_DEFINE_ENUM(RPC_TASK_NO_RETRANS_TIMEOUT);
  91
  92 #define rpc_show_task_flags(flags)                                      \
  93         __print_flags(flags, "|",                                       \
  94                 { RPC_TASK_ASYNC, "ASYNC" },                            \
  95                 { RPC_TASK_SWAPPER, "SWAPPER" },                        \
  96                 { RPC_CALL_MAJORSEEN, "MAJORSEEN" },                    \
  97                 { RPC_TASK_ROOTCREDS, "ROOTCREDS" },                    \
  98                 { RPC_TASK_DYNAMIC, "DYNAMIC" },                        \
  99                 { RPC_TASK_SOFT, "SOFT" },                              \
 100                 { RPC_TASK_SOFTCONN, "SOFTCONN" },                      \
 101                 { RPC_TASK_SENT, "SENT" },                              \
 102                 { RPC_TASK_TIMEOUT, "TIMEOUT" },                        \
 103                 { RPC_TASK_NOCONNECT, "NOCONNECT" },                    \
 104                 { RPC_TASK_NO_RETRANS_TIMEOUT, "NORTO" })
 105
 106 TRACE_DEFINE_ENUM(RPC_TASK_RUNNING);
 107 TRACE_DEFINE_ENUM(RPC_TASK_QUEUED);
 108 TRACE_DEFINE_ENUM(RPC_TASK_ACTIVE);
 109 TRACE_DEFINE_ENUM(RPC_TASK_NEED_XMIT);
 110 TRACE_DEFINE_ENUM(RPC_TASK_NEED_RECV);
 111 TRACE_DEFINE_ENUM(RPC_TASK_MSG_PIN_WAIT);
 112 TRACE_DEFINE_ENUM(RPC_TASK_SIGNALLED);
 113
 114 #define rpc_show_runstate(flags)                                        \
 115         __print_flags(flags, "|",                                       \
 116                 { (1UL << RPC_TASK_RUNNING), "RUNNING" },               \
 117                 { (1UL << RPC_TASK_QUEUED), "QUEUED" },                 \
 118                 { (1UL << RPC_TASK_ACTIVE), "ACTIVE" },                 \
 119                 { (1UL << RPC_TASK_NEED_XMIT), "NEED_XMIT" },           \
 120                 { (1UL << RPC_TASK_NEED_RECV), "NEED_RECV" },           \
 121                 { (1UL << RPC_TASK_MSG_PIN_WAIT), "MSG_PIN_WAIT" },     \
 122                 { (1UL << RPC_TASK_SIGNALLED), "SIGNALLED" })
 123
 124 DECLARE_EVENT_CLASS(rpc_task_running,
 125
 126         TP_PROTO(const struct rpc_task *task, const void *action),
 127
 128         TP_ARGS(task, action),
 129
 130         TP_STRUCT__entry(
 131                 __field(unsigned int, task_id)
 132                 __field(unsigned int, client_id)
 133                 __field(const void *, action)
 134                 __field(unsigned long, runstate)
 135                 __field(int, status)
 136                 __field(unsigned short, flags)
 137                 ),
 138
 139         TP_fast_assign(
 140                 __entry->client_id = task->tk_client ?
 141                                      task->tk_client->cl_clid : -1;
 142                 __entry->task_id = task->tk_pid;
 143                 __entry->action = action;
 144                 __entry->runstate = task->tk_runstate;
 145                 __entry->status = task->tk_status;
 146                 __entry->flags = task->tk_flags;
 147                 ),
 148
 149         TP_printk("task:%u@%d flags=%s runstate=%s status=%d action=%ps",
 150                 __entry->task_id, __entry->client_id,
 151                 rpc_show_task_flags(__entry->flags),
 152                 rpc_show_runstate(__entry->runstate),
 153                 __entry->status,
 154                 __entry->action
 155                 )
 156 );
 157 #define DEFINE_RPC_RUNNING_EVENT(name) \
 158         DEFINE_EVENT(rpc_task_running, rpc_task_##name, \
 159                         TP_PROTO( \
 160                                 const struct rpc_task *task, \
 161                                 const void *action \
 162                         ), \
 163                         TP_ARGS(task, action))
 164
 165 DEFINE_RPC_RUNNING_EVENT(begin);
 166 DEFINE_RPC_RUNNING_EVENT(run_action);
 167 DEFINE_RPC_RUNNING_EVENT(complete);
 168 DEFINE_RPC_RUNNING_EVENT(end);
 169
 170 DECLARE_EVENT_CLASS(rpc_task_queued,
 171
 172         TP_PROTO(const struct rpc_task *task, const struct rpc_wait_queue *q),
 173
 174         TP_ARGS(task, q),
 175
 176         TP_STRUCT__entry(
 177                 __field(unsigned int, task_id)
 178                 __field(unsigned int, client_id)
 179                 __field(unsigned long, timeout)
 180                 __field(unsigned long, runstate)
 181                 __field(int, status)
 182                 __field(unsigned short, flags)
 183                 __string(q_name, rpc_qname(q))
 184                 ),
 185
 186         TP_fast_assign(
 187                 __entry->client_id = task->tk_client ?
 188                                      task->tk_client->cl_clid : -1;
 189                 __entry->task_id = task->tk_pid;
 190                 __entry->timeout = rpc_task_timeout(task);
 191                 __entry->runstate = task->tk_runstate;
 192                 __entry->status = task->tk_status;
 193                 __entry->flags = task->tk_flags;
 194                 __assign_str(q_name, rpc_qname(q));
 195                 ),
 196
 197         TP_printk("task:%u@%d flags=%s runstate=%s status=%d timeout=%lu queue=%s",
 198                 __entry->task_id, __entry->client_id,
 199                 rpc_show_task_flags(__entry->flags),
 200                 rpc_show_runstate(__entry->runstate),
 201                 __entry->status,
 202                 __entry->timeout,
 203                 __get_str(q_name)
 204                 )
 205 );
 206 #define DEFINE_RPC_QUEUED_EVENT(name) \
 207         DEFINE_EVENT(rpc_task_queued, rpc_task_##name, \
 208                         TP_PROTO( \
 209                                 const struct rpc_task *task, \
 210                                 const struct rpc_wait_queue *q \
 211                         ), \
 212                         TP_ARGS(task, q))
 213
 214 DEFINE_RPC_QUEUED_EVENT(sleep);
 215 DEFINE_RPC_QUEUED_EVENT(wakeup);
 216
 217 DECLARE_EVENT_CLASS(rpc_failure,
 218
 219         TP_PROTO(const struct rpc_task *task),
 220
 221         TP_ARGS(task),
 222
 223         TP_STRUCT__entry(
 224                 __field(unsigned int, task_id)
 225                 __field(unsigned int, client_id)
 226         ),
 227
 228         TP_fast_assign(
 229                 __entry->task_id = task->tk_pid;
 230                 __entry->client_id = task->tk_client->cl_clid;
 231         ),
 232
 233         TP_printk("task:%u@%u",
 234                 __entry->task_id, __entry->client_id)
 235 );
 236
 237 #define DEFINE_RPC_FAILURE(name)                                        \
 238         DEFINE_EVENT(rpc_failure, rpc_bad_##name,                       \
 239                         TP_PROTO(                                       \
 240                                 const struct rpc_task *task             \
 241                         ),                                              \
 242                         TP_ARGS(task))
 243
 244 DEFINE_RPC_FAILURE(callhdr);
 245 DEFINE_RPC_FAILURE(verifier);
 246
 247 DECLARE_EVENT_CLASS(rpc_reply_event,
 248
 249         TP_PROTO(
 250                 const struct rpc_task *task
 251         ),
 252
 253         TP_ARGS(task),
 254
 255         TP_STRUCT__entry(
 256                 __field(unsigned int, task_id)
 257                 __field(unsigned int, client_id)
 258                 __field(u32, xid)
 259                 __string(progname, task->tk_client->cl_program->name)
 260                 __field(u32, version)
 261                 __string(procname, rpc_proc_name(task))
 262                 __string(servername, task->tk_xprt->servername)
 263         ),
 264
 265         TP_fast_assign(
 266                 __entry->task_id = task->tk_pid;
 267                 __entry->client_id = task->tk_client->cl_clid;
 268                 __entry->xid = be32_to_cpu(task->tk_rqstp->rq_xid);
 269                 __assign_str(progname, task->tk_client->cl_program->name)
 270                 __entry->version = task->tk_client->cl_vers;
 271                 __assign_str(procname, rpc_proc_name(task))
 272                 __assign_str(servername, task->tk_xprt->servername)
 273         ),
 274
 275         TP_printk("task:%u@%d server=%s xid=0x%08x %sv%d %s",
 276                 __entry->task_id, __entry->client_id, __get_str(servername),
 277                 __entry->xid, __get_str(progname), __entry->version,
 278                 __get_str(procname))
 279 )
 280
 281 #define DEFINE_RPC_REPLY_EVENT(name)                                    \
 282         DEFINE_EVENT(rpc_reply_event, rpc__##name,                      \
 283                         TP_PROTO(                                       \
 284                                 const struct rpc_task *task             \
 285                         ),                                              \
 286                         TP_ARGS(task))
 287
 288 DEFINE_RPC_REPLY_EVENT(prog_unavail);
 289 DEFINE_RPC_REPLY_EVENT(prog_mismatch);
 290 DEFINE_RPC_REPLY_EVENT(proc_unavail);
 291 DEFINE_RPC_REPLY_EVENT(garbage_args);
 292 DEFINE_RPC_REPLY_EVENT(unparsable);
 293 DEFINE_RPC_REPLY_EVENT(mismatch);
 294 DEFINE_RPC_REPLY_EVENT(stale_creds);
 295 DEFINE_RPC_REPLY_EVENT(bad_creds);
 296 DEFINE_RPC_REPLY_EVENT(auth_tooweak);
 297
 298 TRACE_EVENT(rpc_stats_latency,
 299
 300         TP_PROTO(
 301                 const struct rpc_task *task,
 302                 ktime_t backlog,
 303                 ktime_t rtt,
 304                 ktime_t execute
 305         ),
 306
 307         TP_ARGS(task, backlog, rtt, execute),
 308
 309         TP_STRUCT__entry(
 310                 __field(unsigned int, task_id)
 311                 __field(unsigned int, client_id)
 312                 __field(u32, xid)
 313                 __field(int, version)
 314                 __string(progname, task->tk_client->cl_program->name)
 315                 __string(procname, rpc_proc_name(task))
 316                 __field(unsigned long, backlog)
 317                 __field(unsigned long, rtt)
 318                 __field(unsigned long, execute)
 319         ),
 320
 321         TP_fast_assign(
 322                 __entry->client_id = task->tk_client->cl_clid;
 323                 __entry->task_id = task->tk_pid;
 324                 __entry->xid = be32_to_cpu(task->tk_rqstp->rq_xid);
 325                 __entry->version = task->tk_client->cl_vers;
 326                 __assign_str(progname, task->tk_client->cl_program->name)
 327                 __assign_str(procname, rpc_proc_name(task))
 328                 __entry->backlog = ktime_to_us(backlog);
 329                 __entry->rtt = ktime_to_us(rtt);
 330                 __entry->execute = ktime_to_us(execute);
 331         ),
 332
 333         TP_printk("task:%u@%d xid=0x%08x %sv%d %s backlog=%lu rtt=%lu execute=%lu",
 334                 __entry->task_id, __entry->client_id, __entry->xid,
 335                 __get_str(progname), __entry->version, __get_str(procname),
 336                 __entry->backlog, __entry->rtt, __entry->execute)
 337 );
 338
 339 TRACE_EVENT(rpc_xdr_overflow,
 340         TP_PROTO(
 341                 const struct xdr_stream *xdr,
 342                 size_t requested
 343         ),
 344
 345         TP_ARGS(xdr, requested),
 346
 347         TP_STRUCT__entry(
 348                 __field(unsigned int, task_id)
 349                 __field(unsigned int, client_id)
 350                 __field(int, version)
 351                 __field(size_t, requested)
 352                 __field(const void *, end)
 353                 __field(const void *, p)
 354                 __field(const void *, head_base)
 355                 __field(size_t, head_len)
 356                 __field(const void *, tail_base)
 357                 __field(size_t, tail_len)
 358                 __field(unsigned int, page_len)
 359                 __field(unsigned int, len)
 360                 __string(progname, xdr->rqst ?
 361                          xdr->rqst->rq_task->tk_client->cl_program->name : "unknown")
 362                 __string(procedure, xdr->rqst ?
 363                          xdr->rqst->rq_task->tk_msg.rpc_proc->p_name : "unknown")
 364         ),
 365
 366         TP_fast_assign(
 367                 if (xdr->rqst) {
 368                         const struct rpc_task *task = xdr->rqst->rq_task;
 369
 370                         __entry->task_id = task->tk_pid;
 371                         __entry->client_id = task->tk_client->cl_clid;
 372                         __assign_str(progname,
 373                                      task->tk_client->cl_program->name)
 374                         __entry->version = task->tk_client->cl_vers;
 375                         __assign_str(procedure, task->tk_msg.rpc_proc->p_name)
 376                 } else {
 377                         __entry->task_id = 0;
 378                         __entry->client_id = 0;
 379                         __assign_str(progname, "unknown")
 380                         __entry->version = 0;
 381                         __assign_str(procedure, "unknown")
 382                 }
 383                 __entry->requested = requested;
 384                 __entry->end = xdr->end;
 385                 __entry->p = xdr->p;
 386                 __entry->head_base = xdr->buf->head[0].iov_base,
 387                 __entry->head_len = xdr->buf->head[0].iov_len,
 388                 __entry->page_len = xdr->buf->page_len,
 389                 __entry->tail_base = xdr->buf->tail[0].iov_base,
 390                 __entry->tail_len = xdr->buf->tail[0].iov_len,
 391                 __entry->len = xdr->buf->len;
 392         ),
 393
 394         TP_printk(
 395                 "task:%u@%u %sv%d %s requested=%zu p=%p end=%p xdr=[%p,%zu]/%u/[%p,%zu]/%u\n",
 396                 __entry->task_id, __entry->client_id,
 397                 __get_str(progname), __entry->version, __get_str(procedure),
 398                 __entry->requested, __entry->p, __entry->end,
 399                 __entry->head_base, __entry->head_len,
 400                 __entry->page_len,
 401                 __entry->tail_base, __entry->tail_len,
 402                 __entry->len
 403         )
 404 );
 405
 406 TRACE_EVENT(rpc_xdr_alignment,
 407         TP_PROTO(
 408                 const struct xdr_stream *xdr,
 409                 size_t offset,
 410                 unsigned int copied
 411         ),
 412
 413         TP_ARGS(xdr, offset, copied),
 414
 415         TP_STRUCT__entry(
 416                 __field(unsigned int, task_id)
 417                 __field(unsigned int, client_id)
 418                 __field(int, version)
 419                 __field(size_t, offset)
 420                 __field(unsigned int, copied)
 421                 __field(const void *, head_base)
 422                 __field(size_t, head_len)
 423                 __field(const void *, tail_base)
 424                 __field(size_t, tail_len)
 425                 __field(unsigned int, page_len)
 426                 __field(unsigned int, len)
 427                 __string(progname,
 428                          xdr->rqst->rq_task->tk_client->cl_program->name)
 429                 __string(procedure,
 430                          xdr->rqst->rq_task->tk_msg.rpc_proc->p_name)
 431         ),
 432
 433         TP_fast_assign(
 434                 const struct rpc_task *task = xdr->rqst->rq_task;
 435
 436                 __entry->task_id = task->tk_pid;
 437                 __entry->client_id = task->tk_client->cl_clid;
 438                 __assign_str(progname,
 439                              task->tk_client->cl_program->name)
 440                 __entry->version = task->tk_client->cl_vers;
 441                 __assign_str(procedure, task->tk_msg.rpc_proc->p_name)
 442
 443                 __entry->offset = offset;
 444                 __entry->copied = copied;
 445                 __entry->head_base = xdr->buf->head[0].iov_base,
 446                 __entry->head_len = xdr->buf->head[0].iov_len,
 447                 __entry->page_len = xdr->buf->page_len,
 448                 __entry->tail_base = xdr->buf->tail[0].iov_base,
 449                 __entry->tail_len = xdr->buf->tail[0].iov_len,
 450                 __entry->len = xdr->buf->len;
 451         ),
 452
 453         TP_printk(
 454                 "task:%u@%u %sv%d %s offset=%zu copied=%u xdr=[%p,%zu]/%u/[%p,%zu]/%u\n",
 455                 __entry->task_id, __entry->client_id,
 456                 __get_str(progname), __entry->version, __get_str(procedure),
 457                 __entry->offset, __entry->copied,
 458                 __entry->head_base, __entry->head_len,
 459                 __entry->page_len,
 460                 __entry->tail_base, __entry->tail_len,
 461                 __entry->len
 462         )
 463 );
 464
 465 TRACE_EVENT(rpc_reply_pages,
 466         TP_PROTO(
 467                 const struct rpc_rqst *req
 468         ),
 469
 470         TP_ARGS(req),
 471
 472         TP_STRUCT__entry(
 473                 __field(unsigned int, task_id)
 474                 __field(unsigned int, client_id)
 475                 __field(const void *, head_base)
 476                 __field(size_t, head_len)
 477                 __field(const void *, tail_base)
 478                 __field(size_t, tail_len)
 479                 __field(unsigned int, page_len)
 480         ),
 481
 482         TP_fast_assign(
 483                 __entry->task_id = req->rq_task->tk_pid;
 484                 __entry->client_id = req->rq_task->tk_client->cl_clid;
 485
 486                 __entry->head_base = req->rq_rcv_buf.head[0].iov_base;
 487                 __entry->head_len = req->rq_rcv_buf.head[0].iov_len;
 488                 __entry->page_len = req->rq_rcv_buf.page_len;
 489                 __entry->tail_base = req->rq_rcv_buf.tail[0].iov_base;
 490                 __entry->tail_len = req->rq_rcv_buf.tail[0].iov_len;
 491         ),
 492
 493         TP_printk(
 494                 "task:%u@%u xdr=[%p,%zu]/%u/[%p,%zu]\n",
 495                 __entry->task_id, __entry->client_id,
 496                 __entry->head_base, __entry->head_len,
 497                 __entry->page_len,
 498                 __entry->tail_base, __entry->tail_len
 499         )
 500 );
 501
 502 /*
 503  * First define the enums in the below macros to be exported to userspace
 504  * via TRACE_DEFINE_ENUM().
 505  */
 506 #undef EM
 507 #undef EMe
 508 #define EM(a, b)        TRACE_DEFINE_ENUM(a);
 509 #define EMe(a, b)       TRACE_DEFINE_ENUM(a);
 510
 511 #define RPC_SHOW_SOCKET                         \
 512         EM( SS_FREE, "FREE" )                   \
 513         EM( SS_UNCONNECTED, "UNCONNECTED" )     \
 514         EM( SS_CONNECTING, "CONNECTING," )      \
 515         EM( SS_CONNECTED, "CONNECTED," )        \
 516         EMe(SS_DISCONNECTING, "DISCONNECTING" )
 517
 518 #define rpc_show_socket_state(state) \
 519         __print_symbolic(state, RPC_SHOW_SOCKET)
 520
 521 RPC_SHOW_SOCKET
 522
 523 #define RPC_SHOW_SOCK                           \
 524         EM( TCP_ESTABLISHED, "ESTABLISHED" )    \
 525         EM( TCP_SYN_SENT, "SYN_SENT" )          \
 526         EM( TCP_SYN_RECV, "SYN_RECV" )          \
 527         EM( TCP_FIN_WAIT1, "FIN_WAIT1" )        \
 528         EM( TCP_FIN_WAIT2, "FIN_WAIT2" )        \
 529         EM( TCP_TIME_WAIT, "TIME_WAIT" )        \
 530         EM( TCP_CLOSE, "CLOSE" )                \
 531         EM( TCP_CLOSE_WAIT, "CLOSE_WAIT" )      \
 532         EM( TCP_LAST_ACK, "LAST_ACK" )          \
 533         EM( TCP_LISTEN, "LISTEN" )              \
 534         EMe( TCP_CLOSING, "CLOSING" )
 535
 536 #define rpc_show_sock_state(state) \
 537         __print_symbolic(state, RPC_SHOW_SOCK)
 538
 539 RPC_SHOW_SOCK
 540
 541 /*
 542  * Now redefine the EM() and EMe() macros to map the enums to the strings
 543  * that will be printed in the output.
 544  */
 545 #undef EM
 546 #undef EMe
 547 #define EM(a, b)        {a, b},
 548 #define EMe(a, b)       {a, b}
 549
 550 DECLARE_EVENT_CLASS(xs_socket_event,
 551
 552                 TP_PROTO(
 553                         struct rpc_xprt *xprt,
 554                         struct socket *socket
 555                 ),
 556
 557                 TP_ARGS(xprt, socket),
 558
 559                 TP_STRUCT__entry(
 560                         __field(unsigned int, socket_state)
 561                         __field(unsigned int, sock_state)
 562                         __field(unsigned long long, ino)
 563                         __string(dstaddr,
 564                                 xprt->address_strings[RPC_DISPLAY_ADDR])
 565                         __string(dstport,
 566                                 xprt->address_strings[RPC_DISPLAY_PORT])
 567                 ),
 568
 569                 TP_fast_assign(
 570                         struct inode *inode = SOCK_INODE(socket);
 571                         __entry->socket_state = socket->state;
 572                         __entry->sock_state = socket->sk->sk_state;
 573                         __entry->ino = (unsigned long long)inode->i_ino;
 574                         __assign_str(dstaddr,
 575                                 xprt->address_strings[RPC_DISPLAY_ADDR]);
 576                         __assign_str(dstport,
 577                                 xprt->address_strings[RPC_DISPLAY_PORT]);
 578                 ),
 579
 580                 TP_printk(
 581                         "socket:[%llu] dstaddr=%s/%s "
 582                         "state=%u (%s) sk_state=%u (%s)",
 583                         __entry->ino, __get_str(dstaddr), __get_str(dstport),
 584                         __entry->socket_state,
 585                         rpc_show_socket_state(__entry->socket_state),
 586                         __entry->sock_state,
 587                         rpc_show_sock_state(__entry->sock_state)
 588                 )
 589 );
 590 #define DEFINE_RPC_SOCKET_EVENT(name) \
 591         DEFINE_EVENT(xs_socket_event, name, \
 592                         TP_PROTO( \
 593                                 struct rpc_xprt *xprt, \
 594                                 struct socket *socket \
 595                         ), \
 596                         TP_ARGS(xprt, socket))
 597
 598 DECLARE_EVENT_CLASS(xs_socket_event_done,
 599
 600                 TP_PROTO(
 601                         struct rpc_xprt *xprt,
 602                         struct socket *socket,
 603                         int error
 604                 ),
 605
 606                 TP_ARGS(xprt, socket, error),
 607
 608                 TP_STRUCT__entry(
 609                         __field(int, error)
 610                         __field(unsigned int, socket_state)
 611                         __field(unsigned int, sock_state)
 612                         __field(unsigned long long, ino)
 613                         __string(dstaddr,
 614                                 xprt->address_strings[RPC_DISPLAY_ADDR])
 615                         __string(dstport,
 616                                 xprt->address_strings[RPC_DISPLAY_PORT])
 617                 ),
 618
 619                 TP_fast_assign(
 620                         struct inode *inode = SOCK_INODE(socket);
 621                         __entry->socket_state = socket->state;
 622                         __entry->sock_state = socket->sk->sk_state;
 623                         __entry->ino = (unsigned long long)inode->i_ino;
 624                         __entry->error = error;
 625                         __assign_str(dstaddr,
 626                                 xprt->address_strings[RPC_DISPLAY_ADDR]);
 627                         __assign_str(dstport,
 628                                 xprt->address_strings[RPC_DISPLAY_PORT]);
 629                 ),
 630
 631                 TP_printk(
 632                         "error=%d socket:[%llu] dstaddr=%s/%s "
 633                         "state=%u (%s) sk_state=%u (%s)",
 634                         __entry->error,
 635                         __entry->ino, __get_str(dstaddr), __get_str(dstport),
 636                         __entry->socket_state,
 637                         rpc_show_socket_state(__entry->socket_state),
 638                         __entry->sock_state,
 639                         rpc_show_sock_state(__entry->sock_state)
 640                 )
 641 );
 642 #define DEFINE_RPC_SOCKET_EVENT_DONE(name) \
 643         DEFINE_EVENT(xs_socket_event_done, name, \
 644                         TP_PROTO( \
 645                                 struct rpc_xprt *xprt, \
 646                                 struct socket *socket, \
 647                                 int error \
 648                         ), \
 649                         TP_ARGS(xprt, socket, error))
 650
 651 DEFINE_RPC_SOCKET_EVENT(rpc_socket_state_change);
 652 DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_connect);
 653 DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_error);
 654 DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_reset_connection);
 655 DEFINE_RPC_SOCKET_EVENT(rpc_socket_close);
 656 DEFINE_RPC_SOCKET_EVENT(rpc_socket_shutdown);
 657
 658 DECLARE_EVENT_CLASS(rpc_xprt_event,
 659         TP_PROTO(
 660                 const struct rpc_xprt *xprt,
 661                 __be32 xid,
 662                 int status
 663         ),
 664
 665         TP_ARGS(xprt, xid, status),
 666
 667         TP_STRUCT__entry(
 668                 __field(u32, xid)
 669                 __field(int, status)
 670                 __string(addr, xprt->address_strings[RPC_DISPLAY_ADDR])
 671                 __string(port, xprt->address_strings[RPC_DISPLAY_PORT])
 672         ),
 673
 674         TP_fast_assign(
 675                 __entry->xid = be32_to_cpu(xid);
 676                 __entry->status = status;
 677                 __assign_str(addr, xprt->address_strings[RPC_DISPLAY_ADDR]);
 678                 __assign_str(port, xprt->address_strings[RPC_DISPLAY_PORT]);
 679         ),
 680
 681         TP_printk("peer=[%s]:%s xid=0x%08x status=%d", __get_str(addr),
 682                         __get_str(port), __entry->xid,
 683                         __entry->status)
 684 );
 685 #define DEFINE_RPC_XPRT_EVENT(name) \
 686         DEFINE_EVENT(rpc_xprt_event, xprt_##name, \
 687                         TP_PROTO( \
 688                                 const struct rpc_xprt *xprt, \
 689                                 __be32 xid, \
 690                                 int status \
 691                         ), \
 692                         TP_ARGS(xprt, xid, status))
 693
 694 DEFINE_RPC_XPRT_EVENT(timer);
 695 DEFINE_RPC_XPRT_EVENT(lookup_rqst);
 696 DEFINE_RPC_XPRT_EVENT(complete_rqst);
 697
 698 TRACE_EVENT(xprt_transmit,
 699         TP_PROTO(
 700                 const struct rpc_rqst *rqst,
 701                 int status
 702         ),
 703
 704         TP_ARGS(rqst, status),
 705
 706         TP_STRUCT__entry(
 707                 __field(unsigned int, task_id)
 708                 __field(unsigned int, client_id)
 709                 __field(u32, xid)
 710                 __field(u32, seqno)
 711                 __field(int, status)
 712         ),
 713
 714         TP_fast_assign(
 715                 __entry->task_id = rqst->rq_task->tk_pid;
 716                 __entry->client_id = rqst->rq_task->tk_client ?
 717                         rqst->rq_task->tk_client->cl_clid : -1;
 718                 __entry->xid = be32_to_cpu(rqst->rq_xid);
 719                 __entry->seqno = rqst->rq_seqno;
 720                 __entry->status = status;
 721         ),
 722
 723         TP_printk(
 724                 "task:%u@%u xid=0x%08x seqno=%u status=%d",
 725                 __entry->task_id, __entry->client_id, __entry->xid,
 726                 __entry->seqno, __entry->status)
 727 );
 728
 729 TRACE_EVENT(xprt_enq_xmit,
 730         TP_PROTO(
 731                 const struct rpc_task *task,
 732                 int stage
 733         ),
 734
 735         TP_ARGS(task, stage),
 736
 737         TP_STRUCT__entry(
 738                 __field(unsigned int, task_id)
 739                 __field(unsigned int, client_id)
 740                 __field(u32, xid)
 741                 __field(u32, seqno)
 742                 __field(int, stage)
 743         ),
 744
 745         TP_fast_assign(
 746                 __entry->task_id = task->tk_pid;
 747                 __entry->client_id = task->tk_client ?
 748                         task->tk_client->cl_clid : -1;
 749                 __entry->xid = be32_to_cpu(task->tk_rqstp->rq_xid);
 750                 __entry->seqno = task->tk_rqstp->rq_seqno;
 751                 __entry->stage = stage;
 752         ),
 753
 754         TP_printk(
 755                 "task:%u@%u xid=0x%08x seqno=%u stage=%d",
 756                 __entry->task_id, __entry->client_id, __entry->xid,
 757                 __entry->seqno, __entry->stage)
 758 );
 759
 760 TRACE_EVENT(xprt_ping,
 761         TP_PROTO(const struct rpc_xprt *xprt, int status),
 762
 763         TP_ARGS(xprt, status),
 764
 765         TP_STRUCT__entry(
 766                 __field(int, status)
 767                 __string(addr, xprt->address_strings[RPC_DISPLAY_ADDR])
 768                 __string(port, xprt->address_strings[RPC_DISPLAY_PORT])
 769         ),
 770
 771         TP_fast_assign(
 772                 __entry->status = status;
 773                 __assign_str(addr, xprt->address_strings[RPC_DISPLAY_ADDR]);
 774                 __assign_str(port, xprt->address_strings[RPC_DISPLAY_PORT]);
 775         ),
 776
 777         TP_printk("peer=[%s]:%s status=%d",
 778                         __get_str(addr), __get_str(port), __entry->status)
 779 );
 780
 781 TRACE_EVENT(xs_stream_read_data,
 782         TP_PROTO(struct rpc_xprt *xprt, ssize_t err, size_t total),
 783
 784         TP_ARGS(xprt, err, total),
 785
 786         TP_STRUCT__entry(
 787                 __field(ssize_t, err)
 788                 __field(size_t, total)
 789                 __string(addr, xprt ? xprt->address_strings[RPC_DISPLAY_ADDR] :
 790                                 "(null)")
 791                 __string(port, xprt ? xprt->address_strings[RPC_DISPLAY_PORT] :
 792                                 "(null)")
 793         ),
 794
 795         TP_fast_assign(
 796                 __entry->err = err;
 797                 __entry->total = total;
 798                 __assign_str(addr, xprt ?
 799                         xprt->address_strings[RPC_DISPLAY_ADDR] : "(null)");
 800                 __assign_str(port, xprt ?
 801                         xprt->address_strings[RPC_DISPLAY_PORT] : "(null)");
 802         ),
 803
 804         TP_printk("peer=[%s]:%s err=%zd total=%zu", __get_str(addr),
 805                         __get_str(port), __entry->err, __entry->total)
 806 );
 807
 808 TRACE_EVENT(xs_stream_read_request,
 809         TP_PROTO(struct sock_xprt *xs),
 810
 811         TP_ARGS(xs),
 812
 813         TP_STRUCT__entry(
 814                 __string(addr, xs->xprt.address_strings[RPC_DISPLAY_ADDR])
 815                 __string(port, xs->xprt.address_strings[RPC_DISPLAY_PORT])
 816                 __field(u32, xid)
 817                 __field(unsigned long, copied)
 818                 __field(unsigned int, reclen)
 819                 __field(unsigned int, offset)
 820         ),
 821
 822         TP_fast_assign(
 823                 __assign_str(addr, xs->xprt.address_strings[RPC_DISPLAY_ADDR]);
 824                 __assign_str(port, xs->xprt.address_strings[RPC_DISPLAY_PORT]);
 825                 __entry->xid = be32_to_cpu(xs->recv.xid);
 826                 __entry->copied = xs->recv.copied;
 827                 __entry->reclen = xs->recv.len;
 828                 __entry->offset = xs->recv.offset;
 829         ),
 830
 831         TP_printk("peer=[%s]:%s xid=0x%08x copied=%lu reclen=%u offset=%u",
 832                         __get_str(addr), __get_str(port), __entry->xid,
 833                         __entry->copied, __entry->reclen, __entry->offset)
 834 );
 835
 836 #define show_rqstp_flags(flags)                                         \
 837         __print_flags(flags, "|",                                       \
 838                 { (1UL << RQ_SECURE),           "RQ_SECURE"},           \
 839                 { (1UL << RQ_LOCAL),            "RQ_LOCAL"},            \
 840                 { (1UL << RQ_USEDEFERRAL),      "RQ_USEDEFERRAL"},      \
 841                 { (1UL << RQ_DROPME),           "RQ_DROPME"},           \
 842                 { (1UL << RQ_SPLICE_OK),        "RQ_SPLICE_OK"},        \
 843                 { (1UL << RQ_VICTIM),           "RQ_VICTIM"},           \
 844                 { (1UL << RQ_BUSY),             "RQ_BUSY"})
 845
 846 TRACE_EVENT(svc_recv,
 847         TP_PROTO(struct svc_rqst *rqst, int len),
 848
 849         TP_ARGS(rqst, len),
 850
 851         TP_STRUCT__entry(
 852                 __field(u32, xid)
 853                 __field(int, len)
 854                 __field(unsigned long, flags)
 855                 __string(addr, rqst->rq_xprt->xpt_remotebuf)
 856         ),
 857
 858         TP_fast_assign(
 859                 __entry->xid = be32_to_cpu(rqst->rq_xid);
 860                 __entry->len = len;
 861                 __entry->flags = rqst->rq_flags;
 862                 __assign_str(addr, rqst->rq_xprt->xpt_remotebuf);
 863         ),
 864
 865         TP_printk("addr=%s xid=0x%08x len=%d flags=%s",
 866                         __get_str(addr), __entry->xid, __entry->len,
 867                         show_rqstp_flags(__entry->flags))
 868 );
 869
 870 TRACE_EVENT(svc_process,
 871         TP_PROTO(const struct svc_rqst *rqst, const char *name),
 872
 873         TP_ARGS(rqst, name),
 874
 875         TP_STRUCT__entry(
 876                 __field(u32, xid)
 877                 __field(u32, vers)
 878                 __field(u32, proc)
 879                 __string(service, name)
 880                 __string(addr, rqst->rq_xprt ?
 881                          rqst->rq_xprt->xpt_remotebuf : "(null)")
 882         ),
 883
 884         TP_fast_assign(
 885                 __entry->xid = be32_to_cpu(rqst->rq_xid);
 886                 __entry->vers = rqst->rq_vers;
 887                 __entry->proc = rqst->rq_proc;
 888                 __assign_str(service, name);
 889                 __assign_str(addr, rqst->rq_xprt ?
 890                              rqst->rq_xprt->xpt_remotebuf : "(null)");
 891         ),
 892
 893         TP_printk("addr=%s xid=0x%08x service=%s vers=%u proc=%u",
 894                         __get_str(addr), __entry->xid,
 895                         __get_str(service), __entry->vers, __entry->proc)
 896 );
 897
 898 DECLARE_EVENT_CLASS(svc_rqst_event,
 899
 900         TP_PROTO(
 901                 const struct svc_rqst *rqst
 902         ),
 903
 904         TP_ARGS(rqst),
 905
 906         TP_STRUCT__entry(
 907                 __field(u32, xid)
 908                 __field(unsigned long, flags)
 909                 __string(addr, rqst->rq_xprt->xpt_remotebuf)
 910         ),
 911
 912         TP_fast_assign(
 913                 __entry->xid = be32_to_cpu(rqst->rq_xid);
 914                 __entry->flags = rqst->rq_flags;
 915                 __assign_str(addr, rqst->rq_xprt->xpt_remotebuf);
 916         ),
 917
 918         TP_printk("addr=%s xid=0x%08x flags=%s",
 919                         __get_str(addr), __entry->xid,
 920                         show_rqstp_flags(__entry->flags))
 921 );
 922 #define DEFINE_SVC_RQST_EVENT(name) \
 923         DEFINE_EVENT(svc_rqst_event, svc_##name, \
 924                         TP_PROTO( \
 925                                 const struct svc_rqst *rqst \
 926                         ), \
 927                         TP_ARGS(rqst))
 928
 929 DEFINE_SVC_RQST_EVENT(defer);
 930 DEFINE_SVC_RQST_EVENT(drop);
 931
 932 DECLARE_EVENT_CLASS(svc_rqst_status,
 933
 934         TP_PROTO(struct svc_rqst *rqst, int status),
 935
 936         TP_ARGS(rqst, status),
 937
 938         TP_STRUCT__entry(
 939                 __field(u32, xid)
 940                 __field(int, status)
 941                 __field(unsigned long, flags)
 942                 __string(addr, rqst->rq_xprt->xpt_remotebuf)
 943         ),
 944
 945         TP_fast_assign(
 946                 __entry->xid = be32_to_cpu(rqst->rq_xid);
 947                 __entry->status = status;
 948                 __entry->flags = rqst->rq_flags;
 949                 __assign_str(addr, rqst->rq_xprt->xpt_remotebuf);
 950         ),
 951
 952         TP_printk("addr=%s xid=0x%08x status=%d flags=%s",
 953                   __get_str(addr), __entry->xid,
 954                   __entry->status, show_rqstp_flags(__entry->flags))
 955 );
 956
 957 DEFINE_EVENT(svc_rqst_status, svc_send,
 958         TP_PROTO(struct svc_rqst *rqst, int status),
 959         TP_ARGS(rqst, status));
 960
 961 #define show_svc_xprt_flags(flags)                                      \
 962         __print_flags(flags, "|",                                       \
 963                 { (1UL << XPT_BUSY),            "XPT_BUSY"},            \
 964                 { (1UL << XPT_CONN),            "XPT_CONN"},            \
 965                 { (1UL << XPT_CLOSE),           "XPT_CLOSE"},           \
 966                 { (1UL << XPT_DATA),            "XPT_DATA"},            \
 967                 { (1UL << XPT_TEMP),            "XPT_TEMP"},            \
 968                 { (1UL << XPT_DEAD),            "XPT_DEAD"},            \
 969                 { (1UL << XPT_CHNGBUF),         "XPT_CHNGBUF"},         \
 970                 { (1UL << XPT_DEFERRED),        "XPT_DEFERRED"},        \
 971                 { (1UL << XPT_OLD),             "XPT_OLD"},             \
 972                 { (1UL << XPT_LISTENER),        "XPT_LISTENER"},        \
 973                 { (1UL << XPT_CACHE_AUTH),      "XPT_CACHE_AUTH"},      \
 974                 { (1UL << XPT_LOCAL),           "XPT_LOCAL"},           \
 975                 { (1UL << XPT_KILL_TEMP),       "XPT_KILL_TEMP"},       \
 976                 { (1UL << XPT_CONG_CTRL),       "XPT_CONG_CTRL"})
 977
 978 TRACE_EVENT(svc_xprt_do_enqueue,
 979         TP_PROTO(struct svc_xprt *xprt, struct svc_rqst *rqst),
 980
 981         TP_ARGS(xprt, rqst),
 982
 983         TP_STRUCT__entry(
 984                 __field(struct svc_xprt *, xprt)
 985                 __field(int, pid)
 986                 __field(unsigned long, flags)
 987                 __string(addr, xprt->xpt_remotebuf)
 988         ),
 989
 990         TP_fast_assign(
 991                 __entry->xprt = xprt;
 992                 __entry->pid = rqst? rqst->rq_task->pid : 0;
 993                 __entry->flags = xprt->xpt_flags;
 994                 __assign_str(addr, xprt->xpt_remotebuf);
 995         ),
 996
 997         TP_printk("xprt=%p addr=%s pid=%d flags=%s",
 998                         __entry->xprt, __get_str(addr),
 999                         __entry->pid, show_svc_xprt_flags(__entry->flags))
1000 );
1001
1002 DECLARE_EVENT_CLASS(svc_xprt_event,
1003         TP_PROTO(struct svc_xprt *xprt),
1004
1005         TP_ARGS(xprt),
1006
1007         TP_STRUCT__entry(
1008                 __field(struct svc_xprt *, xprt)
1009                 __field(unsigned long, flags)
1010                 __string(addr, xprt->xpt_remotebuf)
1011         ),
1012
1013         TP_fast_assign(
1014                 __entry->xprt = xprt;
1015                 __entry->flags = xprt->xpt_flags;
1016                 __assign_str(addr, xprt->xpt_remotebuf);
1017         ),
1018
1019         TP_printk("xprt=%p addr=%s flags=%s",
1020                         __entry->xprt, __get_str(addr),
1021                         show_svc_xprt_flags(__entry->flags))
1022 );
1023
1024 DEFINE_EVENT(svc_xprt_event, svc_xprt_no_write_space,
1025         TP_PROTO(struct svc_xprt *xprt),
1026         TP_ARGS(xprt));
1027
1028 TRACE_EVENT(svc_xprt_dequeue,
1029         TP_PROTO(struct svc_rqst *rqst),
1030
1031         TP_ARGS(rqst),
1032
1033         TP_STRUCT__entry(
1034                 __field(struct svc_xprt *, xprt)
1035                 __field(unsigned long, flags)
1036                 __field(unsigned long, wakeup)
1037                 __string(addr, rqst->rq_xprt->xpt_remotebuf)
1038         ),
1039
1040         TP_fast_assign(
1041                 __entry->xprt = rqst->rq_xprt;
1042                 __entry->flags = rqst->rq_xprt->xpt_flags;
1043                 __entry->wakeup = ktime_to_us(ktime_sub(ktime_get(),
1044                                                         rqst->rq_qtime));
1045                 __assign_str(addr, rqst->rq_xprt->xpt_remotebuf);
1046         ),
1047
1048         TP_printk("xprt=%p addr=%s flags=%s wakeup-us=%lu",
1049                         __entry->xprt, __get_str(addr),
1050                         show_svc_xprt_flags(__entry->flags),
1051                         __entry->wakeup)
1052 );
1053
1054 TRACE_EVENT(svc_wake_up,
1055         TP_PROTO(int pid),
1056
1057         TP_ARGS(pid),
1058
1059         TP_STRUCT__entry(
1060                 __field(int, pid)
1061         ),
1062
1063         TP_fast_assign(
1064                 __entry->pid = pid;
1065         ),
1066
1067         TP_printk("pid=%d", __entry->pid)
1068 );
1069
1070 TRACE_EVENT(svc_handle_xprt,
1071         TP_PROTO(struct svc_xprt *xprt, int len),
1072
1073         TP_ARGS(xprt, len),
1074
1075         TP_STRUCT__entry(
1076                 __field(struct svc_xprt *, xprt)
1077                 __field(int, len)
1078                 __field(unsigned long, flags)
1079                 __string(addr, xprt->xpt_remotebuf)
1080         ),
1081
1082         TP_fast_assign(
1083                 __entry->xprt = xprt;
1084                 __entry->len = len;
1085                 __entry->flags = xprt->xpt_flags;
1086                 __assign_str(addr, xprt->xpt_remotebuf);
1087         ),
1088
1089         TP_printk("xprt=%p addr=%s len=%d flags=%s",
1090                 __entry->xprt, __get_str(addr),
1091                 __entry->len, show_svc_xprt_flags(__entry->flags))
1092 );
1093
1094 TRACE_EVENT(svc_stats_latency,
1095         TP_PROTO(const struct svc_rqst *rqst),
1096
1097         TP_ARGS(rqst),
1098
1099         TP_STRUCT__entry(
1100                 __field(u32, xid)
1101                 __field(unsigned long, execute)
1102                 __string(addr, rqst->rq_xprt->xpt_remotebuf)
1103         ),
1104
1105         TP_fast_assign(
1106                 __entry->xid = be32_to_cpu(rqst->rq_xid);
1107                 __entry->execute = ktime_to_us(ktime_sub(ktime_get(),
1108                                                          rqst->rq_stime));
1109                 __assign_str(addr, rqst->rq_xprt->xpt_remotebuf);
1110         ),
1111
1112         TP_printk("addr=%s xid=0x%08x execute-us=%lu",
1113                 __get_str(addr), __entry->xid, __entry->execute)
1114 );
1115
1116 DECLARE_EVENT_CLASS(svc_deferred_event,
1117         TP_PROTO(
1118                 const struct svc_deferred_req *dr
1119         ),
1120
1121         TP_ARGS(dr),
1122
1123         TP_STRUCT__entry(
1124                 __field(u32, xid)
1125                 __string(addr, dr->xprt->xpt_remotebuf)
1126         ),
1127
1128         TP_fast_assign(
1129                 __entry->xid = be32_to_cpu(*(__be32 *)(dr->args +
1130                                                        (dr->xprt_hlen>>2)));
1131                 __assign_str(addr, dr->xprt->xpt_remotebuf);
1132         ),
1133
1134         TP_printk("addr=%s xid=0x%08x", __get_str(addr), __entry->xid)
1135 );
1136 #define DEFINE_SVC_DEFERRED_EVENT(name) \
1137         DEFINE_EVENT(svc_deferred_event, svc_##name##_deferred, \
1138                         TP_PROTO( \
1139                                 const struct svc_deferred_req *dr \
1140                         ), \
1141                         TP_ARGS(dr))
1142
1143 DEFINE_SVC_DEFERRED_EVENT(drop);
1144 DEFINE_SVC_DEFERRED_EVENT(revisit);
1145
1146 #endif /* _TRACE_SUNRPC_H */
1147
1148 #include <trace/define_trace.h>