netdev-bsd: Fix tx/rx stats for type=tap netdev
[sliver-openvswitch.git] / m4 / openvswitch.m4
1 # -*- autoconf -*-
2
3 # Copyright (c) 2008, 2009, 2010, 2011, 2012, 2013, 2014 Nicira, Inc.
4 #
5 # Licensed under the Apache License, Version 2.0 (the "License");
6 # you may not use this file except in compliance with the License.
7 # You may obtain a copy of the License at:
8 #
9 #     http://www.apache.org/licenses/LICENSE-2.0
10 #
11 # Unless required by applicable law or agreed to in writing, software
12 # distributed under the License is distributed on an "AS IS" BASIS,
13 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 # See the License for the specific language governing permissions and
15 # limitations under the License.
16
17 dnl Checks for --enable-coverage and updates CFLAGS and LDFLAGS appropriately.
18 AC_DEFUN([OVS_CHECK_COVERAGE],
19   [AC_REQUIRE([AC_PROG_CC])
20    AC_ARG_ENABLE(
21      [coverage],
22      [AC_HELP_STRING([--enable-coverage],
23                      [Enable gcov coverage tool.])],
24      [case "${enableval}" in
25         (yes) coverage=true ;;
26         (no)  coverage=false ;;
27         (*) AC_MSG_ERROR([bad value ${enableval} for --enable-coverage]) ;;
28       esac],
29      [coverage=false])
30    if $coverage; then
31      CFLAGS="$CFLAGS -O0 --coverage"
32      LDFLAGS="$LDFLAGS --coverage"
33    fi])
34
35 dnl Checks for --enable-ndebug and defines NDEBUG if it is specified.
36 AC_DEFUN([OVS_CHECK_NDEBUG],
37   [AC_ARG_ENABLE(
38      [ndebug],
39      [AC_HELP_STRING([--enable-ndebug],
40                      [Disable debugging features for max performance])],
41      [case "${enableval}" in
42         (yes) ndebug=true ;;
43         (no)  ndebug=false ;;
44         (*) AC_MSG_ERROR([bad value ${enableval} for --enable-ndebug]) ;;
45       esac],
46      [ndebug=false])
47    AM_CONDITIONAL([NDEBUG], [test x$ndebug = xtrue])])
48
49 dnl Checks for ESX.
50 AC_DEFUN([OVS_CHECK_ESX],
51   [AC_CHECK_HEADER([vmware.h],
52                    [ESX=yes],
53                    [ESX=no])
54    AM_CONDITIONAL([ESX], [test "$ESX" = yes])
55    if test "$ESX" = yes; then
56       AC_DEFINE([ESX], [1], [Define to 1 if building on ESX.])
57    fi])
58
59 dnl Checks for WINDOWS.
60 AC_DEFUN([OVS_CHECK_WIN32],
61   [AC_CHECK_HEADER([windows.h],
62                    [WIN32=yes],
63                    [WIN32=no])
64    AM_CONDITIONAL([WIN32], [test "$WIN32" = yes])
65    if test "$WIN32" = yes; then
66       AC_DEFINE([WIN32], [1], [Define to 1 if building on WIN32.])
67       AH_BOTTOM([#ifdef WIN32
68 #include "include/windows/windefs.h"
69 #endif])
70    fi])
71
72 dnl Checks for Netlink support.
73 AC_DEFUN([OVS_CHECK_NETLINK],
74   [AC_CHECK_HEADER([linux/netlink.h],
75                    [HAVE_NETLINK=yes],
76                    [HAVE_NETLINK=no],
77                    [#include <sys/socket.h>
78    ])
79    AM_CONDITIONAL([HAVE_NETLINK], [test "$HAVE_NETLINK" = yes])
80    if test "$HAVE_NETLINK" = yes; then
81       AC_DEFINE([HAVE_NETLINK], [1],
82                 [Define to 1 if Netlink protocol is available.])
83    fi])
84
85 dnl Checks for OpenSSL.
86 AC_DEFUN([OVS_CHECK_OPENSSL],
87   [AC_ARG_ENABLE(
88      [ssl],
89      [AC_HELP_STRING([--disable-ssl], [Disable OpenSSL support])],
90      [case "${enableval}" in
91         (yes) ssl=true ;;
92         (no)  ssl=false ;;
93         (*) AC_MSG_ERROR([bad value ${enableval} for --enable-ssl]) ;;
94       esac],
95      [ssl=check])
96
97    if test "$ssl" != false; then
98        AX_CHECK_OPENSSL(
99          [HAVE_OPENSSL=yes],
100          [HAVE_OPENSSL=no
101           if test "$ssl" = check; then
102             AC_MSG_WARN([Cannot find openssl:
103
104 $SSL_PKG_ERRORS
105
106 OpenFlow connections over SSL will not be supported.
107 (You may use --disable-ssl to suppress this warning.)])
108           else
109             AC_MSG_ERROR([Cannot find openssl (use --disable-ssl to configure without SSL support)])
110           fi])
111    else
112        HAVE_OPENSSL=no
113    fi
114    AC_SUBST([HAVE_OPENSSL])
115    AM_CONDITIONAL([HAVE_OPENSSL], [test "$HAVE_OPENSSL" = yes])
116    if test "$HAVE_OPENSSL" = yes; then
117       AC_DEFINE([HAVE_OPENSSL], [1], [Define to 1 if OpenSSL is installed.])
118    fi])
119
120 dnl Checks for libraries needed by lib/socket-util.c.
121 AC_DEFUN([OVS_CHECK_SOCKET_LIBS],
122   [AC_CHECK_LIB([socket], [connect])
123    AC_SEARCH_LIBS([gethostbyname], [resolv])])
124
125 dnl Checks for the directory in which to store the PKI.
126 AC_DEFUN([OVS_CHECK_PKIDIR],
127   [AC_ARG_WITH(
128      [pkidir],
129      AC_HELP_STRING([--with-pkidir=DIR],
130                     [PKI hierarchy directory [[LOCALSTATEDIR/lib/openvswitch/pki]]]),
131      [PKIDIR=$withval],
132      [PKIDIR='${localstatedir}/lib/openvswitch/pki'])
133    AC_SUBST([PKIDIR])])
134
135 dnl Checks for the directory in which to store pidfiles.
136 AC_DEFUN([OVS_CHECK_RUNDIR],
137   [AC_ARG_WITH(
138      [rundir],
139      AC_HELP_STRING([--with-rundir=DIR],
140                     [directory used for pidfiles
141                     [[LOCALSTATEDIR/run/openvswitch]]]),
142      [RUNDIR=$withval],
143      [RUNDIR='${localstatedir}/run/openvswitch'])
144    AC_SUBST([RUNDIR])])
145
146 dnl Checks for the directory in which to store logs.
147 AC_DEFUN([OVS_CHECK_LOGDIR],
148   [AC_ARG_WITH(
149      [logdir],
150      AC_HELP_STRING([--with-logdir=DIR],
151                     [directory used for logs [[LOCALSTATEDIR/log/PACKAGE]]]),
152      [LOGDIR=$withval],
153      [LOGDIR='${localstatedir}/log/${PACKAGE}'])
154    AC_SUBST([LOGDIR])])
155
156 dnl Checks for the directory in which to store the Open vSwitch database.
157 AC_DEFUN([OVS_CHECK_DBDIR],
158   [AC_ARG_WITH(
159      [dbdir],
160      AC_HELP_STRING([--with-dbdir=DIR],
161                     [directory used for conf.db [[SYSCONFDIR/PACKAGE]]]),
162      [DBDIR=$withval],
163      [DBDIR='${sysconfdir}/${PACKAGE}'])
164    AC_SUBST([DBDIR])])
165
166 dnl Defines HAVE_BACKTRACE if backtrace() is found.
167 AC_DEFUN([OVS_CHECK_BACKTRACE],
168   [AC_SEARCH_LIBS([backtrace], [execinfo ubacktrace],
169                   [AC_DEFINE([HAVE_BACKTRACE], [1],
170                              [Define to 1 if you have backtrace(3).])])])
171
172 dnl Checks for __malloc_hook, etc., supported by glibc.
173 AC_DEFUN([OVS_CHECK_MALLOC_HOOKS],
174   [AC_CACHE_CHECK(
175     [whether libc supports hooks for malloc and related functions],
176     [ovs_cv_malloc_hooks],
177     [AC_COMPILE_IFELSE(
178       [AC_LANG_PROGRAM(
179          [#include <malloc.h>
180          ],
181          [(void) __malloc_hook;
182           (void) __realloc_hook;
183           (void) __free_hook;])],
184       [ovs_cv_malloc_hooks=yes],
185       [ovs_cv_malloc_hooks=no])])
186    if test $ovs_cv_malloc_hooks = yes; then
187      AC_DEFINE([HAVE_MALLOC_HOOKS], [1],
188                [Define to 1 if you have __malloc_hook, __realloc_hook, and
189                 __free_hook in <malloc.h>.])
190    fi])
191
192 dnl Checks for valgrind/valgrind.h.
193 AC_DEFUN([OVS_CHECK_VALGRIND],
194   [AC_CHECK_HEADERS([valgrind/valgrind.h])])
195
196 dnl Checks for Python 2.x, x >= 4.
197 AC_DEFUN([OVS_CHECK_PYTHON],
198   [AC_CACHE_CHECK(
199      [for Python 2.x for x >= 4],
200      [ovs_cv_python],
201      [if test -n "$PYTHON"; then
202         ovs_cv_python=$PYTHON
203       else
204         ovs_cv_python=no
205         for binary in python python2.4 python2.5; do
206           ovs_save_IFS=$IFS; IFS=$PATH_SEPARATOR
207           for dir in $PATH; do
208             IFS=$ovs_save_IFS
209             test -z "$dir" && dir=.
210             if test -x "$dir"/"$binary" && "$dir"/"$binary" -c 'import sys
211 if sys.hexversion >= 0x02040000 and sys.hexversion < 0x03000000:
212     sys.exit(0)
213 else:
214     sys.exit(1)'; then
215               ovs_cv_python=$dir/$binary
216               break 2
217             fi
218           done
219         done
220       fi])
221    AC_SUBST([HAVE_PYTHON])
222    AM_MISSING_PROG([PYTHON], [python])
223    if test $ovs_cv_python != no; then
224      PYTHON=$ovs_cv_python
225      HAVE_PYTHON=yes
226    else
227      HAVE_PYTHON=no
228    fi
229    AM_CONDITIONAL([HAVE_PYTHON], [test "$HAVE_PYTHON" = yes])])
230
231 dnl Checks for dot.
232 AC_DEFUN([OVS_CHECK_DOT],
233   [AC_CACHE_CHECK(
234     [for dot],
235     [ovs_cv_dot],
236     [dnl "dot" writes -V output to stderr:
237      if (dot -V) 2>&1 | grep '^dot - [[gG]]raphviz version' >/dev/null 2>&1; then
238        ovs_cv_dot=yes
239      else
240        ovs_cv_dot=no
241      fi])
242    AM_CONDITIONAL([HAVE_DOT], [test "$ovs_cv_dot" = yes])])
243
244 dnl Checks whether $PYTHON supports the module given as $1
245 AC_DEFUN([OVS_CHECK_PYTHON_MODULE],
246   [AC_REQUIRE([OVS_CHECK_PYTHON])
247    AC_CACHE_CHECK(
248      [for $1 Python module],
249      [ovs_cv_py_[]AS_TR_SH([$1])],
250      [ovs_cv_py_[]AS_TR_SH([$1])=no
251       if test $HAVE_PYTHON = yes; then
252         AS_ECHO(["running $PYTHON -c 'import $1
253 import sys
254 sys.exit(0)'..."]) >&AS_MESSAGE_LOG_FD 2>&1
255         if $PYTHON -c 'import $1
256 import sys
257 sys.exit(0)' >&AS_MESSAGE_LOG_FD 2>&1; then
258           ovs_cv_py_[]AS_TR_SH([$1])=yes
259         fi
260       fi])])
261
262 dnl Checks for missing python modules at build time
263 AC_DEFUN([OVS_CHECK_PYTHON_COMPAT],
264   [OVS_CHECK_PYTHON_MODULE([uuid])
265    if test $ovs_cv_py_uuid = yes; then
266      INCLUDE_PYTHON_COMPAT=no
267    else
268      INCLUDE_PYTHON_COMPAT=yes
269    fi
270    AC_MSG_CHECKING([whether to add python/compat to PYTHONPATH])
271    AC_MSG_RESULT([$INCLUDE_PYTHON_COMPAT])
272    AM_CONDITIONAL([INCLUDE_PYTHON_COMPAT], [test $INCLUDE_PYTHON_COMPAT = yes])])
273
274 dnl Checks for groff.
275 AC_DEFUN([OVS_CHECK_GROFF],
276   [AC_CACHE_CHECK(
277     [for groff],
278     [ovs_cv_groff],
279     [if (groff -v) >/dev/null 2>&1; then
280        ovs_cv_groff=yes
281      else
282        ovs_cv_groff=no
283      fi])
284    AM_CONDITIONAL([HAVE_GROFF], [test "$ovs_cv_groff" = yes])])
285
286 dnl Checks for thread-local storage support.
287 dnl
288 dnl Checks whether the compiler and linker support the C11
289 dnl thread_local macro from <threads.h>, and if so defines
290 dnl HAVE_THREAD_LOCAL.  If not, checks whether the compiler and linker
291 dnl support the GCC __thread extension, and if so defines
292 dnl HAVE___THREAD.
293 AC_DEFUN([OVS_CHECK_TLS],
294   [AC_CACHE_CHECK(
295      [whether $CC has <threads.h> that supports thread_local],
296      [ovs_cv_thread_local],
297      [AC_LINK_IFELSE(
298         [AC_LANG_PROGRAM([#include <threads.h>
299 static thread_local int var;], [return var;])],
300         [ovs_cv_thread_local=yes],
301         [ovs_cv_thread_local=no])])
302    if test $ovs_cv_thread_local = yes; then
303      AC_DEFINE([HAVE_THREAD_LOCAL], [1],
304                [Define to 1 if the C compiler and linker supports the C11
305                 thread_local matcro defined in <threads.h>.])
306    else
307      AC_CACHE_CHECK(
308        [whether $CC supports __thread],
309        [ovs_cv___thread],
310        [AC_LINK_IFELSE(
311           [AC_LANG_PROGRAM([static __thread int var;], [return var;])],
312           [ovs_cv___thread=yes],
313           [ovs_cv___thread=no])])
314      if test $ovs_cv___thread = yes; then
315        AC_DEFINE([HAVE___THREAD], [1],
316                  [Define to 1 if the C compiler and linker supports the
317                   GCC __thread extenions.])
318      fi
319    fi])
320
321 dnl OVS_CHECK_ATOMIC_LIBS
322 dnl
323 dnl Check to see if -latomic is need for GCC atomic built-ins.
324 AC_DEFUN([OVS_CHECK_ATOMIC_LIBS],
325    [AC_SEARCH_LIBS([__atomic_load_8], [atomic])])
326
327 dnl OVS_CHECK_GCC4_ATOMICS
328 dnl
329 dnl Checks whether the compiler and linker support GCC 4.0+ atomic built-ins.
330 dnl A compile-time only check is not enough because the compiler defers
331 dnl unimplemented built-ins to libgcc, which sometimes also lacks
332 dnl implementations.
333 AC_DEFUN([OVS_CHECK_GCC4_ATOMICS],
334   [AC_CACHE_CHECK(
335      [whether $CC supports GCC 4.0+ atomic built-ins],
336      [ovs_cv_gcc4_atomics],
337      [AC_LINK_IFELSE(
338         [AC_LANG_PROGRAM([[#include <stdlib.h>
339
340 #define ovs_assert(expr) if (!(expr)) abort();
341 #define TEST_ATOMIC_TYPE(TYPE)                  \
342     {                                           \
343         TYPE x = 1;                             \
344         TYPE orig;                              \
345                                                 \
346         __sync_synchronize();                   \
347         ovs_assert(x == 1);                     \
348                                                 \
349         __sync_synchronize();                   \
350         x = 3;                                  \
351         __sync_synchronize();                   \
352         ovs_assert(x == 3);                     \
353                                                 \
354         orig = __sync_fetch_and_add(&x, 1);     \
355         ovs_assert(orig == 3);                  \
356         __sync_synchronize();                   \
357         ovs_assert(x == 4);                     \
358                                                 \
359         orig = __sync_fetch_and_sub(&x, 2);     \
360         ovs_assert(orig == 4);                  \
361         __sync_synchronize();                   \
362         ovs_assert(x == 2);                     \
363                                                 \
364         orig = __sync_fetch_and_or(&x, 6);      \
365         ovs_assert(orig == 2);                  \
366         __sync_synchronize();                   \
367         ovs_assert(x == 6);                     \
368                                                 \
369         orig = __sync_fetch_and_and(&x, 10);    \
370         ovs_assert(orig == 6);                  \
371         __sync_synchronize();                   \
372         ovs_assert(x == 2);                     \
373                                                 \
374         orig = __sync_fetch_and_xor(&x, 10);    \
375         ovs_assert(orig == 2);                  \
376         __sync_synchronize();                   \
377         ovs_assert(x == 8);                     \
378     }]], [dnl
379 TEST_ATOMIC_TYPE(char);
380 TEST_ATOMIC_TYPE(unsigned char);
381 TEST_ATOMIC_TYPE(signed char);
382 TEST_ATOMIC_TYPE(short);
383 TEST_ATOMIC_TYPE(unsigned short);
384 TEST_ATOMIC_TYPE(int);
385 TEST_ATOMIC_TYPE(unsigned int);
386 TEST_ATOMIC_TYPE(long int);
387 TEST_ATOMIC_TYPE(unsigned long int);
388 TEST_ATOMIC_TYPE(long long int);
389 TEST_ATOMIC_TYPE(unsigned long long int);
390 ])],
391         [ovs_cv_gcc4_atomics=yes],
392         [ovs_cv_gcc4_atomics=no])])
393    if test $ovs_cv_gcc4_atomics = yes; then
394      AC_DEFINE([HAVE_GCC4_ATOMICS], [1],
395                [Define to 1 if the C compiler and linker supports the GCC 4.0+
396                 atomic built-ins.])
397    fi])
398
399 dnl OVS_CHECK_ATOMIC_ALWAYS_LOCK_FREE(SIZE)
400 dnl
401 dnl Checks __atomic_always_lock_free(SIZE, 0)
402 AC_DEFUN([OVS_CHECK_ATOMIC_ALWAYS_LOCK_FREE], 
403   [AC_CACHE_CHECK(
404     [value of __atomic_always_lock_free($1)],
405     [ovs_cv_atomic_always_lock_free_$1],
406     [AC_COMPUTE_INT(
407         [ovs_cv_atomic_always_lock_free_$1],
408         [__atomic_always_lock_free($1, 0)],
409         [],
410         [ovs_cv_atomic_always_lock_free_$1=unsupported])])
411    if test ovs_cv_atomic_always_lock_free_$1 != unsupported; then
412      AC_DEFINE_UNQUOTED(
413        [ATOMIC_ALWAYS_LOCK_FREE_$1B],
414        [$ovs_cv_atomic_always_lock_free_$1],
415        [If the C compiler is GCC 4.7 or later, define to the return value of
416         __atomic_always_lock_free($1, 0).  If the C compiler is not GCC or is
417         an older version of GCC, the value does not matter.])
418    fi])
419
420 dnl OVS_CHECK_POSIX_AIO
421 AC_DEFUN([OVS_CHECK_POSIX_AIO],
422   [AC_SEARCH_LIBS([aio_write], [rt])
423    AM_CONDITIONAL([HAVE_POSIX_AIO], [test "$ac_cv_search_aio_write" != no])])
424
425 dnl OVS_CHECK_INCLUDE_NEXT
426 AC_DEFUN([OVS_CHECK_INCLUDE_NEXT],
427   [AC_REQUIRE([gl_CHECK_NEXT_HEADERS])
428    gl_CHECK_NEXT_HEADERS([$1])])