net/sched: sch_taprio: reset child qdiscs before freeing them

[linux-2.6-microblaze.git] / net / sunrpc / svc_xprt.c

diff --git a/net/sunrpc/svc_xprt.c b/net/sunrpc/svc_xprt.c
index 2284ff0..43cf8db 100644 (file)
--- a/net/sunrpc/svc_xprt.c
+++ b/net/sunrpc/svc_xprt.c
@@ -153,6 +153,7 @@ static void svc_xprt_free(struct kref *kref)
                xprt_put(xprt->xpt_bc_xprt);
        if (xprt->xpt_bc_xps)
                xprt_switch_put(xprt->xpt_bc_xps);
+       trace_svc_xprt_free(xprt);
        xprt->xpt_ops->xpo_free(xprt);
        module_put(owner);
 }
@@ -206,6 +207,7 @@ static struct svc_xprt *__svc_xpo_create(struct svc_xprt_class *xcl,
                .sin6_port              = htons(port),
        };
 #endif
+       struct svc_xprt *xprt;
        struct sockaddr *sap;
        size_t len;
 
@@ -224,7 +226,11 @@ static struct svc_xprt *__svc_xpo_create(struct svc_xprt_class *xcl,
                return ERR_PTR(-EAFNOSUPPORT);
        }
 
-       return xcl->xcl_ops->xpo_create(serv, net, sap, len, flags);
+       xprt = xcl->xcl_ops->xpo_create(serv, net, sap, len, flags);
+       if (IS_ERR(xprt))
+               trace_svc_xprt_create_err(serv->sv_program->pg_name,
+                                         xcl->xcl_name, sap, xprt);
+       return xprt;
 }
 
 /*
@@ -304,15 +310,11 @@ int svc_create_xprt(struct svc_serv *serv, const char *xprt_name,
 {
        int err;
 
-       dprintk("svc: creating transport %s[%d]\n", xprt_name, port);
        err = _svc_create_xprt(serv, xprt_name, net, family, port, flags, cred);
        if (err == -EPROTONOSUPPORT) {
                request_module("svc%s", xprt_name);
                err = _svc_create_xprt(serv, xprt_name, net, family, port, flags, cred);
        }
-       if (err < 0)
-               dprintk("svc: transport %s not found, err %d\n",
-                       xprt_name, -err);
        return err;
 }
 EXPORT_SYMBOL_GPL(svc_create_xprt);
@@ -780,7 +782,6 @@ static int svc_handle_xprt(struct svc_rqst *rqstp, struct svc_xprt *xprt)
        int len = 0;
 
        if (test_bit(XPT_CLOSE, &xprt->xpt_flags)) {
-               dprintk("svc_recv: found XPT_CLOSE\n");
                if (test_and_clear_bit(XPT_KILL_TEMP, &xprt->xpt_flags))
                        xprt->xpt_ops->xpo_kill_temp_xprt(xprt);
                svc_delete_xprt(xprt);
@@ -799,6 +800,7 @@ static int svc_handle_xprt(struct svc_rqst *rqstp, struct svc_xprt *xprt)
                if (newxpt) {
                        newxpt->xpt_cred = get_cred(xprt->xpt_cred);
                        svc_add_new_temp_xprt(serv, newxpt);
+                       trace_svc_xprt_accept(newxpt, serv->sv_name);
                } else
                        module_put(xprt->xpt_class->xcl_owner);
        } else if (svc_xprt_reserve_slot(rqstp, xprt)) {
@@ -812,7 +814,7 @@ static int svc_handle_xprt(struct svc_rqst *rqstp, struct svc_xprt *xprt)
                else
                        len = xprt->xpt_ops->xpo_recvfrom(rqstp);
                if (len > 0)
-                       trace_svc_recvfrom(&rqstp->rq_arg);
+                       trace_svc_xdr_recvfrom(rqstp, &rqstp->rq_arg);
                rqstp->rq_stime = ktime_get();
                rqstp->rq_reserved = serv->sv_max_mesg;
                atomic_add(rqstp->rq_reserved, &xprt->xpt_reserved);
@@ -835,14 +837,6 @@ int svc_recv(struct svc_rqst *rqstp, long timeout)
        struct svc_serv         *serv = rqstp->rq_server;
        int                     len, err;
 
-       dprintk("svc: server %p waiting for data (to = %ld)\n",
-               rqstp, timeout);
-
-       if (rqstp->rq_xprt)
-               printk(KERN_ERR
-                       "svc_recv: service %p, transport not NULL!\n",
-                        rqstp);
-
        err = svc_alloc_arg(rqstp);
        if (err)
                goto out;
@@ -890,7 +884,6 @@ EXPORT_SYMBOL_GPL(svc_recv);
 void svc_drop(struct svc_rqst *rqstp)
 {
        trace_svc_drop(rqstp);
-       dprintk("svc: xprt %p dropped request\n", rqstp->rq_xprt);
        svc_xprt_release(rqstp);
 }
 EXPORT_SYMBOL_GPL(svc_drop);
@@ -913,17 +906,11 @@ int svc_send(struct svc_rqst *rqstp)
        xb->len = xb->head[0].iov_len +
                xb->page_len +
                xb->tail[0].iov_len;
-       trace_svc_sendto(xb);
-
-       /* Grab mutex to serialize outgoing data. */
-       mutex_lock(&xprt->xpt_mutex);
+       trace_svc_xdr_sendto(rqstp, xb);
        trace_svc_stats_latency(rqstp);
-       if (test_bit(XPT_DEAD, &xprt->xpt_flags)
-                       || test_bit(XPT_CLOSE, &xprt->xpt_flags))
-               len = -ENOTCONN;
-       else
-               len = xprt->xpt_ops->xpo_sendto(rqstp);
-       mutex_unlock(&xprt->xpt_mutex);
+
+       len = xprt->xpt_ops->xpo_sendto(rqstp);
+
        trace_svc_send(rqstp, len);
        svc_xprt_release(rqstp);
 
@@ -1031,11 +1018,10 @@ static void svc_delete_xprt(struct svc_xprt *xprt)
        struct svc_serv *serv = xprt->xpt_server;
        struct svc_deferred_req *dr;
 
-       /* Only do this once */
        if (test_and_set_bit(XPT_DEAD, &xprt->xpt_flags))
-               BUG();
+               return;
 
-       dprintk("svc: svc_delete_xprt(%p)\n", xprt);
+       trace_svc_xprt_detach(xprt);
        xprt->xpt_ops->xpo_detach(xprt);
        if (xprt->xpt_bc_xprt)
                xprt->xpt_bc_xprt->ops->close(xprt->xpt_bc_xprt);
@@ -1056,6 +1042,7 @@ static void svc_delete_xprt(struct svc_xprt *xprt)
 
 void svc_close_xprt(struct svc_xprt *xprt)
 {
+       trace_svc_xprt_close(xprt);
        set_bit(XPT_CLOSE, &xprt->xpt_flags);
        if (test_and_set_bit(XPT_BUSY, &xprt->xpt_flags))
                /* someone else will have to effect the close */
@@ -1158,16 +1145,15 @@ static void svc_revisit(struct cache_deferred_req *dreq, int too_many)
        set_bit(XPT_DEFERRED, &xprt->xpt_flags);
        if (too_many || test_bit(XPT_DEAD, &xprt->xpt_flags)) {
                spin_unlock(&xprt->xpt_lock);
-               dprintk("revisit canceled\n");
+               trace_svc_defer_drop(dr);
                svc_xprt_put(xprt);
-               trace_svc_drop_deferred(dr);
                kfree(dr);
                return;
        }
-       dprintk("revisit queued\n");
        dr->xprt = NULL;
        list_add(&dr->handle.recent, &xprt->xpt_deferred);
        spin_unlock(&xprt->xpt_lock);
+       trace_svc_defer_queue(dr);
        svc_xprt_enqueue(xprt);
        svc_xprt_put(xprt);
 }
@@ -1213,22 +1199,24 @@ static struct cache_deferred_req *svc_defer(struct cache_req *req)
                memcpy(dr->args, rqstp->rq_arg.head[0].iov_base - skip,
                       dr->argslen << 2);
        }
+       trace_svc_defer(rqstp);
        svc_xprt_get(rqstp->rq_xprt);
        dr->xprt = rqstp->rq_xprt;
        set_bit(RQ_DROPME, &rqstp->rq_flags);
 
        dr->handle.revisit = svc_revisit;
-       trace_svc_defer(rqstp);
        return &dr->handle;
 }
 
 /*
  * recv data from a deferred request into an active one
  */
-static int svc_deferred_recv(struct svc_rqst *rqstp)
+static noinline int svc_deferred_recv(struct svc_rqst *rqstp)
 {
        struct svc_deferred_req *dr = rqstp->rq_deferred;
 
+       trace_svc_defer_recv(dr);
+
        /* setup iov_base past transport header */
        rqstp->rq_arg.head[0].iov_base = dr->args + (dr->xprt_hlen>>2);
        /* The iov_len does not include the transport header bytes */
@@ -1259,7 +1247,6 @@ static struct svc_deferred_req *svc_deferred_dequeue(struct svc_xprt *xprt)
                                struct svc_deferred_req,
                                handle.recent);
                list_del_init(&dr->handle.recent);
-               trace_svc_revisit_deferred(dr);
        } else
                clear_bit(XPT_DEFERRED, &xprt->xpt_flags);
        spin_unlock(&xprt->xpt_lock);