[NETFILTER]: Decrease number of pointer derefs in nfnetlink_queue.c

Benefits of the patch:
 - Fewer pointer dereferences should make the code slightly faster.
 - Size of generated code is smaller
 - improved readability

Signed-off-by: Jesper Juhl <jesper.juhl@gmail.com>
Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: David S. Miller <davem@davemloft.net>

diff --git a/net/netfilter/nfnetlink_queue.c b/net/netfilter/nfnetlink_queue.c
index 55afdda3d9407af4f1d7bfd4a0bdd7db77c5a8cf..18ed9c5d209ca8e13b1cfc7330862fc3534cd275 100644 (file)
--- a/net/netfilter/nfnetlink_queue.c
+++ b/net/netfilter/nfnetlink_queue.c
@@ -345,6 +345,10 @@ nfqnl_build_packet_message(struct nfqnl_instance *queue,
        struct nfqnl_msg_packet_hdr pmsg;
        struct nlmsghdr *nlh;
        struct nfgenmsg *nfmsg;
+       struct nf_info *entinf = entry->info;
+       struct sk_buff *entskb = entry->skb;
+       struct net_device *indev;
+       struct net_device *outdev;
        unsigned int tmp_uint;
 
        QDEBUG("entered\n");
@@ -361,6 +365,8 @@ nfqnl_build_packet_message(struct nfqnl_instance *queue,
                + NLMSG_SPACE(sizeof(struct nfqnl_msg_packet_hw))
                + NLMSG_SPACE(sizeof(struct nfqnl_msg_packet_timestamp));
 
+       outdev = entinf->outdev;
+
        spin_lock_bh(&queue->lock);
        
        switch (queue->copy_mode) {
@@ -370,15 +376,15 @@ nfqnl_build_packet_message(struct nfqnl_instance *queue,
                break;
        
        case NFQNL_COPY_PACKET:
-               if (entry->skb->ip_summed == CHECKSUM_HW &&
-                   (*errp = skb_checksum_help(entry->skb,
-                                              entry->info->outdev == NULL))) {
+               if (entskb->ip_summed == CHECKSUM_HW &&
+                   (*errp = skb_checksum_help(entskb,
+                                              outdev == NULL))) {
                        spin_unlock_bh(&queue->lock);
                        return NULL;
                }
                if (queue->copy_range == 0 
-                   || queue->copy_range > entry->skb->len)
-                       data_len = entry->skb->len;
+                   || queue->copy_range > entskb->len)
+                       data_len = entskb->len;
                else
                        data_len = queue->copy_range;
                
@@ -402,29 +408,30 @@ nfqnl_build_packet_message(struct nfqnl_instance *queue,
                        NFNL_SUBSYS_QUEUE << 8 | NFQNL_MSG_PACKET,
                        sizeof(struct nfgenmsg));
        nfmsg = NLMSG_DATA(nlh);
-       nfmsg->nfgen_family = entry->info->pf;
+       nfmsg->nfgen_family = entinf->pf;
        nfmsg->version = NFNETLINK_V0;
        nfmsg->res_id = htons(queue->queue_num);
 
        pmsg.packet_id          = htonl(entry->id);
-       pmsg.hw_protocol        = htons(entry->skb->protocol);
-       pmsg.hook               = entry->info->hook;
+       pmsg.hw_protocol        = htons(entskb->protocol);
+       pmsg.hook               = entinf->hook;
 
        NFA_PUT(skb, NFQA_PACKET_HDR, sizeof(pmsg), &pmsg);
 
-       if (entry->info->indev) {
-               tmp_uint = htonl(entry->info->indev->ifindex);
+       indev = entinf->indev;
+       if (indev) {
+               tmp_uint = htonl(indev->ifindex);
 #ifndef CONFIG_BRIDGE_NETFILTER
                NFA_PUT(skb, NFQA_IFINDEX_INDEV, sizeof(tmp_uint), &tmp_uint);
 #else
-               if (entry->info->pf == PF_BRIDGE) {
+               if (entinf->pf == PF_BRIDGE) {
                        /* Case 1: indev is physical input device, we need to
                         * look for bridge group (when called from 
                         * netfilter_bridge) */
                        NFA_PUT(skb, NFQA_IFINDEX_PHYSINDEV, sizeof(tmp_uint), 
                                &tmp_uint);
                        /* this is the bridge group "brX" */
-                       tmp_uint = htonl(entry->info->indev->br_port->br->dev->ifindex);
+                       tmp_uint = htonl(indev->br_port->br->dev->ifindex);
                        NFA_PUT(skb, NFQA_IFINDEX_INDEV, sizeof(tmp_uint),
                                &tmp_uint);
                } else {
@@ -432,9 +439,9 @@ nfqnl_build_packet_message(struct nfqnl_instance *queue,
                         * physical device (when called from ipv4) */
                        NFA_PUT(skb, NFQA_IFINDEX_INDEV, sizeof(tmp_uint),
                                &tmp_uint);
-                       if (entry->skb->nf_bridge
-                           && entry->skb->nf_bridge->physindev) {
-                               tmp_uint = htonl(entry->skb->nf_bridge->physindev->ifindex);
+                       if (entskb->nf_bridge
+                           && entskb->nf_bridge->physindev) {
+                               tmp_uint = htonl(entskb->nf_bridge->physindev->ifindex);
                                NFA_PUT(skb, NFQA_IFINDEX_PHYSINDEV,
                                        sizeof(tmp_uint), &tmp_uint);
                        }
@@ -442,19 +449,19 @@ nfqnl_build_packet_message(struct nfqnl_instance *queue,
 #endif
        }
 
-       if (entry->info->outdev) {
-               tmp_uint = htonl(entry->info->outdev->ifindex);
+       if (outdev) {
+               tmp_uint = htonl(outdev->ifindex);
 #ifndef CONFIG_BRIDGE_NETFILTER
                NFA_PUT(skb, NFQA_IFINDEX_OUTDEV, sizeof(tmp_uint), &tmp_uint);
 #else
-               if (entry->info->pf == PF_BRIDGE) {
+               if (entinf->pf == PF_BRIDGE) {
                        /* Case 1: outdev is physical output device, we need to
                         * look for bridge group (when called from 
                         * netfilter_bridge) */
                        NFA_PUT(skb, NFQA_IFINDEX_PHYSOUTDEV, sizeof(tmp_uint),
                                &tmp_uint);
                        /* this is the bridge group "brX" */
-                       tmp_uint = htonl(entry->info->outdev->br_port->br->dev->ifindex);
+                       tmp_uint = htonl(outdev->br_port->br->dev->ifindex);
                        NFA_PUT(skb, NFQA_IFINDEX_OUTDEV, sizeof(tmp_uint),
                                &tmp_uint);
                } else {
@@ -462,9 +469,9 @@ nfqnl_build_packet_message(struct nfqnl_instance *queue,
                         * physical output device (when called from ipv4) */
                        NFA_PUT(skb, NFQA_IFINDEX_OUTDEV, sizeof(tmp_uint),
                                &tmp_uint);
-                       if (entry->skb->nf_bridge
-                           && entry->skb->nf_bridge->physoutdev) {
-                               tmp_uint = htonl(entry->skb->nf_bridge->physoutdev->ifindex);
+                       if (entskb->nf_bridge
+                           && entskb->nf_bridge->physoutdev) {
+                               tmp_uint = htonl(entskb->nf_bridge->physoutdev->ifindex);
                                NFA_PUT(skb, NFQA_IFINDEX_PHYSOUTDEV,
                                        sizeof(tmp_uint), &tmp_uint);
                        }
@@ -472,27 +479,27 @@ nfqnl_build_packet_message(struct nfqnl_instance *queue,
 #endif
        }
 
-       if (entry->skb->nfmark) {
-               tmp_uint = htonl(entry->skb->nfmark);
+       if (entskb->nfmark) {
+               tmp_uint = htonl(entskb->nfmark);
                NFA_PUT(skb, NFQA_MARK, sizeof(u_int32_t), &tmp_uint);
        }
 
-       if (entry->info->indev && entry->skb->dev
-           && entry->skb->dev->hard_header_parse) {
+       if (indev && entskb->dev
+           && entskb->dev->hard_header_parse) {
                struct nfqnl_msg_packet_hw phw;
 
                phw.hw_addrlen =
-                       entry->skb->dev->hard_header_parse(entry->skb,
+                       entskb->dev->hard_header_parse(entskb,
                                                           phw.hw_addr);
                phw.hw_addrlen = htons(phw.hw_addrlen);
                NFA_PUT(skb, NFQA_HWADDR, sizeof(phw), &phw);
        }
 
-       if (entry->skb->tstamp.off_sec) {
+       if (entskb->tstamp.off_sec) {
                struct nfqnl_msg_packet_timestamp ts;
 
-               ts.sec = cpu_to_be64(entry->skb->tstamp.off_sec);
-               ts.usec = cpu_to_be64(entry->skb->tstamp.off_usec);
+               ts.sec = cpu_to_be64(entskb->tstamp.off_sec);
+               ts.usec = cpu_to_be64(entskb->tstamp.off_usec);
 
                NFA_PUT(skb, NFQA_TIMESTAMP, sizeof(ts), &ts);
        }
@@ -510,7 +517,7 @@ nfqnl_build_packet_message(struct nfqnl_instance *queue,
                nfa->nfa_type = NFQA_PAYLOAD;
                nfa->nfa_len = size;
 
-               if (skb_copy_bits(entry->skb, 0, NFA_DATA(nfa), data_len))
+               if (skb_copy_bits(entskb, 0, NFA_DATA(nfa), data_len))
                        BUG();
        }
                
@@ -667,12 +674,14 @@ nfqnl_set_mode(struct nfqnl_instance *queue,
 static int
 dev_cmp(struct nfqnl_queue_entry *entry, unsigned long ifindex)
 {
-       if (entry->info->indev)
-               if (entry->info->indev->ifindex == ifindex)
+       struct nf_info *entinf = entry->info;
+       
+       if (entinf->indev)
+               if (entinf->indev->ifindex == ifindex)
                        return 1;
                        
-       if (entry->info->outdev)
-               if (entry->info->outdev->ifindex == ifindex)
+       if (entinf->outdev)
+               if (entinf->outdev->ifindex == ifindex)
                        return 1;
 
        return 0;