From 6506f45c0818618e96deb858bbabdf2cc90eb2df Mon Sep 17 00:00:00 2001 From: Ben Pfaff Date: Fri, 6 May 2011 12:59:51 -0700 Subject: [PATCH] Make the source tree sparse clean. With this commit, the tree compiles clean with sparse commit 87f4a7fda3d "Teach 'already_tokenized()' to use the stream name hash table" with patch "evaluate: Allow sizeof(_Bool) to succeed" available at http://permalink.gmane.org/gmane.comp.parsers.sparse/2461 applied, as long as the "include/sparse" directory is included for use by sparse (only), e.g.: make CC="CHECK='sparse -I../include/sparse' cgcc" --- include/automake.mk | 1 + include/sparse/arpa/inet.h | 21 ++++ include/sparse/assert.h | 22 ++++ include/sparse/automake.mk | 8 ++ include/sparse/math.h | 203 +++++++++++++++++++++++++++++++++++ include/sparse/netinet/in.h | 95 ++++++++++++++++ include/sparse/netinet/ip6.h | 61 +++++++++++ include/sparse/sys/socket.h | 133 +++++++++++++++++++++++ include/sparse/sys/wait.h | 34 ++++++ lib/byte-order.h | 16 ++- lib/csum.c | 7 ++ lib/netdev-linux.c | 3 +- lib/sflow_receiver.c | 4 + lib/unaligned.h | 7 ++ ofproto/ofproto-sflow.c | 2 +- tests/test-byte-order.c | 6 +- 16 files changed, 616 insertions(+), 7 deletions(-) create mode 100644 include/sparse/arpa/inet.h create mode 100644 include/sparse/assert.h create mode 100644 include/sparse/automake.mk create mode 100644 include/sparse/math.h create mode 100644 include/sparse/netinet/in.h create mode 100644 include/sparse/netinet/ip6.h create mode 100644 include/sparse/sys/socket.h create mode 100644 include/sparse/sys/wait.h diff --git a/include/automake.mk b/include/automake.mk index 5c07a6aac..f34e5c9bf 100644 --- a/include/automake.mk +++ b/include/automake.mk @@ -1,3 +1,4 @@ include include/linux/automake.mk include include/openflow/automake.mk include include/openvswitch/automake.mk +include include/sparse/automake.mk diff --git a/include/sparse/arpa/inet.h b/include/sparse/arpa/inet.h new file mode 100644 index 000000000..c545f29d8 --- /dev/null +++ b/include/sparse/arpa/inet.h @@ -0,0 +1,21 @@ +/* + * Copyright (c) 2011 Nicira Networks. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef __CHECKER__ +#error "Use this header only with sparse. It is not a correct implementation." +#endif + +#include diff --git a/include/sparse/assert.h b/include/sparse/assert.h new file mode 100644 index 000000000..f396761a5 --- /dev/null +++ b/include/sparse/assert.h @@ -0,0 +1,22 @@ +/* + * Copyright (c) 2011 Nicira Networks. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef __CHECKER__ +#error "Use this header only with sparse. It is not a correct implementation." +#endif + +extern void __ovs_assert(_Bool); +#define assert(EXPRESSION) __ovs_assert(EXPRESSION) diff --git a/include/sparse/automake.mk b/include/sparse/automake.mk new file mode 100644 index 000000000..1a77500b9 --- /dev/null +++ b/include/sparse/automake.mk @@ -0,0 +1,8 @@ +noinst_HEADERS += \ + include/sparse/arpa/inet.h \ + include/sparse/assert.h \ + include/sparse/math.h \ + include/sparse/netinet/in.h \ + include/sparse/netinet/ip6.h \ + include/sparse/sys/socket.h \ + include/sparse/sys/wait.h diff --git a/include/sparse/math.h b/include/sparse/math.h new file mode 100644 index 000000000..884c6de87 --- /dev/null +++ b/include/sparse/math.h @@ -0,0 +1,203 @@ +/* + * Copyright (c) 2011 Nicira Networks. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef __CHECKER__ +#error "Use this header only with sparse. It is not a correct implementation." +#endif + +#ifndef __SYS_MATH_SPARSE +#define __SYS_MATH_SPARSE 1 + +double acos(double); +float acosf(float); +double acosh(double); +float acoshf(float); +long double acoshl(long double); +long double acosl(long double); +double asin(double); +float asinf(float); +double asinh(double); +float asinhf(float); +long double asinhl(long double); +long double asinl(long double); +double atan(double); +double atan2(double, double); +float atan2f(float, float); +long double atan2l(long double, long double); +float atanf(float); +double atanh(double); +float atanhf(float); +long double atanhl(long double); +long double atanl(long double); +double cbrt(double); +float cbrtf(float); +long double cbrtl(long double); +double ceil(double); +float ceilf(float); +long double ceill(long double); +double copysign(double, double); +float copysignf(float, float); +long double copysignl(long double, long double); +double cos(double); +float cosf(float); +double cosh(double); +float coshf(float); +long double coshl(long double); +long double cosl(long double); +double erf(double); +double erfc(double); +float erfcf(float); +long double erfcl(long double); +float erff(float); +long double erfl(long double); +double exp(double); +double exp2(double); +float exp2f(float); +long double exp2l(long double); +float expf(float); +long double expl(long double); +double expm1(double); +float expm1f(float); +long double expm1l(long double); +double fabs(double); +float fabsf(float); +long double fabsl(long double); +double fdim(double, double); +float fdimf(float, float); +long double fdiml(long double, long double); +double floor(double); +float floorf(float); +long double floorl(long double); +double fma(double, double, double); +float fmaf(float, float, float); +long double fmal(long double, long double, long double); +double fmax(double, double); +float fmaxf(float, float); +long double fmaxl(long double, long double); +double fmin(double, double); +float fminf(float, float); +long double fminl(long double, long double); +double fmod(double, double); +float fmodf(float, float); +long double fmodl(long double, long double); +double frexp(double, int *); +float frexpf(float value, int *); +long double frexpl(long double value, int *); +double hypot(double, double); +float hypotf(float, float); +long double hypotl(long double, long double); +int ilogb(double); +int ilogbf(float); +int ilogbl(long double); +double j0(double); +double j1(double); +double jn(int, double); +double ldexp(double, int); +float ldexpf(float, int); +long double ldexpl(long double, int); +double lgamma(double); +float lgammaf(float); +long double lgammal(long double); +long long llrint(double); +long long llrintf(float); +long long llrintl(long double); +long long llround(double); +long long llroundf(float); +long long llroundl(long double); +double log(double); +double log10(double); +float log10f(float); +long double log10l(long double); +double log1p(double); +float log1pf(float); +long double log1pl(long double); +double log2(double); +float log2f(float); +long double log2l(long double); +double logb(double); +float logbf(float); +long double logbl(long double); +float logf(float); +long double logl(long double); +long lrint(double); +long lrintf(float); +long lrintl(long double); +long lround(double); +long lroundf(float); +long lroundl(long double); +double modf(double, double *); +float modff(float, float *); +long double modfl(long double, long double *); +double nan(const char *); +float nanf(const char *); +long double nanl(const char *); +double nearbyint(double); +float nearbyintf(float); +long double nearbyintl(long double); +double nextafter(double, double); +float nextafterf(float, float); +long double nextafterl(long double, long double); +double nexttoward(double, long double); +float nexttowardf(float, long double); +long double nexttowardl(long double, long double); +double pow(double, double); +float powf(float, float); +long double powl(long double, long double); +double remainder(double, double); +float remainderf(float, float); +long double remainderl(long double, long double); +double remquo(double, double, int *); +float remquof(float, float, int *); +long double remquol(long double, long double, int *); +double rint(double); +float rintf(float); +long double rintl(long double); +double round(double); +float roundf(float); +long double roundl(long double); +double scalb(double, double); +double scalbln(double, long); +float scalblnf(float, long); +long double scalblnl(long double, long); +double scalbn(double, int); +float scalbnf(float, int); +long double scalbnl(long double, int); +double sin(double); +float sinf(float); +double sinh(double); +float sinhf(float); +long double sinhl(long double); +long double sinl(long double); +double sqrt(double); +float sqrtf(float); +long double sqrtl(long double); +double tan(double); +float tanf(float); +double tanh(double); +float tanhf(float); +long double tanhl(long double); +long double tanl(long double); +double tgamma(double); +float tgammaf(float); +long double tgammal(long double); +double trunc(double); +float truncf(float); +long double truncl(long double); +double y0(double); +double y1(double); +double yn(int, double); + +#endif /* for sparse */ diff --git a/include/sparse/netinet/in.h b/include/sparse/netinet/in.h new file mode 100644 index 000000000..d86431ada --- /dev/null +++ b/include/sparse/netinet/in.h @@ -0,0 +1,95 @@ +/* + * Copyright (c) 2011 Nicira Networks. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef __CHECKER__ +#error "Use this header only with sparse. It is not a correct implementation." +#endif + +#ifndef __NETINET_IN_SPARSE +#define __NETINET_IN_SPARSE 1 + +#include "openvswitch/types.h" +#include +#include + +typedef ovs_be16 in_port_t; +typedef ovs_be32 in_addr_t; + +struct in_addr { + in_addr_t s_addr; +}; + +struct sockaddr_in { + sa_family_t sin_family; + in_port_t sin_port; + struct in_addr sin_addr; +}; + +struct in6_addr { + union { + uint8_t u_s6_addr[16]; + } u; +}; + +#define s6_addr u.u_s6_addr + +extern const struct in6_addr in6addr_any; + +#define IPPROTO_IP 0 +#define IPPROTO_HOPOPTS 0 +#define IPPROTO_ICMP 1 +#define IPPROTO_TCP 6 +#define IPPROTO_UDP 17 +#define IPPROTO_ROUTING 43 +#define IPPROTO_FRAGMENT 44 +#define IPPROTO_AH 51 +#define IPPROTO_ICMPV6 58 +#define IPPROTO_NONE 59 +#define IPPROTO_DSTOPTS 60 + +#define INADDR_ANY 0x00000000 +#define INADDR_BROADCAST 0xffffffff +#define INADDR_NONE 0xffffffff + +#define INET6_ADDRSTRLEN 46 + +static inline ovs_be32 htonl(uint32_t x) +{ + return (OVS_FORCE ovs_be32) x; +} + +static inline ovs_be16 htons(uint16_t x) +{ + return (OVS_FORCE ovs_be16) x; +} + +static inline uint32_t ntohl(ovs_be32 x) +{ + return (OVS_FORCE uint32_t) x; +} + +static inline uint16_t ntohs(ovs_be16 x) +{ + return (OVS_FORCE uint16_t) x; +} + +in_addr_t inet_addr(const char *); +int inet_aton (const char *, struct in_addr *); +char *inet_ntoa(struct in_addr); +const char *inet_ntop(int, const void *, char *, socklen_t); +int inet_pton(int, const char *, void *); + +#endif /* sparse */ diff --git a/include/sparse/netinet/ip6.h b/include/sparse/netinet/ip6.h new file mode 100644 index 000000000..c6608a144 --- /dev/null +++ b/include/sparse/netinet/ip6.h @@ -0,0 +1,61 @@ +/* + * Copyright (c) 2011 Nicira Networks. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef __CHECKER__ +#error "Use this header only with sparse. It is not a correct implementation." +#endif + +#ifndef __NETINET_IP6_SPARSE +#define __NETINET_IP6_SPARSE 1 + +#include + +struct ip6_hdr { + union { + struct ip6_hdrctl { + ovs_be32 ip6_un1_flow; + ovs_be16 ip6_un1_plen; + uint8_t ip6_un1_nxt; + uint8_t ip6_un1_hlim; + } ip6_un1; + uint8_t ip6_un2_vfc; + } ip6_ctlun; + struct in6_addr ip6_src; + struct in6_addr ip6_dst; +}; + +#define ip6_vfc ip6_ctlun.ip6_un2_vfc +#define ip6_flow ip6_ctlun.ip6_un1.ip6_un1_flow +#define ip6_plen ip6_ctlun.ip6_un1.ip6_un1_plen +#define ip6_nxt ip6_ctlun.ip6_un1.ip6_un1_nxt +#define ip6_hlim ip6_ctlun.ip6_un1.ip6_un1_hlim +#define ip6_hops ip6_ctlun.ip6_un1.ip6_un1_hlim + +struct ip6_ext { + uint8_t ip6e_nxt; + uint8_t ip6e_len; +}; + +struct ip6_frag { + uint8_t ip6f_nxt; + uint8_t ip6f_reserved; + ovs_be16 ip6f_offlg; + ovs_be32 ip6f_ident; +}; + +#define IP6F_OFF_MASK ((OVS_FORCE ovs_be16) 0xfff8) + +#endif /* netinet/ip6.h sparse */ diff --git a/include/sparse/sys/socket.h b/include/sparse/sys/socket.h new file mode 100644 index 000000000..89e3c2dc2 --- /dev/null +++ b/include/sparse/sys/socket.h @@ -0,0 +1,133 @@ +/* + * Copyright (c) 2011 Nicira Networks. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef __CHECKER__ +#error "Use this header only with sparse. It is not a correct implementation." +#endif + +#ifndef __SYS_SOCKET_SPARSE +#define __SYS_SOCKET_SPARSE 1 + +#include "openvswitch/types.h" +#include + +typedef unsigned short int sa_family_t; +typedef __socklen_t socklen_t; + +struct sockaddr { + sa_family_t sa_family; + char sa_data[64]; +}; + +struct sockaddr_storage { + sa_family_t ss_family; + char sa_data[64]; +}; + +struct msghdr { + void *msg_name; + socklen_t msg_namelen; + struct iovec *msg_iov; + int msg_iovlen; + void *msg_control; + socklen_t msg_controllen; + int msg_flags; +}; + +enum { + SOCK_DGRAM, + SOCK_RAW, + SOCK_SEQPACKET, + SOCK_STREAM +}; + +enum { + SOL_SOCKET +}; + +enum { + SO_ACCEPTCONN, + SO_BROADCAST, + SO_DEBUG, + SO_DONTROUTE, + SO_ERROR, + SO_KEEPALIVE, + SO_LINGER, + SO_OOBINLINE, + SO_RCVBUF, + SO_RCVLOWAT, + SO_RCVTIMEO, + SO_REUSEADDR, + SO_SNDBUF, + SO_SNDLOWAT, + SO_SNDTIMEO, + SO_TYPE +}; + +enum { + MSG_CTRUNC, + MSG_DONTROUTE, + MSG_EOR, + MSG_OOB, + MSG_NOSIGNAL, + MSG_PEEK, + MSG_TRUNC, + MSG_WAITALL, + MSG_DONTWAIT +}; + +enum { + AF_UNSPEC, + PF_UNSPEC = AF_UNSPEC, + AF_INET, + PF_INET = AF_INET, + AF_INET6, + PF_INET6 = AF_INET6, + AF_UNIX, + PF_UNIX = AF_UNIX, + AF_NETLINK, + PF_NETLINK = AF_NETLINK, + AF_PACKET, + PF_PACKET = AF_PACKET +}; + +enum { + SHUT_RD, + SHUT_RDWR, + SHUT_WR +}; + +int accept(int, struct sockaddr *, socklen_t *); +int bind(int, const struct sockaddr *, socklen_t); +int connect(int, const struct sockaddr *, socklen_t); +int getpeername(int, struct sockaddr *, socklen_t *); +int getsockname(int, struct sockaddr *, socklen_t *); +int getsockopt(int, int, int, void *, socklen_t *); +int listen(int, int); +ssize_t recv(int, void *, size_t, int); +ssize_t recvfrom(int, void *, size_t, int, struct sockaddr *, socklen_t *); +ssize_t recvmsg(int, struct msghdr *, int); +ssize_t send(int, const void *, size_t, int); +ssize_t sendmsg(int, const struct msghdr *, int); +ssize_t sendto(int, const void *, size_t, int, const struct sockaddr *, + socklen_t); +int setsockopt(int, int, int, const void *, socklen_t); +int shutdown(int, int); +int sockatmark(int); +int socket(int, int, int); +int socketpair(int, int, int, int[2]); + +#endif /* for sparse */ diff --git a/include/sparse/sys/wait.h b/include/sparse/sys/wait.h new file mode 100644 index 000000000..31e1d76a6 --- /dev/null +++ b/include/sparse/sys/wait.h @@ -0,0 +1,34 @@ +/* + * Copyright (c) 2011 Nicira Networks. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef __CHECKER__ +#error "Use this header only with sparse. It is not a correct implementation." +#endif + +#ifndef __SYS_WAIT_SPARSE +#define __SYS_WAIT_SPARSE 1 + +#include_next + +#undef wait +#define wait(a) rpl_wait(a) +pid_t rpl_wait(int *); + +#undef waitpid +#define waitpid(a, b, c) rpl_waitpid(a, b, c) +pid_t rpl_waitpid(pid_t, int *, int); + +#endif /* for sparse */ diff --git a/lib/byte-order.h b/lib/byte-order.h index d2bc8db72..993137fb7 100644 --- a/lib/byte-order.h +++ b/lib/byte-order.h @@ -21,6 +21,7 @@ #include #include "openvswitch/types.h" +#ifndef __CHECKER__ static inline ovs_be64 htonll(uint64_t n) { @@ -32,14 +33,21 @@ ntohll(ovs_be64 n) { return htonl(1) == 1 ? n : ((uint64_t) ntohl(n) << 32) | ntohl(n >> 32); } +#else +/* Making sparse happy with these functions also makes them unreadable, so + * don't bother to show it their implementations. */ +ovs_be64 htonll(uint64_t); +uint64_t ntohll(ovs_be64); +#endif /* These macros may substitute for htons(), htonl(), and htonll() in contexts * where function calls are not allowed, such as case labels. They should not * be used elsewhere because all of them evaluate their argument many times. */ -#ifdef WORDS_BIGENDIAN -#define CONSTANT_HTONS(VALUE) ((ovs_be16) (VALUE)) -#define CONSTANT_HTONL(VALUE) ((ovs_be32) (VALUE)) -#define CONSTANT_HTONLL(VALUE) ((ovs_be64) (VALUE)) +#if defined(WORDS_BIGENDIAN) || __CHECKER__ +#define CONSTANT_HTONS(VALUE) ((OVS_FORCE ovs_be16) ((VALUE) & 0xffff)) +#define CONSTANT_HTONL(VALUE) ((OVS_FORCE ovs_be32) ((VALUE) & 0xffffffff)) +#define CONSTANT_HTONLL(VALUE) \ + ((OVS_FORCE ovs_be64) ((VALUE) & UINT64_C(0xffffffffffffffff))) #else #define CONSTANT_HTONS(VALUE) \ (((((ovs_be16) (VALUE)) & 0xff00) >> 8) | \ diff --git a/lib/csum.c b/lib/csum.c index 668d7108e..47e803e39 100644 --- a/lib/csum.c +++ b/lib/csum.c @@ -18,6 +18,8 @@ #include "csum.h" #include "unaligned.h" +#ifndef __CHECKER__ + /* Returns the IP checksum of the 'n' bytes in 'data'. * * The return value has the same endianness as the data. That is, if 'data' @@ -109,3 +111,8 @@ recalc_csum32(ovs_be16 old_csum, ovs_be32 old_u32, ovs_be32 new_u32) return recalc_csum16(recalc_csum16(old_csum, old_u32, new_u32), old_u32 >> 16, new_u32 >> 16); } + +#else /* __CHECKER__ */ +/* Making sparse happy with these functions also makes them unreadable, so + * don't bother to show it their implementations. */ +#endif diff --git a/lib/netdev-linux.c b/lib/netdev-linux.c index cd104b320..fde686c83 100644 --- a/lib/netdev-linux.c +++ b/lib/netdev-linux.c @@ -673,7 +673,8 @@ netdev_linux_open(struct netdev_dev *netdev_dev_, int ethertype, protocol = (ethertype == NETDEV_ETH_TYPE_ANY ? ETH_P_ALL : ethertype == NETDEV_ETH_TYPE_802_2 ? ETH_P_802_2 : ethertype); - netdev->fd = socket(PF_PACKET, SOCK_RAW, htons(protocol)); + netdev->fd = socket(PF_PACKET, SOCK_RAW, + (OVS_FORCE int) htons(protocol)); if (netdev->fd < 0) { error = errno; goto error; diff --git a/lib/sflow_receiver.c b/lib/sflow_receiver.c index 0e34959d6..019f38f7e 100644 --- a/lib/sflow_receiver.c +++ b/lib/sflow_receiver.c @@ -1,6 +1,8 @@ /* Copyright (c) 2002-2009 InMon Corp. Licensed under the terms of the InMon sFlow licence: */ /* http://www.inmon.com/technology/sflowlicense.txt */ +#ifndef __CHECKER__ /* Don't run sparse on anything in this file. */ + #include #include "sflow_api.h" @@ -830,3 +832,5 @@ static void sflError(SFLReceiver *receiver, char *msg) sfl_agent_error(receiver->agent, "receiver", msg); resetSampleCollector(receiver); } + +#endif /* !__CHECKER__ */ diff --git a/lib/unaligned.h b/lib/unaligned.h index a44ee8be8..f1aab23ad 100644 --- a/lib/unaligned.h +++ b/lib/unaligned.h @@ -156,6 +156,7 @@ put_32aligned_u64(ovs_32aligned_u64 *x, uint64_t value) x->lo = value; } +#ifndef __CHECKER__ /* Returns the value of 'x'. */ static inline ovs_be64 get_32aligned_be64(const ovs_32aligned_be64 *x) @@ -179,5 +180,11 @@ put_32aligned_be64(ovs_32aligned_be64 *x, ovs_be64 value) x->lo = value >> 32; #endif } +#else /* __CHECKER__ */ +/* Making sparse happy with these functions also makes them unreadable, so + * don't bother to show it their implementations. */ +ovs_be64 get_32aligned_be64(const ovs_32aligned_be64 *); +void put_32aligned_be64(ovs_32aligned_be64 *, ovs_be64); +#endif #endif /* unaligned.h */ diff --git a/ofproto/ofproto-sflow.c b/ofproto/ofproto-sflow.c index 5351b8378..a3f4d810f 100644 --- a/ofproto/ofproto-sflow.c +++ b/ofproto/ofproto-sflow.c @@ -252,7 +252,7 @@ sflow_choose_agent_address(const char *agent_device, const char *control_ip, return false; success: - agent_addr->address.ip_v4.addr = in4.s_addr; + agent_addr->address.ip_v4.addr = (OVS_FORCE uint32_t) in4.s_addr; return true; } diff --git a/tests/test-byte-order.c b/tests/test-byte-order.c index 187075457..1c5bf388e 100644 --- a/tests/test-byte-order.c +++ b/tests/test-byte-order.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2010 Nicira Networks. + * Copyright (c) 2010, 2011 Nicira Networks. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -22,6 +22,7 @@ int main(void) { +#ifndef __CHECKER__ /* I picked some random numbers. */ const uint16_t s = 0xc9bd; const uint32_t l = 0xffe56ae8; @@ -44,6 +45,9 @@ main(void) assert(ntohll(htonll(ll)) == ll); assert(CONSTANT_HTONLL(ntohll(ll)) == ll); assert(ntohll(CONSTANT_HTONLL(ll))); +#else /* __CHECKER__ */ +/* Making sparse happy with this code makes it unreadable, so don't bother. */ +#endif return 0; } -- 2.43.0