← Back to branch summary

~darkmuggle-deactivatedaccount/ubuntu/quantal/grub2/fix-872244

« back to all changes in this revision

Viewing changes to m4/threadlib.m4

  • Committer: Bazaar Package Importer
  • Author(s): Colin Watson, Colin Watson, Evan Broder, Mario Limonciello
  • Date: 2010-11-24 13:59:55 UTC
  • mfrom: (1.17.6 upstream) (17.6.15 experimental)
  • Revision ID: james.westby@ubuntu.com-20101124135955-r6ii5sepayr7jt53
Tags: 1.99~20101124-1ubuntu1
https://launchpad.net/bugs/677758
[ Colin Watson ]
* Resynchronise with Debian experimental.  Remaining changes:
  - Adjust for default Ubuntu boot options ("quiet splash").
  - Default to hiding the menu; holding down Shift at boot will show it.
  - Set a monochromatic theme for Ubuntu.
  - Apply Ubuntu GRUB Legacy changes to legacy update-grub script: title,
    recovery mode, quiet option, tweak how memtest86+ is displayed, and
    use UUIDs where appropriate.
  - Fix backslash-escaping in merge_debconf_into_conf.
  - Remove "GNU/Linux" from default distributor string.
  - Add crashkernel= options if kdump and makedumpfile are available.
  - If other operating systems are installed, then automatically unhide
    the menu.  Otherwise, if GRUB_HIDDEN_TIMEOUT is 0, then use keystatus
    if available to check whether Shift is pressed.  If it is, show the
    menu, otherwise boot immediately.  If keystatus is not available, then
    fall back to a short delay interruptible with Escape.
  - Allow Shift to interrupt 'sleep --interruptible'.
  - Don't display introductory message about line editing unless we're
    actually offering a shell prompt.  Don't clear the screen just before
    booting if we never drew the menu in the first place.
  - Remove some verbose messages printed before reading the configuration
    file.
  - Suppress progress messages as the kernel and initrd load for
    non-recovery kernel menu entries.
  - Change prepare_grub_to_access_device to handle filesystems
    loop-mounted on file images.
  - Ignore devices loop-mounted from files in 10_linux.
  - Show the boot menu if the previous boot failed, that is if it failed
    to get to the end of one of the normal runlevels.
  - Don't generate /boot/grub/device.map during grub-install or
    grub-mkconfig by default.
  - Adjust upgrade version checks for Ubuntu.
  - Don't display "GRUB loading" unless Shift is held down.
  - Adjust versions of grub-doc and grub-legacy-doc conflicts to tolerate
    our backport of the grub-doc split.
  - Fix LVM/RAID probing in the absence of /boot/grub/device.map.
  - Look for .mo files in /usr/share/locale-langpack as well, in
    preference.
  - Make sure GRUB_TIMEOUT isn't quoted unnecessarily.
  - Probe all devices in 'grub-probe --target=drive' if
    /boot/grub/device.map is missing.
  - Build-depend on qemu-kvm rather than qemu-system for grub-pc tests.
  - Use qemu rather than qemu-system-i386.
  - Program vesafb on BIOS systems rather than efifb.
  - Add a grub-rescue-efi-amd64 package containing a rescue CD-ROM image
    for EFI-AMD64.
  - On Wubi, don't ask for an install device, but just update wubildr
    using the diverted grub-install.
  - When embedding the core image in a post-MBR gap, check for and avoid
    sectors matching any of a list of known signatures.
  - Disable video_bochs and video_cirrus on PC BIOS systems, as probing
    PCI space seems to break on some systems.
* Downgrade "ACPI shutdown failed" error to a debug message, since it can
  cause spurious test failures.

[ Evan Broder ]
* Enable lua from grub-extras.
* Incorporate the bitop library into lua.
* Add enum_pci function to grub module in lua.
* Switch back to gfxpayload=keep by default, unless the video hardware
  is known to not support it.

[ Mario Limonciello ]
* Built part_msdos and vfat into bootx64.efi (LP: #677758)

Show diffs side-by-side

added added

removed removed

Lines of Context:
m4/threadlib.m4
 
1
# threadlib.m4 serial 6 (gettext-0.18.2)
 
2
dnl Copyright (C) 2005-2010 Free Software Foundation, Inc.
 
3
dnl This file is free software; the Free Software Foundation
 
4
dnl gives unlimited permission to copy and/or distribute it,
 
5
dnl with or without modifications, as long as this notice is preserved.
 
6
 
 
7
dnl From Bruno Haible.
 
8
 
 
9
dnl gl_THREADLIB
 
10
dnl ------------
 
11
dnl Tests for a multithreading library to be used.
 
12
dnl Defines at most one of the macros USE_POSIX_THREADS, USE_SOLARIS_THREADS,
 
13
dnl USE_PTH_THREADS, USE_WIN32_THREADS
 
14
dnl Sets the variables LIBTHREAD and LTLIBTHREAD to the linker options for use
 
15
dnl in a Makefile (LIBTHREAD for use without libtool, LTLIBTHREAD for use with
 
16
dnl libtool).
 
17
dnl Sets the variables LIBMULTITHREAD and LTLIBMULTITHREAD similarly, for
 
18
dnl programs that really need multithread functionality. The difference
 
19
dnl between LIBTHREAD and LIBMULTITHREAD is that on platforms supporting weak
 
20
dnl symbols, typically LIBTHREAD="" whereas LIBMULTITHREAD="-lpthread".
 
21
dnl Adds to CPPFLAGS the flag -D_REENTRANT or -D_THREAD_SAFE if needed for
 
22
dnl multithread-safe programs.
 
23
 
 
24
AC_DEFUN([gl_THREADLIB_EARLY],
 
25
[
 
26
  AC_REQUIRE([gl_THREADLIB_EARLY_BODY])
 
27
])
 
28
 
 
29
dnl The guts of gl_THREADLIB_EARLY. Needs to be expanded only once.
 
30
 
 
31
AC_DEFUN([gl_THREADLIB_EARLY_BODY],
 
32
[
 
33
  dnl Ordering constraints: This macro modifies CPPFLAGS in a way that
 
34
  dnl influences the result of the autoconf tests that test for *_unlocked
 
35
  dnl declarations, on AIX 5 at least. Therefore it must come early.
 
36
  AC_BEFORE([$0], [gl_FUNC_GLIBC_UNLOCKED_IO])dnl
 
37
  AC_BEFORE([$0], [gl_ARGP])dnl
 
38
 
 
39
  AC_REQUIRE([AC_CANONICAL_HOST])
 
40
  dnl _GNU_SOURCE is needed for pthread_rwlock_t on glibc systems.
 
41
  dnl AC_USE_SYSTEM_EXTENSIONS was introduced in autoconf 2.60 and obsoletes
 
42
  dnl AC_GNU_SOURCE.
 
43
  m4_ifdef([AC_USE_SYSTEM_EXTENSIONS],
 
44
    [AC_REQUIRE([AC_USE_SYSTEM_EXTENSIONS])],
 
45
    [AC_REQUIRE([AC_GNU_SOURCE])])
 
46
  dnl Check for multithreading.
 
47
  m4_divert_text([DEFAULTS], [gl_use_threads_default=])
 
48
  AC_ARG_ENABLE([threads],
 
49
AC_HELP_STRING([--enable-threads={posix|solaris|pth|win32}], [specify multithreading API])
 
50
AC_HELP_STRING([--disable-threads], [build without multithread safety]),
 
51
    [gl_use_threads=$enableval],
 
52
    [if test -n "$gl_use_threads_default"; then
 
53
       gl_use_threads="$gl_use_threads_default"
 
54
     else
 
55
changequote(,)dnl
 
56
       case "$host_os" in
 
57
         dnl Disable multithreading by default on OSF/1, because it interferes
 
58
         dnl with fork()/exec(): When msgexec is linked with -lpthread, its
 
59
         dnl child process gets an endless segmentation fault inside execvp().
 
60
         dnl Disable multithreading by default on Cygwin 1.5.x, because it has
 
61
         dnl bugs that lead to endless loops or crashes. See
 
62
         dnl <http://cygwin.com/ml/cygwin/2009-08/msg00283.html>.
 
63
         osf*) gl_use_threads=no ;;
 
64
         cygwin*)
 
65
               case `uname -r` in
 
66
                 1.[0-5].*) gl_use_threads=no ;;
 
67
                 *)         gl_use_threads=yes ;;
 
68
               esac
 
69
               ;;
 
70
         *)    gl_use_threads=yes ;;
 
71
       esac
 
72
changequote([,])dnl
 
73
     fi
 
74
    ])
 
75
  if test "$gl_use_threads" = yes || test "$gl_use_threads" = posix; then
 
76
    # For using <pthread.h>:
 
77
    case "$host_os" in
 
78
      osf*)
 
79
        # On OSF/1, the compiler needs the flag -D_REENTRANT so that it
 
80
        # groks <pthread.h>. cc also understands the flag -pthread, but
 
81
        # we don't use it because 1. gcc-2.95 doesn't understand -pthread,
 
82
        # 2. putting a flag into CPPFLAGS that has an effect on the linker
 
83
        # causes the AC_LINK_IFELSE test below to succeed unexpectedly,
 
84
        # leading to wrong values of LIBTHREAD and LTLIBTHREAD.
 
85
        CPPFLAGS="$CPPFLAGS -D_REENTRANT"
 
86
        ;;
 
87
    esac
 
88
    # Some systems optimize for single-threaded programs by default, and
 
89
    # need special flags to disable these optimizations. For example, the
 
90
    # definition of 'errno' in <errno.h>.
 
91
    case "$host_os" in
 
92
      aix* | freebsd*) CPPFLAGS="$CPPFLAGS -D_THREAD_SAFE" ;;
 
93
      solaris*) CPPFLAGS="$CPPFLAGS -D_REENTRANT" ;;
 
94
    esac
 
95
  fi
 
96
])
 
97
 
 
98
dnl The guts of gl_THREADLIB. Needs to be expanded only once.
 
99
 
 
100
AC_DEFUN([gl_THREADLIB_BODY],
 
101
[
 
102
  AC_REQUIRE([gl_THREADLIB_EARLY_BODY])
 
103
  gl_threads_api=none
 
104
  LIBTHREAD=
 
105
  LTLIBTHREAD=
 
106
  LIBMULTITHREAD=
 
107
  LTLIBMULTITHREAD=
 
108
  if test "$gl_use_threads" != no; then
 
109
    dnl Check whether the compiler and linker support weak declarations.
 
110
    AC_CACHE_CHECK([whether imported symbols can be declared weak],
 
111
      [gl_cv_have_weak],
 
112
      [gl_cv_have_weak=no
 
113
       dnl First, test whether the compiler accepts it syntactically.
 
114
       AC_LINK_IFELSE(
 
115
         [AC_LANG_PROGRAM(
 
116
            [[extern void xyzzy ();
 
117
#pragma weak xyzzy]],
 
118
            [[xyzzy();]])],
 
119
         [gl_cv_have_weak=maybe])
 
120
       if test $gl_cv_have_weak = maybe; then
 
121
         dnl Second, test whether it actually works. On Cygwin 1.7.2, with
 
122
         dnl gcc 4.3, symbols declared weak always evaluate to the address 0.
 
123
         AC_RUN_IFELSE(
 
124
           [AC_LANG_SOURCE([[
 
125
#include <stdio.h>
 
126
#pragma weak fputs
 
127
int main ()
 
128
{
 
129
  return (fputs == NULL);
 
130
}]])],
 
131
           [gl_cv_have_weak=yes],
 
132
           [gl_cv_have_weak=no],
 
133
           [dnl When cross-compiling, assume that only ELF platforms support
 
134
            dnl weak symbols.
 
135
            AC_EGREP_CPP([Extensible Linking Format],
 
136
              [#ifdef __ELF__
 
137
               Extensible Linking Format
 
138
               #endif
 
139
              ],
 
140
              [gl_cv_have_weak="guessing yes"],
 
141
              [gl_cv_have_weak="guessing no"])
 
142
           ])
 
143
       fi
 
144
      ])
 
145
    if test "$gl_use_threads" = yes || test "$gl_use_threads" = posix; then
 
146
      # On OSF/1, the compiler needs the flag -pthread or -D_REENTRANT so that
 
147
      # it groks <pthread.h>. It's added above, in gl_THREADLIB_EARLY_BODY.
 
148
      AC_CHECK_HEADER([pthread.h],
 
149
        [gl_have_pthread_h=yes], [gl_have_pthread_h=no])
 
150
      if test "$gl_have_pthread_h" = yes; then
 
151
        # Other possible tests:
 
152
        #   -lpthreads (FSU threads, PCthreads)
 
153
        #   -lgthreads
 
154
        gl_have_pthread=
 
155
        # Test whether both pthread_mutex_lock and pthread_mutexattr_init exist
 
156
        # in libc. IRIX 6.5 has the first one in both libc and libpthread, but
 
157
        # the second one only in libpthread, and lock.c needs it.
 
158
        AC_LINK_IFELSE(
 
159
          [AC_LANG_PROGRAM(
 
160
             [[#include <pthread.h>]],
 
161
             [[pthread_mutex_lock((pthread_mutex_t*)0);
 
162
               pthread_mutexattr_init((pthread_mutexattr_t*)0);]])],
 
163
          [gl_have_pthread=yes])
 
164
        # Test for libpthread by looking for pthread_kill. (Not pthread_self,
 
165
        # since it is defined as a macro on OSF/1.)
 
166
        if test -n "$gl_have_pthread"; then
 
167
          # The program links fine without libpthread. But it may actually
 
168
          # need to link with libpthread in order to create multiple threads.
 
169
          AC_CHECK_LIB([pthread], [pthread_kill],
 
170
            [LIBMULTITHREAD=-lpthread LTLIBMULTITHREAD=-lpthread
 
171
             # On Solaris and HP-UX, most pthread functions exist also in libc.
 
172
             # Therefore pthread_in_use() needs to actually try to create a
 
173
             # thread: pthread_create from libc will fail, whereas
 
174
             # pthread_create will actually create a thread.
 
175
             case "$host_os" in
 
176
               solaris* | hpux*)
 
177
                 AC_DEFINE([PTHREAD_IN_USE_DETECTION_HARD], [1],
 
178
                   [Define if the pthread_in_use() detection is hard.])
 
179
             esac
 
180
            ])
 
181
        else
 
182
          # Some library is needed. Try libpthread and libc_r.
 
183
          AC_CHECK_LIB([pthread], [pthread_kill],
 
184
            [gl_have_pthread=yes
 
185
             LIBTHREAD=-lpthread LTLIBTHREAD=-lpthread
 
186
             LIBMULTITHREAD=-lpthread LTLIBMULTITHREAD=-lpthread])
 
187
          if test -z "$gl_have_pthread"; then
 
188
            # For FreeBSD 4.
 
189
            AC_CHECK_LIB([c_r], [pthread_kill],
 
190
              [gl_have_pthread=yes
 
191
               LIBTHREAD=-lc_r LTLIBTHREAD=-lc_r
 
192
               LIBMULTITHREAD=-lc_r LTLIBMULTITHREAD=-lc_r])
 
193
          fi
 
194
        fi
 
195
        if test -n "$gl_have_pthread"; then
 
196
          gl_threads_api=posix
 
197
          AC_DEFINE([USE_POSIX_THREADS], [1],
 
198
            [Define if the POSIX multithreading library can be used.])
 
199
          if test -n "$LIBMULTITHREAD" || test -n "$LTLIBMULTITHREAD"; then
 
200
            if case "$gl_cv_have_weak" in *yes) true;; *) false;; esac; then
 
201
              AC_DEFINE([USE_POSIX_THREADS_WEAK], [1],
 
202
                [Define if references to the POSIX multithreading library should be made weak.])
 
203
              LIBTHREAD=
 
204
              LTLIBTHREAD=
 
205
            fi
 
206
          fi
 
207
        fi
 
208
      fi
 
209
    fi
 
210
    if test -z "$gl_have_pthread"; then
 
211
      if test "$gl_use_threads" = yes || test "$gl_use_threads" = solaris; then
 
212
        gl_have_solaristhread=
 
213
        gl_save_LIBS="$LIBS"
 
214
        LIBS="$LIBS -lthread"
 
215
        AC_LINK_IFELSE(
 
216
          [AC_LANG_PROGRAM(
 
217
             [[
 
218
#include <thread.h>
 
219
#include <synch.h>
 
220
             ]],
 
221
             [[thr_self();]])],
 
222
          [gl_have_solaristhread=yes])
 
223
        LIBS="$gl_save_LIBS"
 
224
        if test -n "$gl_have_solaristhread"; then
 
225
          gl_threads_api=solaris
 
226
          LIBTHREAD=-lthread
 
227
          LTLIBTHREAD=-lthread
 
228
          LIBMULTITHREAD="$LIBTHREAD"
 
229
          LTLIBMULTITHREAD="$LTLIBTHREAD"
 
230
          AC_DEFINE([USE_SOLARIS_THREADS], [1],
 
231
            [Define if the old Solaris multithreading library can be used.])
 
232
          if case "$gl_cv_have_weak" in *yes) true;; *) false;; esac; then
 
233
            AC_DEFINE([USE_SOLARIS_THREADS_WEAK], [1],
 
234
              [Define if references to the old Solaris multithreading library should be made weak.])
 
235
            LIBTHREAD=
 
236
            LTLIBTHREAD=
 
237
          fi
 
238
        fi
 
239
      fi
 
240
    fi
 
241
    if test "$gl_use_threads" = pth; then
 
242
      gl_save_CPPFLAGS="$CPPFLAGS"
 
243
      AC_LIB_LINKFLAGS([pth])
 
244
      gl_have_pth=
 
245
      gl_save_LIBS="$LIBS"
 
246
      LIBS="$LIBS -lpth"
 
247
      AC_LINK_IFELSE(
 
248
        [AC_LANG_PROGRAM([[#include <pth.h>]], [[pth_self();]])],
 
249
        [gl_have_pth=yes])
 
250
      LIBS="$gl_save_LIBS"
 
251
      if test -n "$gl_have_pth"; then
 
252
        gl_threads_api=pth
 
253
        LIBTHREAD="$LIBPTH"
 
254
        LTLIBTHREAD="$LTLIBPTH"
 
255
        LIBMULTITHREAD="$LIBTHREAD"
 
256
        LTLIBMULTITHREAD="$LTLIBTHREAD"
 
257
        AC_DEFINE([USE_PTH_THREADS], [1],
 
258
          [Define if the GNU Pth multithreading library can be used.])
 
259
        if test -n "$LIBMULTITHREAD" || test -n "$LTLIBMULTITHREAD"; then
 
260
          if case "$gl_cv_have_weak" in *yes) true;; *) false;; esac; then
 
261
            AC_DEFINE([USE_PTH_THREADS_WEAK], [1],
 
262
              [Define if references to the GNU Pth multithreading library should be made weak.])
 
263
            LIBTHREAD=
 
264
            LTLIBTHREAD=
 
265
          fi
 
266
        fi
 
267
      else
 
268
        CPPFLAGS="$gl_save_CPPFLAGS"
 
269
      fi
 
270
    fi
 
271
    if test -z "$gl_have_pthread"; then
 
272
      if test "$gl_use_threads" = yes || test "$gl_use_threads" = win32; then
 
273
        if { case "$host_os" in
 
274
               mingw*) true;;
 
275
               *) false;;
 
276
             esac
 
277
           }; then
 
278
          gl_threads_api=win32
 
279
          AC_DEFINE([USE_WIN32_THREADS], [1],
 
280
            [Define if the Win32 multithreading API can be used.])
 
281
        fi
 
282
      fi
 
283
    fi
 
284
  fi
 
285
  AC_MSG_CHECKING([for multithread API to use])
 
286
  AC_MSG_RESULT([$gl_threads_api])
 
287
  AC_SUBST([LIBTHREAD])
 
288
  AC_SUBST([LTLIBTHREAD])
 
289
  AC_SUBST([LIBMULTITHREAD])
 
290
  AC_SUBST([LTLIBMULTITHREAD])
 
291
])
 
292
 
 
293
AC_DEFUN([gl_THREADLIB],
 
294
[
 
295
  AC_REQUIRE([gl_THREADLIB_EARLY])
 
296
  AC_REQUIRE([gl_THREADLIB_BODY])
 
297
])
 
298
 
 
299
 
 
300
dnl gl_DISABLE_THREADS
 
301
dnl ------------------
 
302
dnl Sets the gl_THREADLIB default so that threads are not used by default.
 
303
dnl The user can still override it at installation time, by using the
 
304
dnl configure option '--enable-threads'.
 
305
 
 
306
AC_DEFUN([gl_DISABLE_THREADS], [
 
307
  m4_divert_text([INIT_PREPARE], [gl_use_threads_default=no])
 
308
])
 
309
 
 
310
 
 
311
dnl Survey of platforms:
 
312
dnl
 
313
dnl Platform          Available   Compiler    Supports   test-lock
 
314
dnl                   flavours    option      weak       result
 
315
dnl ---------------   ---------   ---------   --------   ---------
 
316
dnl Linux 2.4/glibc   posix       -lpthread       Y      OK
 
317
dnl
 
318
dnl GNU Hurd/glibc    posix
 
319
dnl
 
320
dnl FreeBSD 5.3       posix       -lc_r           Y
 
321
dnl                   posix       -lkse ?         Y
 
322
dnl                   posix       -lpthread ?     Y
 
323
dnl                   posix       -lthr           Y
 
324
dnl
 
325
dnl FreeBSD 5.2       posix       -lc_r           Y
 
326
dnl                   posix       -lkse           Y
 
327
dnl                   posix       -lthr           Y
 
328
dnl
 
329
dnl FreeBSD 4.0,4.10  posix       -lc_r           Y      OK
 
330
dnl
 
331
dnl NetBSD 1.6        --
 
332
dnl
 
333
dnl OpenBSD 3.4       posix       -lpthread       Y      OK
 
334
dnl
 
335
dnl MacOS X 10.[123]  posix       -lpthread       Y      OK
 
336
dnl
 
337
dnl Solaris 7,8,9     posix       -lpthread       Y      Sol 7,8: 0.0; Sol 9: OK
 
338
dnl                   solaris     -lthread        Y      Sol 7,8: 0.0; Sol 9: OK
 
339
dnl
 
340
dnl HP-UX 11          posix       -lpthread       N (cc) OK
 
341
dnl                                               Y (gcc)
 
342
dnl
 
343
dnl IRIX 6.5          posix       -lpthread       Y      0.5
 
344
dnl
 
345
dnl AIX 4.3,5.1       posix       -lpthread       N      AIX 4: 0.5; AIX 5: OK
 
346
dnl
 
347
dnl OSF/1 4.0,5.1     posix       -pthread (cc)   N      OK
 
348
dnl                               -lpthread (gcc) Y
 
349
dnl
 
350
dnl Cygwin            posix       -lpthread       Y      OK
 
351
dnl
 
352
dnl Any of the above  pth         -lpth                  0.0
 
353
dnl
 
354
dnl Mingw             win32                       N      OK
 
355
dnl
 
356
dnl BeOS 5            --
 
357
dnl
 
358
dnl The test-lock result shows what happens if in test-lock.c EXPLICIT_YIELD is
 
359
dnl turned off:
 
360
dnl   OK if all three tests terminate OK,
 
361
dnl   0.5 if the first test terminates OK but the second one loops endlessly,
 
362
dnl   0.0 if the first test already loops endlessly.