TP_fast_assign(
                           __entry->sched_job_id = job->base.id;
-                          __assign_str(timeline, AMDGPU_JOB_GET_TIMELINE_NAME(job))
+                          __assign_str(timeline, AMDGPU_JOB_GET_TIMELINE_NAME(job));
                           __entry->context = job->base.s_fence->finished.context;
                           __entry->seqno = job->base.s_fence->finished.seqno;
-                          __assign_str(ring, to_amdgpu_ring(job->base.sched)->name)
+                          __assign_str(ring, to_amdgpu_ring(job->base.sched)->name);
                           __entry->num_ibs = job->num_ibs;
                           ),
            TP_printk("sched_job=%llu, timeline=%s, context=%u, seqno=%u, ring_name=%s, num_ibs=%u",
 
            TP_fast_assign(
                           __entry->sched_job_id = job->base.id;
-                          __assign_str(timeline, AMDGPU_JOB_GET_TIMELINE_NAME(job))
+                          __assign_str(timeline, AMDGPU_JOB_GET_TIMELINE_NAME(job));
                           __entry->context = job->base.s_fence->finished.context;
                           __entry->seqno = job->base.s_fence->finished.seqno;
-                          __assign_str(ring, to_amdgpu_ring(job->base.sched)->name)
+                          __assign_str(ring, to_amdgpu_ring(job->base.sched)->name);
                           __entry->num_ibs = job->num_ibs;
                           ),
            TP_printk("sched_job=%llu, timeline=%s, context=%u, seqno=%u, ring_name=%s, num_ibs=%u",
 
            TP_fast_assign(
                           __entry->pasid = vm->pasid;
-                          __assign_str(ring, ring->name)
+                          __assign_str(ring, ring->name);
                           __entry->vmid = job->vmid;
                           __entry->vm_hub = ring->funcs->vmhub,
                           __entry->pd_addr = job->vm_pd_addr;
                             ),
 
            TP_fast_assign(
-                          __assign_str(ring, ring->name)
+                          __assign_str(ring, ring->name);
                           __entry->vmid = vmid;
                           __entry->vm_hub = ring->funcs->vmhub;
                           __entry->pd_addr = pd_addr;
                             ),
 
            TP_fast_assign(
-                          __assign_str(ring, sched_job->base.sched->name)
+                          __assign_str(ring, sched_job->base.sched->name);
                           __entry->id = sched_job->base.id;
                           __entry->fence = fence;
                           __entry->ctx = fence->context;
 
                __entry->task_id = task->base.id;
                __entry->context = task->base.s_fence->finished.context;
                __entry->seqno = task->base.s_fence->finished.seqno;
-               __assign_str(pipe, task->base.sched->name)
+               __assign_str(pipe, task->base.sched->name);
                ),
 
        TP_printk("task=%llu, context=%u seqno=%u pipe=%s",
 
                             __array(char, buf, 64)
                             __field(int, src)
                             ),
-           TP_fast_assign(DD_DEV_ASSIGN(dd)
+           TP_fast_assign(DD_DEV_ASSIGN(dd);
                           is_entry->is_name(__entry->buf, 64,
                                             src - is_entry->start);
                           __entry->src = src;
                             __field(u32, qpn)
                             __field(u8, opcode)
                             ),
-           TP_fast_assign(DD_DEV_ASSIGN(dd_from_ibdev(qp->ibqp.device))
+           TP_fast_assign(DD_DEV_ASSIGN(dd_from_ibdev(qp->ibqp.device));
                           __entry->qpn = qp->ibqp.qp_num;
                           __entry->opcode = opcode;
                           ),
 
                        __field(u32, r_psn)
                        ),
                    TP_fast_assign(
-                       DD_DEV_ASSIGN(dd_from_ibdev(qp->ibqp.device))
+                       DD_DEV_ASSIGN(dd_from_ibdev(qp->ibqp.device));
                        __entry->qpn = qp->ibqp.qp_num;
                        __entry->s_flags = qp->s_flags;
                        __entry->psn = psn;
                __field(u32, lpsn)
        ),
        TP_fast_assign(/* assign */
-               DD_DEV_ASSIGN(dd_from_ibdev(qp->ibqp.device))
+               DD_DEV_ASSIGN(dd_from_ibdev(qp->ibqp.device));
                __entry->qpn = qp->ibqp.qp_num;
                __entry->aeth = aeth;
                __entry->psn = psn;
 
                __field(u8, s_retry)
        ),
        TP_fast_assign(/* assign */
-               DD_DEV_ASSIGN(dd_from_ibdev(qp->ibqp.device))
+               DD_DEV_ASSIGN(dd_from_ibdev(qp->ibqp.device));
                __entry->qpn = qp->ibqp.qp_num;
                __entry->state = qp->state;
                __entry->s_cur = qp->s_cur;
                __field(int, diff)
        ),
        TP_fast_assign(/* assign */
-               DD_DEV_ASSIGN(dd_from_ibdev(qp->ibqp.device))
+               DD_DEV_ASSIGN(dd_from_ibdev(qp->ibqp.device));
                __entry->qpn = qp->ibqp.qp_num;
                __entry->s_flags = qp->s_flags;
                __entry->state = qp->state;
                __field(u32, resync_psn)
        ),
        TP_fast_assign(/* assign */
-               DD_DEV_ASSIGN(dd_from_ibdev(qp->ibqp.device))
+               DD_DEV_ASSIGN(dd_from_ibdev(qp->ibqp.device));
                __entry->qpn = qp->ibqp.qp_num;
                __entry->aeth = aeth;
                __entry->psn = psn;
 
                    __field(unsigned long, iow_flags)
                    ),
                    TP_fast_assign(
-                   DD_DEV_ASSIGN(dd_from_ibdev(qp->ibqp.device))
+                   DD_DEV_ASSIGN(dd_from_ibdev(qp->ibqp.device));
                    __entry->flags = flags;
                    __entry->qpn = qp->ibqp.qp_num;
                    __entry->s_flags = qp->s_flags;
                __field(int, send_flags)
        ),
        TP_fast_assign(
-               DD_DEV_ASSIGN(dd_from_ibdev(qp->ibqp.device))
+               DD_DEV_ASSIGN(dd_from_ibdev(qp->ibqp.device));
                __entry->wqe = wqe;
                __entry->wr_id = wqe->wr.wr_id;
                __entry->qpn = qp->ibqp.qp_num;
                __field(bool, flag)
        ),
        TP_fast_assign(
-               DD_DEV_ASSIGN(dd_from_ibdev(qp->ibqp.device))
+               DD_DEV_ASSIGN(dd_from_ibdev(qp->ibqp.device));
                __entry->qpn = qp->ibqp.qp_num;
                __entry->flag = flag;
        ),
                __field(u8, stopped)
        ),
        TP_fast_assign(/* assign */
-               DD_DEV_ASSIGN(txq->priv->dd)
+               DD_DEV_ASSIGN(txq->priv->dd);
                __entry->txq = txq;
                __entry->sde = txq->sde;
                __entry->head = txq->tx_ring.head;
 
                                     __field(int, comp_vector_cpu)
                                     __field(u32, flags)
                                     ),
-                   TP_fast_assign(RDI_DEV_ASSIGN(cq->rdi)
+                   TP_fast_assign(RDI_DEV_ASSIGN(cq->rdi);
                                   __entry->ip = cq->ip;
                                   __entry->cqe = attr->cqe;
                                   __entry->comp_vector = attr->comp_vector;
                __field(u32, imm)
        ),
        TP_fast_assign(
-               RDI_DEV_ASSIGN(cq->rdi)
+               RDI_DEV_ASSIGN(cq->rdi);
                __entry->wr_id = wc->wr_id;
                __entry->status = wc->status;
                __entry->opcode = wc->opcode;
 
                __field(uint, sg_offset)
        ),
        TP_fast_assign(
-               RDI_DEV_ASSIGN(ib_to_rvt(to_imr(ibmr)->mr.pd->device))
+               RDI_DEV_ASSIGN(ib_to_rvt(to_imr(ibmr)->mr.pd->device));
                __entry->ibmr_iova = ibmr->iova;
                __entry->iova = to_imr(ibmr)->mr.iova;
                __entry->user_base = to_imr(ibmr)->mr.user_base;
 
                __field(u32, bucket)
        ),
        TP_fast_assign(
-               RDI_DEV_ASSIGN(ib_to_rvt(qp->ibqp.device))
+               RDI_DEV_ASSIGN(ib_to_rvt(qp->ibqp.device));
                __entry->qpn = qp->ibqp.qp_num;
                __entry->bucket = bucket;
        ),
                __field(u32, to)
        ),
        TP_fast_assign(
-               RDI_DEV_ASSIGN(ib_to_rvt(qp->ibqp.device))
+               RDI_DEV_ASSIGN(ib_to_rvt(qp->ibqp.device));
                __entry->qpn = qp->ibqp.qp_num;
                __entry->hrtimer = &qp->s_rnr_timer;
                __entry->s_flags = qp->s_flags;
 
                        __field(u32, r_psn)
                        ),
                    TP_fast_assign(
-                       RDI_DEV_ASSIGN(ib_to_rvt(qp->ibqp.device))
+                       RDI_DEV_ASSIGN(ib_to_rvt(qp->ibqp.device));
                        __entry->qpn = qp->ibqp.qp_num;
                        __entry->s_flags = qp->s_flags;
                        __entry->psn = psn;
 
                __field(int, wr_num_sge)
        ),
        TP_fast_assign(
-               RDI_DEV_ASSIGN(ib_to_rvt(qp->ibqp.device))
+               RDI_DEV_ASSIGN(ib_to_rvt(qp->ibqp.device));
                __entry->wqe = wqe;
                __entry->wr_id = wqe->wr.wr_id;
                __entry->qpn = qp->ibqp.qp_num;
                __field(int, send_flags)
        ),
        TP_fast_assign(
-               RDI_DEV_ASSIGN(ib_to_rvt(qp->ibqp.device))
+               RDI_DEV_ASSIGN(ib_to_rvt(qp->ibqp.device));
                __entry->wqe = wqe;
                __entry->wr_id = wqe->wr.wr_id;
                __entry->qpn = qp->ibqp.qp_num;
 
                __field(u32, val)
        ),
        TP_fast_assign(
-               __assign_str(dev, dev_name(dev))
+               __assign_str(dev, dev_name(dev));
                __entry->reg  = reg;
                __entry->offs = offs;
                __entry->val = val;
                __field(u32, val)
        ),
        TP_fast_assign(
-               __assign_str(dev, dev_name(dev))
+               __assign_str(dev, dev_name(dev));
                __entry->reg = reg;
                __entry->offs = offs;
                __entry->val = val;
                __field(u32, val)
        ),
        TP_fast_assign(
-               __assign_str(dev, dev_name(dev))
+               __assign_str(dev, dev_name(dev));
                __entry->reg  = reg;
                __entry->offs = offs;
                __entry->val = val;
 
                             __field(u16, id)
                             __field(u64, size)
            ),
-           TP_fast_assign(__assign_str(dev, pci_name(pdev))
+           TP_fast_assign(__assign_str(dev, pci_name(pdev));
                           __entry->id = id;
                           __entry->size = size;
            ),
                             __field(u16, num_msgs)
                             __field(u64, msg_size)
            ),
-           TP_fast_assign(__assign_str(dev, pci_name(pdev))
+           TP_fast_assign(__assign_str(dev, pci_name(pdev));
                           __entry->num_msgs = num_msgs;
                           __entry->msg_size = msg_size;
            ),
                             __field(u16, rspid)
                             __field(int, rc)
            ),
-           TP_fast_assign(__assign_str(dev, pci_name(pdev))
+           TP_fast_assign(__assign_str(dev, pci_name(pdev));
                           __entry->reqid = reqid;
                           __entry->rspid = rspid;
                           __entry->rc = rc;
                             __string(str, msg)
                             __field(u64, intr)
            ),
-           TP_fast_assign(__assign_str(dev, pci_name(pdev))
-                          __assign_str(str, msg)
+           TP_fast_assign(__assign_str(dev, pci_name(pdev));
+                          __assign_str(str, msg);
                           __entry->intr = intr;
            ),
            TP_printk("[%s] mbox interrupt %s (0x%llx)\n", __get_str(dev),
                             __field(u16, id)
                             __field(int, err)
            ),
-           TP_fast_assign(__assign_str(dev, pci_name(pdev))
+           TP_fast_assign(__assign_str(dev, pci_name(pdev));
                           __entry->id = id;
                           __entry->err = err;
            ),
 
                 __string(err, err)
        ),
        TP_fast_assign(
-               __assign_str(err, err)
+               __assign_str(err, err);
        ),
        TP_printk("%s", __get_str(err))
 );
                 __string(err, err)
        ),
        TP_fast_assign(
-               __assign_str(err, err)
+               __assign_str(err, err);
        ),
        TP_printk("%s", __get_str(err))
 );
 
                __string(text, msg)
        ),
        TP_fast_assign(
-               __assign_str(text, msg)
+               __assign_str(text, msg);
        ),
        TP_printk("%s", __get_str(text))
 );
 
 
                TP_fast_assign(
                        __entry->state = clp->cl_state;
-                       __assign_str(hostname, clp->cl_hostname)
+                       __assign_str(hostname, clp->cl_hostname);
                ),
 
                TP_printk(
                                __entry->fileid = 0;
                                __entry->dev = 0;
                        }
-                       __assign_str(dstaddr, clp ? clp->cl_hostname : "unknown")
+                       __assign_str(dstaddr, clp ? clp->cl_hostname : "unknown");
                ),
 
                TP_printk(
                                __entry->fileid = 0;
                                __entry->dev = 0;
                        }
-                       __assign_str(dstaddr, clp ? clp->cl_hostname : "unknown")
+                       __assign_str(dstaddr, clp ? clp->cl_hostname : "unknown");
                        __entry->stateid_seq =
                                be32_to_cpu(stateid->seqid);
                        __entry->stateid_hash =
 
                        __entry->version = task->tk_client->cl_vers;
                        __entry->error = error;
                        __assign_str(program,
-                                    task->tk_client->cl_program->name)
-                       __assign_str(procedure, task->tk_msg.rpc_proc->p_name)
+                                    task->tk_client->cl_program->name);
+                       __assign_str(procedure, task->tk_msg.rpc_proc->p_name);
                ),
 
                TP_printk(
 
                __entry->flags  = flags;
                __entry->bytes  = bytes;
                __entry->flush  = flush;
-               __assign_str(reason, reason)
+               __assign_str(reason, reason);
        ),
 
        TP_printk_btrfs("%s: flush=%d(%s) flags=%llu(%s) bytes=%llu",
 
        ),
 
        TP_fast_assign(
-               __assign_str(driver, fence->ops->get_driver_name(fence))
-               __assign_str(timeline, fence->ops->get_timeline_name(fence))
+               __assign_str(driver, fence->ops->get_driver_name(fence));
+               __assign_str(timeline, fence->ops->get_timeline_name(fence));
                __entry->context = fence->context;
                __entry->seqno = fence->seqno;
        ),
 
        TP_fast_assign(
                __entry->cred = gc;
                __entry->service = gc->gc_service;
-               __assign_str(principal, gc->gc_principal)
+               __assign_str(principal, gc->gc_principal);
        ),
 
        TP_printk("cred=%p service=%s principal='%s'",
        ),
 
        TP_fast_assign(
-               __assign_str(msg, buf)
+               __assign_str(msg, buf);
        ),
 
        TP_printk("msg='%s'", __get_str(msg))
 
                __entry->client_id = clnt->cl_clid;
                __assign_str(addr, xprt->address_strings[RPC_DISPLAY_ADDR]);
                __assign_str(port, xprt->address_strings[RPC_DISPLAY_PORT]);
-               __assign_str(program, program)
-               __assign_str(server, server)
+               __assign_str(program, program);
+               __assign_str(server, server);
        ),
 
        TP_printk("client=%u peer=[%s]:%s program=%s server=%s",
 
        TP_fast_assign(
                __entry->error = error;
-               __assign_str(program, program)
-               __assign_str(server, server)
+               __assign_str(program, program);
+               __assign_str(server, server);
        ),
 
        TP_printk("program=%s server=%s error=%d",
                __entry->client_id = task->tk_client->cl_clid;
                __entry->version = task->tk_client->cl_vers;
                __entry->async = RPC_IS_ASYNC(task);
-               __assign_str(progname, task->tk_client->cl_program->name)
-               __assign_str(procname, rpc_proc_name(task))
+               __assign_str(progname, task->tk_client->cl_program->name);
+               __assign_str(procname, rpc_proc_name(task));
        ),
 
        TP_printk("task:%u@%u %sv%d %s (%ssync)",
                __entry->task_id = task->tk_pid;
                __entry->client_id = task->tk_client->cl_clid;
                __entry->xid = be32_to_cpu(task->tk_rqstp->rq_xid);
-               __assign_str(progname, task->tk_client->cl_program->name)
+               __assign_str(progname, task->tk_client->cl_program->name);
                __entry->version = task->tk_client->cl_vers;
-               __assign_str(procname, rpc_proc_name(task))
-               __assign_str(servername, task->tk_xprt->servername)
+               __assign_str(procname, rpc_proc_name(task));
+               __assign_str(servername, task->tk_xprt->servername);
        ),
 
        TP_printk("task:%u@%d server=%s xid=0x%08x %sv%d %s",
                __entry->task_id = task->tk_pid;
                __entry->xid = be32_to_cpu(task->tk_rqstp->rq_xid);
                __entry->version = task->tk_client->cl_vers;
-               __assign_str(progname, task->tk_client->cl_program->name)
-               __assign_str(procname, rpc_proc_name(task))
+               __assign_str(progname, task->tk_client->cl_program->name);
+               __assign_str(procname, rpc_proc_name(task));
                __entry->backlog = ktime_to_us(backlog);
                __entry->rtt = ktime_to_us(rtt);
                __entry->execute = ktime_to_us(execute);
                        __entry->task_id = task->tk_pid;
                        __entry->client_id = task->tk_client->cl_clid;
                        __assign_str(progname,
-                                    task->tk_client->cl_program->name)
+                                    task->tk_client->cl_program->name);
                        __entry->version = task->tk_client->cl_vers;
-                       __assign_str(procedure, task->tk_msg.rpc_proc->p_name)
+                       __assign_str(procedure, task->tk_msg.rpc_proc->p_name);
                } else {
                        __entry->task_id = 0;
                        __entry->client_id = 0;
-                       __assign_str(progname, "unknown")
+                       __assign_str(progname, "unknown");
                        __entry->version = 0;
-                       __assign_str(procedure, "unknown")
+                       __assign_str(procedure, "unknown");
                }
                __entry->requested = requested;
                __entry->end = xdr->end;
                __entry->task_id = task->tk_pid;
                __entry->client_id = task->tk_client->cl_clid;
                __assign_str(progname,
-                            task->tk_client->cl_program->name)
+                            task->tk_client->cl_program->name);
                __entry->version = task->tk_client->cl_vers;
-               __assign_str(procedure, task->tk_msg.rpc_proc->p_name)
+               __assign_str(procedure, task->tk_msg.rpc_proc->p_name);
 
                __entry->offset = offset;
                __entry->copied = copied;
                __entry->xid = be32_to_cpu(rqst->rq_xid);
                __entry->ntrans = rqst->rq_ntrans;
                __assign_str(progname,
-                            task->tk_client->cl_program->name)
+                            task->tk_client->cl_program->name);
                __entry->version = task->tk_client->cl_vers;
-               __assign_str(procedure, task->tk_msg.rpc_proc->p_name)
+               __assign_str(procedure, task->tk_msg.rpc_proc->p_name);
        ),
 
        TP_printk(
 
        TP_fast_assign(
                __assign_str(addr, xprt->xpt_remotebuf);
-               __assign_str(protocol, xprt->xpt_class->xcl_name)
+               __assign_str(protocol, xprt->xpt_class->xcl_name);
                __assign_str(service, service);
        ),