An SKB is not on a list if skb->next is NULL.
Codify this convention into a helper function and use it
where we are dequeueing an SKB and need to mark it as such.
Signed-off-by: David S. Miller <davem@davemloft.net>
        }
 }
 
+static inline void skb_mark_not_on_list(struct sk_buff *skb)
+{
+       skb->next = NULL;
+}
+
 /**
  *     skb_queue_empty - check if a queue is empty
  *     @list: queue head
 
        while (skb) {
                struct sk_buff *next = skb->next;
 
-               skb->next = NULL;
+               skb_mark_not_on_list(skb);
                rc = xmit_one(skb, dev, txq, next != NULL);
                if (unlikely(!dev_xmit_complete(rc))) {
                        skb->next = next;
 
        for (; skb != NULL; skb = next) {
                next = skb->next;
-               skb->next = NULL;
+               skb_mark_not_on_list(skb);
 
                /* in case skb wont be segmented, point to itself */
                skb->prev = skb;
                if (flush_old && NAPI_GRO_CB(skb)->age == jiffies)
                        return;
                list_del(&skb->list);
-               skb->next = NULL;
+               skb_mark_not_on_list(skb);
                napi_gro_complete(skb);
                napi->gro_hash[index].count--;
        }
 
        if (pp) {
                list_del(&pp->list);
-               pp->next = NULL;
+               skb_mark_not_on_list(pp);
                napi_gro_complete(pp);
                napi->gro_hash[hash].count--;
        }
 
                        next = skb->next;
                        prefetch(next);
                        WARN_ON_ONCE(skb_dst_is_noref(skb));
-                       skb->next = NULL;
+                       skb_mark_not_on_list(skb);
                        sk_backlog_rcv(sk, skb);
 
                        cond_resched();
 
        }
        sub_frag_mem_limit(fq->q.net, sum_truesize);
 
-       head->next = NULL;
+       skb_mark_not_on_list(head);
        head->dev = ldev;
        head->tstamp = fq->q.stamp;
 
 
        sub_frag_mem_limit(qp->q.net, head->truesize);
 
        *nextp = NULL;
-       head->next = NULL;
+       skb_mark_not_on_list(head);
        head->prev = NULL;
        head->dev = dev;
        head->tstamp = qp->q.stamp;
 
                /* Handle ip{6}_forward case, as sch_direct_xmit have
                 * another kind of SKB-list usage (see validate_xmit_skb_list)
                 */
-               skb->next = NULL;
+               skb_mark_not_on_list(skb);
                dst_input(skb);
        }
 }
 
                struct sk_buff *nskb = segs->next;
                int err;
 
-               segs->next = NULL;
+               skb_mark_not_on_list(segs);
                err = ip_fragment(net, sk, segs, mtu, ip_finish_output2);
 
                if (err && ret == 0)
 
                        skb = frag;
                        frag = skb->next;
-                       skb->next = NULL;
+                       skb_mark_not_on_list(skb);
                }
 
                if (err == 0) {
 
 
                        skb = frag;
                        frag = skb->next;
-                       skb->next = NULL;
+                       skb_mark_not_on_list(skb);
                }
 
                kfree(tmp_hdr);
 
        sub_frag_mem_limit(fq->q.net, head->truesize);
 
        head->ignore_df = 1;
-       head->next = NULL;
+       skb_mark_not_on_list(head);
        head->dev = dev;
        head->tstamp = fq->q.stamp;
        ipv6_hdr(head)->payload_len = htons(payload_len);
 
        }
        sub_frag_mem_limit(fq->q.net, sum_truesize);
 
-       head->next = NULL;
+       skb_mark_not_on_list(head);
        head->dev = dev;
        head->tstamp = fq->q.stamp;
        ipv6_hdr(head)->payload_len = htons(payload_len);
 
                return ret;
        }
 
-       skb->next = NULL;
+       skb_mark_not_on_list(skb);
 
        entry_seg = nf_queue_entry_dup(entry);
        if (entry_seg) {
 
        while (list) {
                skb = list;
                list = skb->next;
-               skb->next = NULL;
+               skb_mark_not_on_list(skb);
                rxrpc_free_skb(skb, rxrpc_skb_tx_freed);
        }
 }
 
 
        if (skb) {
                flow->head = skb->next;
-               skb->next = NULL;
+               skb_mark_not_on_list(skb);
        }
 
        return skb;
        else
                flow->head = elig_ack->next;
 
-       elig_ack->next = NULL;
+       skb_mark_not_on_list(elig_ack);
 
        return elig_ack;
 }
 
                while (segs) {
                        nskb = segs->next;
-                       segs->next = NULL;
+                       skb_mark_not_on_list(segs);
                        qdisc_skb_cb(segs)->pkt_len = segs->len;
                        cobalt_set_enqueue_time(segs, now);
                        get_cobalt_cb(segs)->adjusted_len = cake_overhead(q,
 
 
        if (skb) {
                flow->head = skb->next;
-               skb->next = NULL;
+               skb_mark_not_on_list(skb);
                flow->qlen--;
                qdisc_qstats_backlog_dec(sch, skb);
                sch->q.qlen--;
 
        struct sk_buff *skb = flow->head;
 
        flow->head = skb->next;
-       skb->next = NULL;
+       skb_mark_not_on_list(skb);
        return skb;
 }
 
 
                skb = nskb;
                (*packets)++; /* GSO counts as one pkt */
        }
-       skb->next = NULL;
+       skb_mark_not_on_list(skb);
 }
 
 /* This variant of try_bulk_dequeue_skb() makes sure
                skb = nskb;
        } while (++cnt < 8);
        (*packets) += cnt;
-       skb->next = NULL;
+       skb_mark_not_on_list(skb);
 }
 
 /* Note that dequeue_skb can possibly return a SKB list (via skb->next).
 
        struct sk_buff *skb = bucket->head;
 
        bucket->head = skb->next;
-       skb->next = NULL;
+       skb_mark_not_on_list(skb);
        return skb;
 }
 
 
        if (segs) {
                while (segs) {
                        skb2 = segs->next;
-                       segs->next = NULL;
+                       skb_mark_not_on_list(segs);
                        qdisc_skb_cb(segs)->pkt_len = segs->len;
                        last_len = segs->len;
                        rc = qdisc_enqueue(segs, sch, to_free);
 
        nb = 0;
        while (segs) {
                nskb = segs->next;
-               segs->next = NULL;
+               skb_mark_not_on_list(segs);
                qdisc_skb_cb(segs)->pkt_len = segs->len;
                len += segs->len;
                ret = qdisc_enqueue(segs, q->qdisc, to_free);
 
                rcu_dereference_rtnl(orig_dev->tipc_ptr);
        if (likely(b && test_bit(0, &b->up) &&
                   (skb->pkt_type <= PACKET_MULTICAST))) {
-               skb->next = NULL;
+               skb_mark_not_on_list(skb);
                tipc_rcv(dev_net(b->pt.dev), skb, b);
                rcu_read_unlock();
                return NET_RX_SUCCESS;
 
 
        do {
                struct sk_buff *nskb = skb2->next;
-               skb2->next = NULL;
+               skb_mark_not_on_list(skb2);
 
                xo = xfrm_offload(skb2);
                xo->flags |= XFRM_DEV_RESUME;
 
                struct sk_buff *nskb = segs->next;
                int err;
 
-               segs->next = NULL;
+               skb_mark_not_on_list(segs);
                err = xfrm_output2(net, sk, segs);
 
                if (unlikely(err)) {