tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

net: Change pseudohdr argument of inet_proto_csum_replace* to be a bool

inet_proto_csum_replace4,2,16 take a pseudohdr argument which indicates
the checksum field carries a pseudo header. This argument should be a
boolean instead of an int.

Signed-off-by: Tom Herbert <tom@herbertland.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

authored by

Tom Herbert and committed by
David S. Miller 4b048d6d 25368623

+38 -36
+3 -3
include/net/checksum.h
··· 140 140 141 141 struct sk_buff; 142 142 void inet_proto_csum_replace4(__sum16 *sum, struct sk_buff *skb, 143 - __be32 from, __be32 to, int pseudohdr); 143 + __be32 from, __be32 to, bool pseudohdr); 144 144 void inet_proto_csum_replace16(__sum16 *sum, struct sk_buff *skb, 145 145 const __be32 *from, const __be32 *to, 146 - int pseudohdr); 146 + bool pseudohdr); 147 147 148 148 static inline void inet_proto_csum_replace2(__sum16 *sum, struct sk_buff *skb, 149 149 __be16 from, __be16 to, 150 - int pseudohdr) 150 + bool pseudohdr) 151 151 { 152 152 inet_proto_csum_replace4(sum, skb, (__force __be32)from, 153 153 (__force __be32)to, pseudohdr);
+1 -1
net/core/filter.c
··· 1349 1349 static u64 bpf_l4_csum_replace(u64 r1, u64 r2, u64 from, u64 to, u64 flags) 1350 1350 { 1351 1351 struct sk_buff *skb = (struct sk_buff *) (long) r1; 1352 - u32 is_pseudo = BPF_IS_PSEUDO_HEADER(flags); 1352 + bool is_pseudo = !!BPF_IS_PSEUDO_HEADER(flags); 1353 1353 int offset = (int) r2; 1354 1354 __sum16 sum, *ptr; 1355 1355
+2 -2
net/core/utils.c
··· 301 301 EXPORT_SYMBOL(in6_pton); 302 302 303 303 void inet_proto_csum_replace4(__sum16 *sum, struct sk_buff *skb, 304 - __be32 from, __be32 to, int pseudohdr) 304 + __be32 from, __be32 to, bool pseudohdr) 305 305 { 306 306 if (skb->ip_summed != CHECKSUM_PARTIAL) { 307 307 csum_replace4(sum, from, to); ··· 318 318 319 319 void inet_proto_csum_replace16(__sum16 *sum, struct sk_buff *skb, 320 320 const __be32 *from, const __be32 *to, 321 - int pseudohdr) 321 + bool pseudohdr) 322 322 { 323 323 __be32 diff[] = { 324 324 ~from[0], ~from[1], ~from[2], ~from[3],
+1 -1
net/ipv4/netfilter/ipt_ECN.c
··· 72 72 tcph->cwr = einfo->proto.tcp.cwr; 73 73 74 74 inet_proto_csum_replace2(&tcph->check, skb, 75 - oldval, ((__be16 *)tcph)[6], 0); 75 + oldval, ((__be16 *)tcph)[6], false); 76 76 return true; 77 77 } 78 78
+2 -2
net/ipv4/netfilter/nf_nat_l3proto_ipv4.c
··· 120 120 oldip = iph->daddr; 121 121 newip = t->dst.u3.ip; 122 122 } 123 - inet_proto_csum_replace4(check, skb, oldip, newip, 1); 123 + inet_proto_csum_replace4(check, skb, oldip, newip, true); 124 124 } 125 125 126 126 static void nf_nat_ipv4_csum_recalc(struct sk_buff *skb, ··· 151 151 } 152 152 } else 153 153 inet_proto_csum_replace2(check, skb, 154 - htons(oldlen), htons(datalen), 1); 154 + htons(oldlen), htons(datalen), true); 155 155 } 156 156 157 157 #if IS_ENABLED(CONFIG_NF_CT_NETLINK)
+1 -1
net/ipv4/netfilter/nf_nat_proto_icmp.c
··· 67 67 68 68 hdr = (struct icmphdr *)(skb->data + hdroff); 69 69 inet_proto_csum_replace2(&hdr->checksum, skb, 70 - hdr->un.echo.id, tuple->src.u.icmp.id, 0); 70 + hdr->un.echo.id, tuple->src.u.icmp.id, false); 71 71 hdr->un.echo.id = tuple->src.u.icmp.id; 72 72 return true; 73 73 }
+2 -2
net/ipv6/netfilter/nf_nat_l3proto_ipv6.c
··· 124 124 newip = &t->dst.u3.in6; 125 125 } 126 126 inet_proto_csum_replace16(check, skb, oldip->s6_addr32, 127 - newip->s6_addr32, 1); 127 + newip->s6_addr32, true); 128 128 } 129 129 130 130 static void nf_nat_ipv6_csum_recalc(struct sk_buff *skb, ··· 155 155 } 156 156 } else 157 157 inet_proto_csum_replace2(check, skb, 158 - htons(oldlen), htons(datalen), 1); 158 + htons(oldlen), htons(datalen), true); 159 159 } 160 160 161 161 #if IS_ENABLED(CONFIG_NF_CT_NETLINK)
+1 -1
net/ipv6/netfilter/nf_nat_proto_icmpv6.c
··· 73 73 hdr->icmp6_type == ICMPV6_ECHO_REPLY) { 74 74 inet_proto_csum_replace2(&hdr->icmp6_cksum, skb, 75 75 hdr->icmp6_identifier, 76 - tuple->src.u.icmp.id, 0); 76 + tuple->src.u.icmp.id, false); 77 77 hdr->icmp6_identifier = tuple->src.u.icmp.id; 78 78 } 79 79 return true;
+5 -4
net/netfilter/nf_conntrack_seqadj.c
··· 103 103 ntohl(sack->end_seq), ntohl(new_end_seq)); 104 104 105 105 inet_proto_csum_replace4(&tcph->check, skb, 106 - sack->start_seq, new_start_seq, 0); 106 + sack->start_seq, new_start_seq, false); 107 107 inet_proto_csum_replace4(&tcph->check, skb, 108 - sack->end_seq, new_end_seq, 0); 108 + sack->end_seq, new_end_seq, false); 109 109 sack->start_seq = new_start_seq; 110 110 sack->end_seq = new_end_seq; 111 111 sackoff += sizeof(*sack); ··· 193 193 newseq = htonl(ntohl(tcph->seq) + seqoff); 194 194 newack = htonl(ntohl(tcph->ack_seq) - ackoff); 195 195 196 - inet_proto_csum_replace4(&tcph->check, skb, tcph->seq, newseq, 0); 197 - inet_proto_csum_replace4(&tcph->check, skb, tcph->ack_seq, newack, 0); 196 + inet_proto_csum_replace4(&tcph->check, skb, tcph->seq, newseq, false); 197 + inet_proto_csum_replace4(&tcph->check, skb, tcph->ack_seq, newack, 198 + false); 198 199 199 200 pr_debug("Adjusting sequence number from %u->%u, ack from %u->%u\n", 200 201 ntohl(tcph->seq), ntohl(newseq), ntohl(tcph->ack_seq),
+1 -1
net/netfilter/nf_nat_proto_dccp.c
··· 69 69 l3proto->csum_update(skb, iphdroff, &hdr->dccph_checksum, 70 70 tuple, maniptype); 71 71 inet_proto_csum_replace2(&hdr->dccph_checksum, skb, oldport, newport, 72 - 0); 72 + false); 73 73 return true; 74 74 } 75 75
+1 -1
net/netfilter/nf_nat_proto_tcp.c
··· 70 70 return true; 71 71 72 72 l3proto->csum_update(skb, iphdroff, &hdr->check, tuple, maniptype); 73 - inet_proto_csum_replace2(&hdr->check, skb, oldport, newport, 0); 73 + inet_proto_csum_replace2(&hdr->check, skb, oldport, newport, false); 74 74 return true; 75 75 } 76 76
+1 -1
net/netfilter/nf_nat_proto_udp.c
··· 57 57 l3proto->csum_update(skb, iphdroff, &hdr->check, 58 58 tuple, maniptype); 59 59 inet_proto_csum_replace2(&hdr->check, skb, *portptr, newport, 60 - 0); 60 + false); 61 61 if (!hdr->check) 62 62 hdr->check = CSUM_MANGLED_0; 63 63 }
+1 -1
net/netfilter/nf_nat_proto_udplite.c
··· 56 56 } 57 57 58 58 l3proto->csum_update(skb, iphdroff, &hdr->check, tuple, maniptype); 59 - inet_proto_csum_replace2(&hdr->check, skb, *portptr, newport, 0); 59 + inet_proto_csum_replace2(&hdr->check, skb, *portptr, newport, false); 60 60 if (!hdr->check) 61 61 hdr->check = CSUM_MANGLED_0; 62 62
+1 -1
net/netfilter/nf_synproxy_core.c
··· 225 225 synproxy->tsoff); 226 226 } 227 227 inet_proto_csum_replace4(&th->check, skb, 228 - old, *ptr, 0); 228 + old, *ptr, false); 229 229 return 1; 230 230 } 231 231 optoff += op[1];
+4 -4
net/netfilter/xt_TCPMSS.c
··· 144 144 145 145 inet_proto_csum_replace2(&tcph->check, skb, 146 146 htons(oldmss), htons(newmss), 147 - 0); 147 + false); 148 148 return 0; 149 149 } 150 150 } ··· 185 185 memmove(opt + TCPOLEN_MSS, opt, len - sizeof(struct tcphdr)); 186 186 187 187 inet_proto_csum_replace2(&tcph->check, skb, 188 - htons(len), htons(len + TCPOLEN_MSS), 1); 188 + htons(len), htons(len + TCPOLEN_MSS), true); 189 189 opt[0] = TCPOPT_MSS; 190 190 opt[1] = TCPOLEN_MSS; 191 191 opt[2] = (newmss & 0xff00) >> 8; 192 192 opt[3] = newmss & 0x00ff; 193 193 194 - inet_proto_csum_replace4(&tcph->check, skb, 0, *((__be32 *)opt), 0); 194 + inet_proto_csum_replace4(&tcph->check, skb, 0, *((__be32 *)opt), false); 195 195 196 196 oldval = ((__be16 *)tcph)[6]; 197 197 tcph->doff += TCPOLEN_MSS/4; 198 198 inet_proto_csum_replace2(&tcph->check, skb, 199 - oldval, ((__be16 *)tcph)[6], 0); 199 + oldval, ((__be16 *)tcph)[6], false); 200 200 return TCPOLEN_MSS; 201 201 } 202 202
+1 -1
net/netfilter/xt_TCPOPTSTRIP.c
··· 80 80 n <<= 8; 81 81 } 82 82 inet_proto_csum_replace2(&tcph->check, skb, htons(o), 83 - htons(n), 0); 83 + htons(n), false); 84 84 } 85 85 memset(opt + i, TCPOPT_NOP, optl); 86 86 }
+6 -6
net/openvswitch/actions.c
··· 284 284 if (nh->protocol == IPPROTO_TCP) { 285 285 if (likely(transport_len >= sizeof(struct tcphdr))) 286 286 inet_proto_csum_replace4(&tcp_hdr(skb)->check, skb, 287 - addr, new_addr, 1); 287 + addr, new_addr, true); 288 288 } else if (nh->protocol == IPPROTO_UDP) { 289 289 if (likely(transport_len >= sizeof(struct udphdr))) { 290 290 struct udphdr *uh = udp_hdr(skb); 291 291 292 292 if (uh->check || skb->ip_summed == CHECKSUM_PARTIAL) { 293 293 inet_proto_csum_replace4(&uh->check, skb, 294 - addr, new_addr, 1); 294 + addr, new_addr, true); 295 295 if (!uh->check) 296 296 uh->check = CSUM_MANGLED_0; 297 297 } ··· 316 316 if (l4_proto == NEXTHDR_TCP) { 317 317 if (likely(transport_len >= sizeof(struct tcphdr))) 318 318 inet_proto_csum_replace16(&tcp_hdr(skb)->check, skb, 319 - addr, new_addr, 1); 319 + addr, new_addr, true); 320 320 } else if (l4_proto == NEXTHDR_UDP) { 321 321 if (likely(transport_len >= sizeof(struct udphdr))) { 322 322 struct udphdr *uh = udp_hdr(skb); 323 323 324 324 if (uh->check || skb->ip_summed == CHECKSUM_PARTIAL) { 325 325 inet_proto_csum_replace16(&uh->check, skb, 326 - addr, new_addr, 1); 326 + addr, new_addr, true); 327 327 if (!uh->check) 328 328 uh->check = CSUM_MANGLED_0; 329 329 } ··· 331 331 } else if (l4_proto == NEXTHDR_ICMP) { 332 332 if (likely(transport_len >= sizeof(struct icmp6hdr))) 333 333 inet_proto_csum_replace16(&icmp6_hdr(skb)->icmp6_cksum, 334 - skb, addr, new_addr, 1); 334 + skb, addr, new_addr, true); 335 335 } 336 336 } 337 337 ··· 498 498 static void set_tp_port(struct sk_buff *skb, __be16 *port, 499 499 __be16 new_port, __sum16 *check) 500 500 { 501 - inet_proto_csum_replace2(check, skb, *port, new_port, 0); 501 + inet_proto_csum_replace2(check, skb, *port, new_port, false); 502 502 *port = new_port; 503 503 } 504 504
+4 -3
net/sched/act_nat.c
··· 162 162 goto drop; 163 163 164 164 tcph = (void *)(skb_network_header(skb) + ihl); 165 - inet_proto_csum_replace4(&tcph->check, skb, addr, new_addr, 1); 165 + inet_proto_csum_replace4(&tcph->check, skb, addr, new_addr, 166 + true); 166 167 break; 167 168 } 168 169 case IPPROTO_UDP: ··· 179 178 udph = (void *)(skb_network_header(skb) + ihl); 180 179 if (udph->check || skb->ip_summed == CHECKSUM_PARTIAL) { 181 180 inet_proto_csum_replace4(&udph->check, skb, addr, 182 - new_addr, 1); 181 + new_addr, true); 183 182 if (!udph->check) 184 183 udph->check = CSUM_MANGLED_0; 185 184 } ··· 232 231 iph->saddr = new_addr; 233 232 234 233 inet_proto_csum_replace4(&icmph->checksum, skb, addr, new_addr, 235 - 0); 234 + false); 236 235 break; 237 236 } 238 237 default: