2007-03-17 14:50:42 +01:00
|
|
|
package Mkvcbuild;
|
2007-03-23 10:53:33 +01:00
|
|
|
|
2007-03-17 15:01:01 +01:00
|
|
|
#
|
|
|
|
# Package that generates build files for msvc build
|
|
|
|
#
|
2010-09-20 22:08:53 +02:00
|
|
|
# src/tools/msvc/Mkvcbuild.pm
|
2007-03-17 15:01:01 +01:00
|
|
|
#
|
2007-03-17 14:50:42 +01:00
|
|
|
use Carp;
|
|
|
|
use Win32;
|
|
|
|
use strict;
|
|
|
|
use warnings;
|
|
|
|
use Project;
|
|
|
|
use Solution;
|
2010-01-09 15:45:47 +01:00
|
|
|
use Cwd;
|
|
|
|
use File::Copy;
|
2011-11-26 21:22:32 +01:00
|
|
|
use Config;
|
2012-01-03 14:44:26 +01:00
|
|
|
use VSObjectFactory;
|
2011-11-26 21:22:32 +01:00
|
|
|
use List::Util qw(first);
|
2007-03-17 14:50:42 +01:00
|
|
|
|
|
|
|
use Exporter;
|
|
|
|
our (@ISA, @EXPORT_OK);
|
2012-07-05 03:47:49 +02:00
|
|
|
@ISA = qw(Exporter);
|
2007-03-17 14:50:42 +01:00
|
|
|
@EXPORT_OK = qw(Mkvcbuild);
|
|
|
|
|
|
|
|
my $solution;
|
|
|
|
my $libpgport;
|
Create libpgcommon, and move pg_malloc et al to it
libpgcommon is a new static library to allow sharing code among the
various frontend programs and backend; this lets us eliminate duplicate
implementations of common routines. We avoid libpgport, because that's
intended as a place for porting issues; per discussion, it seems better
to keep them separate.
The first use case, and the only implemented by this patch, is pg_malloc
and friends, which many frontend programs were already using.
At the same time, we can use this to provide palloc emulation functions
for the frontend; this way, some palloc-using files in the backend can
also be used by the frontend cleanly. To do this, we change palloc() in
the backend to be a function instead of a macro on top of
MemoryContextAlloc(). This was previously believed to cause loss of
performance, but this implementation has been tweaked by Tom and Andres
so that on modern compilers it provides a slight improvement over the
previous one.
This lets us clean up some places that were already with
localized hacks.
Most of the pg_malloc/palloc changes in this patch were authored by
Andres Freund. Zoltán Böszörményi also independently provided a form of
that. libpgcommon infrastructure was authored by Álvaro.
2013-02-12 14:33:40 +01:00
|
|
|
my $libpgcommon;
|
2016-03-24 20:55:44 +01:00
|
|
|
my $libpgfeutils;
|
2007-03-17 14:50:42 +01:00
|
|
|
my $postgres;
|
|
|
|
my $libpq;
|
2017-12-09 03:06:05 +01:00
|
|
|
my @unlink_on_exit;
|
2007-03-17 14:50:42 +01:00
|
|
|
|
2015-04-16 20:17:26 +02:00
|
|
|
# Set of variables for modules in contrib/ and src/test/modules/
|
2012-07-05 03:47:49 +02:00
|
|
|
my $contrib_defines = { 'refint' => 'REFINT_VERBOSE' };
|
2015-05-24 03:35:49 +02:00
|
|
|
my @contrib_uselibpq = ('dblink', 'oid2name', 'postgres_fdw', 'vacuumlo');
|
|
|
|
my @contrib_uselibpgport = ('oid2name', 'pg_standby', 'vacuumlo');
|
|
|
|
my @contrib_uselibpgcommon = ('oid2name', 'pg_standby', 'vacuumlo');
|
|
|
|
my $contrib_extralibs = undef;
|
2017-05-18 01:01:23 +02:00
|
|
|
my $contrib_extraincludes = { 'dblink' => ['src/backend'] };
|
2007-03-17 14:50:42 +01:00
|
|
|
my $contrib_extrasource = {
|
2015-04-25 14:52:03 +02:00
|
|
|
'cube' => [ 'contrib/cube/cubescan.l', 'contrib/cube/cubeparse.y' ],
|
2018-05-09 16:14:46 +02:00
|
|
|
'seg' => [ 'contrib/seg/segscan.l', 'contrib/seg/segparse.y' ],
|
|
|
|
};
|
2015-04-28 17:47:08 +02:00
|
|
|
my @contrib_excludes = (
|
2019-07-01 18:37:52 +02:00
|
|
|
'commit_ts', 'hstore_plperl',
|
|
|
|
'hstore_plpython', 'intagg',
|
|
|
|
'jsonb_plperl', 'jsonb_plpython',
|
|
|
|
'ltree_plpython', 'pgcrypto',
|
|
|
|
'sepgsql', 'brin',
|
2019-09-08 01:03:11 +02:00
|
|
|
'test_extensions', 'test_misc',
|
|
|
|
'test_pg_dump', 'snapshot_too_old',
|
|
|
|
'unsafe_tests');
|
2007-03-17 14:50:42 +01:00
|
|
|
|
2015-03-11 14:21:01 +01:00
|
|
|
# Set of variables for frontend modules
|
|
|
|
my $frontend_defines = { 'initdb' => 'FRONTEND' };
|
2017-06-29 00:00:16 +02:00
|
|
|
my @frontend_uselibpq = ('pg_ctl', 'pg_upgrade', 'pgbench', 'psql', 'initdb');
|
2015-05-24 03:35:49 +02:00
|
|
|
my @frontend_uselibpgport = (
|
|
|
|
'pg_archivecleanup', 'pg_test_fsync',
|
|
|
|
'pg_test_timing', 'pg_upgrade',
|
2017-05-18 01:01:23 +02:00
|
|
|
'pg_waldump', 'pgbench');
|
2015-05-24 03:35:49 +02:00
|
|
|
my @frontend_uselibpgcommon = (
|
|
|
|
'pg_archivecleanup', 'pg_test_fsync',
|
|
|
|
'pg_test_timing', 'pg_upgrade',
|
2017-05-18 01:01:23 +02:00
|
|
|
'pg_waldump', 'pgbench');
|
2015-03-11 14:21:01 +01:00
|
|
|
my $frontend_extralibs = {
|
|
|
|
'initdb' => ['ws2_32.lib'],
|
|
|
|
'pg_restore' => ['ws2_32.lib'],
|
2015-03-11 03:33:24 +01:00
|
|
|
'pgbench' => ['ws2_32.lib'],
|
2018-05-09 16:14:46 +02:00
|
|
|
'psql' => ['ws2_32.lib']
|
|
|
|
};
|
2015-03-11 14:21:01 +01:00
|
|
|
my $frontend_extraincludes = {
|
2015-04-25 14:52:03 +02:00
|
|
|
'initdb' => ['src/timezone'],
|
2018-05-09 16:14:46 +02:00
|
|
|
'psql' => ['src/backend']
|
|
|
|
};
|
2015-03-11 03:33:24 +01:00
|
|
|
my $frontend_extrasource = {
|
2016-06-12 10:19:56 +02:00
|
|
|
'psql' => ['src/bin/psql/psqlscanslash.l'],
|
2015-03-11 03:33:24 +01:00
|
|
|
'pgbench' =>
|
2018-05-09 16:14:46 +02:00
|
|
|
[ 'src/bin/pgbench/exprscan.l', 'src/bin/pgbench/exprparse.y' ]
|
|
|
|
};
|
2015-05-24 03:35:49 +02:00
|
|
|
my @frontend_excludes = (
|
2017-05-18 01:01:23 +02:00
|
|
|
'pgevent', 'pg_basebackup', 'pg_rewind', 'pg_dump',
|
2017-02-09 22:23:46 +01:00
|
|
|
'pg_waldump', 'scripts');
|
2015-03-11 14:21:01 +01:00
|
|
|
|
2007-03-17 14:50:42 +01:00
|
|
|
sub mkvcbuild
|
|
|
|
{
|
2012-06-10 21:20:04 +02:00
|
|
|
our $config = shift;
|
|
|
|
|
2015-04-25 14:52:03 +02:00
|
|
|
chdir('../../..') if (-d '../msvc' && -d '../../../src');
|
2012-07-05 03:47:49 +02:00
|
|
|
die 'Must run from root or msvc directory'
|
2015-04-25 14:52:03 +02:00
|
|
|
unless (-d 'src/tools/msvc' && -d 'src');
|
2012-06-10 21:20:04 +02:00
|
|
|
|
|
|
|
my $vsVersion = DetermineVisualStudioVersion();
|
|
|
|
|
|
|
|
$solution = CreateSolution($vsVersion, $config);
|
|
|
|
|
|
|
|
our @pgportfiles = qw(
|
2019-10-30 12:58:32 +01:00
|
|
|
chklocale.c explicit_bzero.c fls.c fseeko.c getpeereid.c getrusage.c inet_aton.c random.c
|
2012-06-10 21:20:04 +02:00
|
|
|
srandom.c getaddrinfo.c gettimeofday.c inet_net_ntop.c kill.c open.c
|
2013-10-18 03:52:54 +02:00
|
|
|
erand48.c snprintf.c strlcat.c strlcpy.c dirmod.c noblock.c path.c
|
Convert elog.c's useful_strerror() into a globally-used strerror wrapper.
elog.c has long had a private strerror wrapper that handles assorted
possible failures or deficiencies of the platform's strerror. On Windows,
it also knows how to translate Winsock error codes, which the native
strerror does not. Move all this code into src/port/strerror.c and
define strerror() as a macro that invokes it, so that both our frontend
and backend code will have all of this behavior.
I believe this constitutes an actual bug fix on Windows, since AFAICS
our frontend code did not report Winsock error codes properly before this.
However, the main point is to lay the groundwork for implementing %m
in src/port/snprintf.c: the behavior we want %m to have is this one,
not the native strerror's.
Note that this throws away the prior use of src/port/strerror.c,
which was to implement strerror() on platforms lacking it. That's
been dead code for nigh twenty years now, since strerror() was
already required by C89.
We should likewise cause strerror_r to use this behavior, but
I'll tackle that separately.
Patch by me, reviewed by Michael Paquier
Discussion: https://postgr.es/m/2975.1526862605@sss.pgh.pa.us
2018-09-26 17:06:42 +02:00
|
|
|
dirent.c dlopen.c getopt.c getopt_long.c
|
Make use of compiler builtins and/or assembly for CLZ, CTZ, POPCNT.
Test for the compiler builtins __builtin_clz, __builtin_ctz, and
__builtin_popcount, and make use of these in preference to
handwritten C code if they're available. Create src/port
infrastructure for "leftmost one", "rightmost one", and "popcount"
so as to centralize these decisions.
On x86_64, __builtin_popcount generally won't make use of the POPCNT
opcode because that's not universally supported yet. Provide code
that checks CPUID and then calls POPCNT via asm() if available.
This requires indirecting through a function pointer, which is
an annoying amount of overhead for a one-instruction operation,
but it's probably not worth working harder than this for our
current use-cases.
I'm not sure we've found all the existing places that could profit
from this new infrastructure; but we at least touched all the
ones that used copied-and-pasted versions of the bitmapset.c code,
and got rid of multiple copies of the associated constant arrays.
While at it, replace c-compiler.m4's one-per-builtin-function
macros with a single one that can handle all the cases we need
to worry about so far. Also, because I'm paranoid, make those
checks into AC_LINK checks rather than just AC_COMPILE; the
former coding failed to verify that libgcc has support for the
builtin, in cases where it's not inline code.
David Rowley, Thomas Munro, Alvaro Herrera, Tom Lane
Discussion: https://postgr.es/m/CAKJS1f9WTAGG1tPeJnD18hiQW5gAk59fQ6WK-vfdAKEHyRg2RA@mail.gmail.com
2019-02-16 05:22:27 +01:00
|
|
|
pread.c pwrite.c pg_bitutils.c
|
Replace PostmasterRandom() with a stronger source, second attempt.
This adds a new routine, pg_strong_random() for generating random bytes,
for use in both frontend and backend. At the moment, it's only used in
the backend, but the upcoming SCRAM authentication patches need strong
random numbers in libpq as well.
pg_strong_random() is based on, and replaces, the existing implementation
in pgcrypto. It can acquire strong random numbers from a number of sources,
depending on what's available:
- OpenSSL RAND_bytes(), if built with OpenSSL
- On Windows, the native cryptographic functions are used
- /dev/urandom
Unlike the current pgcrypto function, the source is chosen by configure.
That makes it easier to test different implementations, and ensures that
we don't accidentally fall back to a less secure implementation, if the
primary source fails. All of those methods are quite reliable, it would be
pretty surprising for them to fail, so we'd rather find out by failing
hard.
If no strong random source is available, we fall back to using erand48(),
seeded from current timestamp, like PostmasterRandom() was. That isn't
cryptographically secure, but allows us to still work on platforms that
don't have any of the above stronger sources. Because it's not very secure,
the built-in implementation is only used if explicitly requested with
--disable-strong-random.
This replaces the more complicated Fortuna algorithm we used to have in
pgcrypto, which is unfortunate, but all modern platforms have /dev/urandom,
so it doesn't seem worth the maintenance effort to keep that. pgcrypto
functions that require strong random numbers will be disabled with
--disable-strong-random.
Original patch by Magnus Hagander, tons of further work by Michael Paquier
and me.
Discussion: https://www.postgresql.org/message-id/CAB7nPqRy3krN8quR9XujMVVHYtXJ0_60nqgVc6oUk8ygyVkZsA@mail.gmail.com
Discussion: https://www.postgresql.org/message-id/CAB7nPqRWkNYRRPJA7-cF+LfroYV10pvjdz6GNvxk-Eee9FypKA@mail.gmail.com
2016-12-05 12:42:59 +01:00
|
|
|
pg_strong_random.c pgcheckdir.c pgmkdirp.c pgsleep.c pgstrcasecmp.c
|
|
|
|
pqsignal.c mkdtemp.c qsort.c qsort_arg.c quotes.c system.c
|
Convert elog.c's useful_strerror() into a globally-used strerror wrapper.
elog.c has long had a private strerror wrapper that handles assorted
possible failures or deficiencies of the platform's strerror. On Windows,
it also knows how to translate Winsock error codes, which the native
strerror does not. Move all this code into src/port/strerror.c and
define strerror() as a macro that invokes it, so that both our frontend
and backend code will have all of this behavior.
I believe this constitutes an actual bug fix on Windows, since AFAICS
our frontend code did not report Winsock error codes properly before this.
However, the main point is to lay the groundwork for implementing %m
in src/port/snprintf.c: the behavior we want %m to have is this one,
not the native strerror's.
Note that this throws away the prior use of src/port/strerror.c,
which was to implement strerror() on platforms lacking it. That's
been dead code for nigh twenty years now, since strerror() was
already required by C89.
We should likewise cause strerror_r to use this behavior, but
I'll tackle that separately.
Patch by me, reviewed by Michael Paquier
Discussion: https://postgr.es/m/2975.1526862605@sss.pgh.pa.us
2018-09-26 17:06:42 +02:00
|
|
|
sprompt.c strerror.c tar.c thread.c
|
2016-01-07 15:59:08 +01:00
|
|
|
win32env.c win32error.c win32security.c win32setlocale.c);
|
2012-06-10 21:20:04 +02:00
|
|
|
|
2014-01-26 15:49:10 +01:00
|
|
|
push(@pgportfiles, 'rint.c') if ($vsVersion < '12.00');
|
|
|
|
|
2019-02-13 16:19:44 +01:00
|
|
|
push(@pgportfiles, 'strtof.c') if ($vsVersion < '14.00');
|
|
|
|
|
Use Intel SSE 4.2 CRC instructions where available.
Modern x86 and x86-64 processors with SSE 4.2 support have special
instructions, crc32b and crc32q, for calculating CRC-32C. They greatly
speed up CRC calculation.
Whether the instructions can be used or not depends on the compiler and the
target architecture. If generation of SSE 4.2 instructions is allowed for
the target (-msse4.2 flag on gcc and clang), use them. If they are not
allowed by default, but the compiler supports the -msse4.2 flag to enable
them, compile just the CRC-32C function with -msse4.2 flag, and check at
runtime whether the processor we're running on supports it. If it doesn't,
fall back to the slicing-by-8 algorithm. (With the common defaults on
current operating systems, the runtime-check variant is what you get in
practice.)
Abhijit Menon-Sen, heavily modified by me, reviewed by Andres Freund.
2015-04-14 16:05:03 +02:00
|
|
|
if ($vsVersion >= '9.00')
|
|
|
|
{
|
Use ARMv8 CRC instructions where available.
ARMv8 introduced special CPU instructions for calculating CRC-32C. Use
them, when available, for speed.
Like with the similar Intel CRC instructions, several factors affect
whether the instructions can be used. The compiler intrinsics for them must
be supported by the compiler, and the instructions must be supported by the
target architecture. If the compilation target architecture does not
support the instructions, but adding "-march=armv8-a+crc" makes them
available, then we compile the code with a runtime check to determine if
the host we're running on supports them or not.
For the runtime check, use glibc getauxval() function. Unfortunately,
that's not very portable, but I couldn't find any more portable way to do
it. If getauxval() is not available, the CRC instructions will still be
used if the target architecture supports them without any additional
compiler flags, but the runtime check will not be available.
Original patch by Yuqi Gu, heavily modified by me. Reviewed by Andres
Freund, Thomas Munro.
Discussion: https://www.postgresql.org/message-id/HE1PR0801MB1323D171938EABC04FFE7FA9E3110%40HE1PR0801MB1323.eurprd08.prod.outlook.com
2018-04-04 11:22:45 +02:00
|
|
|
push(@pgportfiles, 'pg_crc32c_sse42_choose.c');
|
Use Intel SSE 4.2 CRC instructions where available.
Modern x86 and x86-64 processors with SSE 4.2 support have special
instructions, crc32b and crc32q, for calculating CRC-32C. They greatly
speed up CRC calculation.
Whether the instructions can be used or not depends on the compiler and the
target architecture. If generation of SSE 4.2 instructions is allowed for
the target (-msse4.2 flag on gcc and clang), use them. If they are not
allowed by default, but the compiler supports the -msse4.2 flag to enable
them, compile just the CRC-32C function with -msse4.2 flag, and check at
runtime whether the processor we're running on supports it. If it doesn't,
fall back to the slicing-by-8 algorithm. (With the common defaults on
current operating systems, the runtime-check variant is what you get in
practice.)
Abhijit Menon-Sen, heavily modified by me, reviewed by Andres Freund.
2015-04-14 16:05:03 +02:00
|
|
|
push(@pgportfiles, 'pg_crc32c_sse42.c');
|
|
|
|
push(@pgportfiles, 'pg_crc32c_sb8.c');
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2015-05-24 03:35:49 +02:00
|
|
|
push(@pgportfiles, 'pg_crc32c_sb8.c');
|
Use Intel SSE 4.2 CRC instructions where available.
Modern x86 and x86-64 processors with SSE 4.2 support have special
instructions, crc32b and crc32q, for calculating CRC-32C. They greatly
speed up CRC calculation.
Whether the instructions can be used or not depends on the compiler and the
target architecture. If generation of SSE 4.2 instructions is allowed for
the target (-msse4.2 flag on gcc and clang), use them. If they are not
allowed by default, but the compiler supports the -msse4.2 flag to enable
them, compile just the CRC-32C function with -msse4.2 flag, and check at
runtime whether the processor we're running on supports it. If it doesn't,
fall back to the slicing-by-8 algorithm. (With the common defaults on
current operating systems, the runtime-check variant is what you get in
practice.)
Abhijit Menon-Sen, heavily modified by me, reviewed by Andres Freund.
2015-04-14 16:05:03 +02:00
|
|
|
}
|
|
|
|
|
2013-02-22 02:46:17 +01:00
|
|
|
our @pgcommonallfiles = qw(
|
Change floating-point output format for improved performance.
Previously, floating-point output was done by rounding to a specific
decimal precision; by default, to 6 or 15 decimal digits (losing
information) or as requested using extra_float_digits. Drivers that
wanted exact float values, and applications like pg_dump that must
preserve values exactly, set extra_float_digits=3 (or sometimes 2 for
historical reasons, though this isn't enough for float4).
Unfortunately, decimal rounded output is slow enough to become a
noticable bottleneck when dealing with large result sets or COPY of
large tables when many floating-point values are involved.
Floating-point output can be done much faster when the output is not
rounded to a specific decimal length, but rather is chosen as the
shortest decimal representation that is closer to the original float
value than to any other value representable in the same precision. The
recently published Ryu algorithm by Ulf Adams is both relatively
simple and remarkably fast.
Accordingly, change float4out/float8out to output shortest decimal
representations if extra_float_digits is greater than 0, and make that
the new default. Applications that need rounded output can set
extra_float_digits back to 0 or below, and take the resulting
performance hit.
We make one concession to portability for systems with buggy
floating-point input: we do not output decimal values that fall
exactly halfway between adjacent representable binary values (which
would rely on the reader doing round-to-nearest-even correctly). This
is known to be a problem at least for VS2013 on Windows.
Our version of the Ryu code originates from
https://github.com/ulfjack/ryu/ at commit c9c3fb1979, but with the
following (significant) modifications:
- Output format is changed to use fixed-point notation for small
exponents, as printf would, and also to use lowercase 'e', a
minimum of 2 exponent digits, and a mandatory sign on the exponent,
to keep the formatting as close as possible to previous output.
- The output of exact midpoint values is disabled as noted above.
- The integer fast-path code is changed somewhat (since we have
fixed-point output and the upstream did not).
- Our project style has been largely applied to the code with the
exception of C99 declaration-after-statement, which has been
retained as an exception to our present policy.
- Most of upstream's debugging and conditionals are removed, and we
use our own configure tests to determine things like uint128
availability.
Changing the float output format obviously affects a number of
regression tests. This patch uses an explicit setting of
extra_float_digits=0 for test output that is not expected to be
exactly reproducible (e.g. due to numerical instability or differing
algorithms for transcendental functions).
Conversions from floats to numeric are unchanged by this patch. These
may appear in index expressions and it is not yet clear whether any
change should be made, so that can be left for another day.
This patch assumes that the only supported floating point format is
now IEEE format, and the documentation is updated to reflect that.
Code by me, adapting the work of Ulf Adams and other contributors.
References:
https://dl.acm.org/citation.cfm?id=3192369
Reviewed-by: Tom Lane, Andres Freund, Donald Dong
Discussion: https://postgr.es/m/87r2el1bx6.fsf@news-spur.riddles.org.uk
2019-02-13 16:20:33 +01:00
|
|
|
base64.c config_info.c controldata_utils.c d2s.c exec.c f2s.c file_perm.c ip.c
|
Replace the data structure used for keyword lookup.
Previously, ScanKeywordLookup was passed an array of string pointers.
This had some performance deficiencies: the strings themselves might
be scattered all over the place depending on the compiler (and some
quick checking shows that at least with gcc-on-Linux, they indeed
weren't reliably close together). That led to very cache-unfriendly
behavior as the binary search touched strings in many different pages.
Also, depending on the platform, the string pointers might need to
be adjusted at program start, so that they couldn't be simple constant
data. And the ScanKeyword struct had been designed with an eye to
32-bit machines originally; on 64-bit it requires 16 bytes per
keyword, making it even more cache-unfriendly.
Redesign so that the keyword strings themselves are allocated
consecutively (as part of one big char-string constant), thereby
eliminating the touch-lots-of-unrelated-pages syndrome. And get
rid of the ScanKeyword array in favor of three separate arrays:
uint16 offsets into the keyword array, uint16 token codes, and
uint8 keyword categories. That reduces the overhead per keyword
to 5 bytes instead of 16 (even less in programs that only need
one of the token codes and categories); moreover, the binary search
only touches the offsets array, further reducing its cache footprint.
This also lets us put the token codes somewhere else than the
keyword strings are, which avoids some unpleasant build dependencies.
While we're at it, wrap the data used by ScanKeywordLookup into
a struct that can be treated as an opaque type by most callers.
That doesn't change things much right now, but it will make it
less painful to switch to a hash-based lookup method, as is being
discussed in the mailing list thread.
Most of the change here is associated with adding a generator
script that can build the new data structure from the same
list-of-PG_KEYWORD header representation we used before.
The PG_KEYWORD lists that plpgsql and ecpg used to embed in
their scanner .c files have to be moved into headers, and the
Makefiles have to be taught to invoke the generator script.
This work is also necessary if we're to consider hash-based lookup,
since the generator script is what would be responsible for
constructing a hash table.
Aside from saving a few kilobytes in each program that includes
the keyword table, this seems to speed up raw parsing (flex+bison)
by a few percent. So it's worth doing even as it stands, though
we think we can gain even more with a follow-on patch to switch
to hash-based lookup.
John Naylor, with further hacking by me
Discussion: https://postgr.es/m/CAJVSVGXdFVU2sgym89XPL=Lv1zOS5=EHHQ8XWNzFL=mTXkKMLw@mail.gmail.com
2019-01-06 23:02:57 +01:00
|
|
|
keywords.c kwlookup.c link-canary.c md5.c
|
2018-09-09 18:23:23 +02:00
|
|
|
pg_lzcompress.c pgfnames.c psprintf.c relpath.c rmtree.c
|
Make StringInfo available to frontend code.
There's plenty places in frontend code that could benefit from a
string buffer implementation. Some because it yields simpler and
faster code, and some others because of the desire to share code
between backend and frontend.
While there is a string buffer implementation available to frontend
code, libpq's PQExpBuffer, it is clunkier than stringinfo, it
introduces a libpq dependency, doesn't allow for sharing between
frontend and backend code, and has a higher API/ABI stability
requirement due to being exposed via libpq.
Therefore it seems best to just making StringInfo being usable by
frontend code. There's not much to do for that, except for rewriting
two subsequent elog/ereport calls into others types of error
reporting, and deciding on a maximum string length.
For the maximum string size I decided to privately define MaxAllocSize
to the same value as used in the backend. It seems likely that we'll
want to reconsider this for both backend and frontend code in the not
too far away future.
For now I've left stringinfo.h in lib/, rather than common/, to reduce
the likelihood of unnecessary breakage. We could alternatively decide
to provide a redirecting stringinfo.h in lib/, or just not provide
compatibility.
Author: Andres Freund
Reviewed-By: Kyotaro Horiguchi, Daniel Gustafsson
Discussion: https://postgr.es/m/20190920051857.2fhnvhvx4qdddviz@alap3.anarazel.de
2019-11-05 23:56:40 +01:00
|
|
|
saslprep.c scram-common.c string.c stringinfo.c unicode_norm.c username.c
|
Use SASLprep to normalize passwords for SCRAM authentication.
An important step of SASLprep normalization, is to convert the string to
Unicode normalization form NFKC. Unicode normalization requires a fairly
large table of character decompositions, which is generated from data
published by the Unicode consortium. The script to generate the table is
put in src/common/unicode, as well test code for the normalization.
A pre-generated version of the tables is included in src/include/common,
so you don't need the code in src/common/unicode to build PostgreSQL, only
if you wish to modify the normalization tables.
The SASLprep implementation depends on the UTF-8 functions from
src/backend/utils/mb/wchar.c. So to use it, you must also compile and link
that. That doesn't change anything for the current users of these
functions, the backend and libpq, as they both already link with wchar.o.
It would be good to move those functions into a separate file in
src/commmon, but I'll leave that for another day.
No documentation changes included, because there is no details on the
SCRAM mechanism in the docs anyway. An overview on that in the protocol
specification would probably be good, even though SCRAM is documented in
detail in RFC5802. I'll write that as a separate patch. An important thing
to mention there is that we apply SASLprep even on invalid UTF-8 strings,
to support other encodings.
Patch by Michael Paquier and me.
Discussion: https://www.postgresql.org/message-id/CAB7nPqSByyEmAVLtEf1KxTRh=PWNKiWKEKQR=e1yGehz=wbymQ@mail.gmail.com
2017-04-07 13:56:05 +02:00
|
|
|
wait_error.c);
|
Create libpgcommon, and move pg_malloc et al to it
libpgcommon is a new static library to allow sharing code among the
various frontend programs and backend; this lets us eliminate duplicate
implementations of common routines. We avoid libpgport, because that's
intended as a place for porting issues; per discussion, it seems better
to keep them separate.
The first use case, and the only implemented by this patch, is pg_malloc
and friends, which many frontend programs were already using.
At the same time, we can use this to provide palloc emulation functions
for the frontend; this way, some palloc-using files in the backend can
also be used by the frontend cleanly. To do this, we change palloc() in
the backend to be a function instead of a macro on top of
MemoryContextAlloc(). This was previously believed to cause loss of
performance, but this implementation has been tweaked by Tom and Andres
so that on modern compilers it provides a slight improvement over the
previous one.
This lets us clean up some places that were already with
localized hacks.
Most of the pg_malloc/palloc changes in this patch were authored by
Andres Freund. Zoltán Böszörményi also independently provided a form of
that. libpgcommon infrastructure was authored by Álvaro.
2013-02-12 14:33:40 +01:00
|
|
|
|
2017-03-07 13:23:49 +01:00
|
|
|
if ($solution->{options}->{openssl})
|
|
|
|
{
|
|
|
|
push(@pgcommonallfiles, 'sha2_openssl.c');
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
push(@pgcommonallfiles, 'sha2.c');
|
|
|
|
}
|
|
|
|
|
2015-05-24 03:35:49 +02:00
|
|
|
our @pgcommonfrontendfiles = (
|
2016-09-29 18:00:00 +02:00
|
|
|
@pgcommonallfiles, qw(fe_memutils.c file_utils.c
|
2019-05-14 20:19:49 +02:00
|
|
|
logging.c restricted_token.c));
|
2013-02-22 02:46:17 +01:00
|
|
|
|
|
|
|
our @pgcommonbkndfiles = @pgcommonallfiles;
|
Create libpgcommon, and move pg_malloc et al to it
libpgcommon is a new static library to allow sharing code among the
various frontend programs and backend; this lets us eliminate duplicate
implementations of common routines. We avoid libpgport, because that's
intended as a place for porting issues; per discussion, it seems better
to keep them separate.
The first use case, and the only implemented by this patch, is pg_malloc
and friends, which many frontend programs were already using.
At the same time, we can use this to provide palloc emulation functions
for the frontend; this way, some palloc-using files in the backend can
also be used by the frontend cleanly. To do this, we change palloc() in
the backend to be a function instead of a macro on top of
MemoryContextAlloc(). This was previously believed to cause loss of
performance, but this implementation has been tweaked by Tom and Andres
so that on modern compilers it provides a slight improvement over the
previous one.
This lets us clean up some places that were already with
localized hacks.
Most of the pg_malloc/palloc changes in this patch were authored by
Andres Freund. Zoltán Böszörményi also independently provided a form of
that. libpgcommon infrastructure was authored by Álvaro.
2013-02-12 14:33:40 +01:00
|
|
|
|
2016-03-24 20:55:44 +01:00
|
|
|
our @pgfeutilsfiles = qw(
|
2019-12-02 03:18:56 +01:00
|
|
|
cancel.c conditional.c mbprint.c print.c psqlscan.l psqlscan.c
|
2019-09-25 19:35:24 +02:00
|
|
|
simple_list.c string_utils.c recovery_gen.c);
|
2016-03-24 20:55:44 +01:00
|
|
|
|
2012-07-05 03:47:49 +02:00
|
|
|
$libpgport = $solution->AddProject('libpgport', 'lib', 'misc');
|
2012-06-10 21:20:04 +02:00
|
|
|
$libpgport->AddDefine('FRONTEND');
|
2015-04-25 14:52:03 +02:00
|
|
|
$libpgport->AddFiles('src/port', @pgportfiles);
|
2012-06-10 21:20:04 +02:00
|
|
|
|
Create libpgcommon, and move pg_malloc et al to it
libpgcommon is a new static library to allow sharing code among the
various frontend programs and backend; this lets us eliminate duplicate
implementations of common routines. We avoid libpgport, because that's
intended as a place for porting issues; per discussion, it seems better
to keep them separate.
The first use case, and the only implemented by this patch, is pg_malloc
and friends, which many frontend programs were already using.
At the same time, we can use this to provide palloc emulation functions
for the frontend; this way, some palloc-using files in the backend can
also be used by the frontend cleanly. To do this, we change palloc() in
the backend to be a function instead of a macro on top of
MemoryContextAlloc(). This was previously believed to cause loss of
performance, but this implementation has been tweaked by Tom and Andres
so that on modern compilers it provides a slight improvement over the
previous one.
This lets us clean up some places that were already with
localized hacks.
Most of the pg_malloc/palloc changes in this patch were authored by
Andres Freund. Zoltán Böszörményi also independently provided a form of
that. libpgcommon infrastructure was authored by Álvaro.
2013-02-12 14:33:40 +01:00
|
|
|
$libpgcommon = $solution->AddProject('libpgcommon', 'lib', 'misc');
|
|
|
|
$libpgcommon->AddDefine('FRONTEND');
|
2015-04-25 14:52:03 +02:00
|
|
|
$libpgcommon->AddFiles('src/common', @pgcommonfrontendfiles);
|
Create libpgcommon, and move pg_malloc et al to it
libpgcommon is a new static library to allow sharing code among the
various frontend programs and backend; this lets us eliminate duplicate
implementations of common routines. We avoid libpgport, because that's
intended as a place for porting issues; per discussion, it seems better
to keep them separate.
The first use case, and the only implemented by this patch, is pg_malloc
and friends, which many frontend programs were already using.
At the same time, we can use this to provide palloc emulation functions
for the frontend; this way, some palloc-using files in the backend can
also be used by the frontend cleanly. To do this, we change palloc() in
the backend to be a function instead of a macro on top of
MemoryContextAlloc(). This was previously believed to cause loss of
performance, but this implementation has been tweaked by Tom and Andres
so that on modern compilers it provides a slight improvement over the
previous one.
This lets us clean up some places that were already with
localized hacks.
Most of the pg_malloc/palloc changes in this patch were authored by
Andres Freund. Zoltán Böszörményi also independently provided a form of
that. libpgcommon infrastructure was authored by Álvaro.
2013-02-12 14:33:40 +01:00
|
|
|
|
2016-03-24 20:55:44 +01:00
|
|
|
$libpgfeutils = $solution->AddProject('libpgfeutils', 'lib', 'misc');
|
|
|
|
$libpgfeutils->AddDefine('FRONTEND');
|
2016-03-24 22:12:40 +01:00
|
|
|
$libpgfeutils->AddIncludeDir('src/interfaces/libpq');
|
2016-03-24 20:55:44 +01:00
|
|
|
$libpgfeutils->AddFiles('src/fe_utils', @pgfeutilsfiles);
|
|
|
|
|
2015-04-25 14:52:03 +02:00
|
|
|
$postgres = $solution->AddProject('postgres', 'exe', '', 'src/backend');
|
|
|
|
$postgres->AddIncludeDir('src/backend');
|
|
|
|
$postgres->AddDir('src/backend/port/win32');
|
|
|
|
$postgres->AddFile('src/backend/utils/fmgrtab.c');
|
|
|
|
$postgres->ReplaceFile('src/backend/port/pg_sema.c',
|
|
|
|
'src/backend/port/win32_sema.c');
|
|
|
|
$postgres->ReplaceFile('src/backend/port/pg_shmem.c',
|
|
|
|
'src/backend/port/win32_shmem.c');
|
|
|
|
$postgres->AddFiles('src/port', @pgportfiles);
|
|
|
|
$postgres->AddFiles('src/common', @pgcommonbkndfiles);
|
|
|
|
$postgres->AddDir('src/timezone');
|
|
|
|
|
|
|
|
# We need source files from src/timezone, but that directory's resource
|
2014-08-19 04:59:53 +02:00
|
|
|
# file pertains to "zic", not to the backend.
|
2015-04-25 14:52:03 +02:00
|
|
|
$postgres->RemoveFile('src/timezone/win32ver.rc');
|
|
|
|
$postgres->AddFiles('src/backend/parser', 'scan.l', 'gram.y');
|
|
|
|
$postgres->AddFiles('src/backend/bootstrap', 'bootscanner.l',
|
2012-07-05 03:47:49 +02:00
|
|
|
'bootparse.y');
|
2015-04-25 14:52:03 +02:00
|
|
|
$postgres->AddFiles('src/backend/utils/misc', 'guc-file.l');
|
2016-06-12 10:19:56 +02:00
|
|
|
$postgres->AddFiles(
|
|
|
|
'src/backend/replication', 'repl_scanner.l',
|
|
|
|
'repl_gram.y', 'syncrep_scanner.l',
|
|
|
|
'syncrep_gram.y');
|
Partial implementation of SQL/JSON path language
SQL 2016 standards among other things contains set of SQL/JSON features for
JSON processing inside of relational database. The core of SQL/JSON is JSON
path language, allowing access parts of JSON documents and make computations
over them. This commit implements partial support JSON path language as
separate datatype called "jsonpath". The implementation is partial because
it's lacking datetime support and suppression of numeric errors. Missing
features will be added later by separate commits.
Support of SQL/JSON features requires implementation of separate nodes, and it
will be considered in subsequent patches. This commit includes following
set of plain functions, allowing to execute jsonpath over jsonb values:
* jsonb_path_exists(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_match(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query_array(jsonb, jsonpath[, jsonb, bool]).
* jsonb_path_query_first(jsonb, jsonpath[, jsonb, bool]).
This commit also implements "jsonb @? jsonpath" and "jsonb @@ jsonpath", which
are wrappers over jsonpath_exists(jsonb, jsonpath) and jsonpath_predicate(jsonb,
jsonpath) correspondingly. These operators will have an index support
(implemented in subsequent patches).
Catversion bumped, to add new functions and operators.
Code was written by Nikita Glukhov and Teodor Sigaev, revised by me.
Documentation was written by Oleg Bartunov and Liudmila Mantrova. The work
was inspired by Oleg Bartunov.
Discussion: https://postgr.es/m/fcc6fc6a-b497-f39a-923d-aa34d0c588e8%402ndQuadrant.com
Author: Nikita Glukhov, Teodor Sigaev, Alexander Korotkov, Oleg Bartunov, Liudmila Mantrova
Reviewed-by: Tomas Vondra, Andrew Dunstan, Pavel Stehule, Alexander Korotkov
2019-03-16 10:15:37 +01:00
|
|
|
$postgres->AddFiles('src/backend/utils/adt', 'jsonpath_scan.l',
|
|
|
|
'jsonpath_gram.y');
|
2012-06-10 21:20:04 +02:00
|
|
|
$postgres->AddDefine('BUILDING_DLL');
|
|
|
|
$postgres->AddLibrary('secur32.lib');
|
2014-07-15 14:18:39 +02:00
|
|
|
$postgres->AddLibrary('ws2_32.lib');
|
2012-06-10 21:20:04 +02:00
|
|
|
$postgres->AddLibrary('wldap32.lib') if ($solution->{options}->{ldap});
|
|
|
|
$postgres->FullExportDLL('postgres.lib');
|
2015-03-11 14:21:01 +01:00
|
|
|
|
2018-09-28 21:17:07 +02:00
|
|
|
# The OBJS scraper doesn't know about ifdefs, so remove appropriate files
|
|
|
|
# if building without OpenSSL.
|
Break out OpenSSL-specific code to separate files.
This refactoring is in preparation for adding support for other SSL
implementations, with no user-visible effects. There are now two #defines,
USE_OPENSSL which is defined when building with OpenSSL, and USE_SSL which
is defined when building with any SSL implementation. Currently, OpenSSL is
the only implementation so the two #defines go together, but USE_SSL is
supposed to be used for implementation-independent code.
The libpq SSL code is changed to use a custom BIO, which does all the raw
I/O, like we've been doing in the backend for a long time. That makes it
possible to use MSG_NOSIGNAL to block SIGPIPE when using SSL, which avoids
a couple of syscall for each send(). Probably doesn't make much performance
difference in practice - the SSL encryption is expensive enough to mask the
effect - but it was a natural result of this refactoring.
Based on a patch by Martijn van Oosterhout from 2006. Briefly reviewed by
Alvaro Herrera, Andreas Karlsson, Jeff Janes.
2014-08-11 10:54:19 +02:00
|
|
|
if (!$solution->{options}->{openssl})
|
|
|
|
{
|
2018-02-26 19:28:38 +01:00
|
|
|
$postgres->RemoveFile('src/backend/libpq/be-secure-common.c');
|
2015-04-25 14:52:03 +02:00
|
|
|
$postgres->RemoveFile('src/backend/libpq/be-secure-openssl.c');
|
Break out OpenSSL-specific code to separate files.
This refactoring is in preparation for adding support for other SSL
implementations, with no user-visible effects. There are now two #defines,
USE_OPENSSL which is defined when building with OpenSSL, and USE_SSL which
is defined when building with any SSL implementation. Currently, OpenSSL is
the only implementation so the two #defines go together, but USE_SSL is
supposed to be used for implementation-independent code.
The libpq SSL code is changed to use a custom BIO, which does all the raw
I/O, like we've been doing in the backend for a long time. That makes it
possible to use MSG_NOSIGNAL to block SIGPIPE when using SSL, which avoids
a couple of syscall for each send(). Probably doesn't make much performance
difference in practice - the SSL encryption is expensive enough to mask the
effect - but it was a natural result of this refactoring.
Based on a patch by Martijn van Oosterhout from 2006. Briefly reviewed by
Alvaro Herrera, Andreas Karlsson, Jeff Janes.
2014-08-11 10:54:19 +02:00
|
|
|
}
|
GSSAPI encryption support
On both the frontend and backend, prepare for GSSAPI encryption
support by moving common code for error handling into a separate file.
Fix a TODO for handling multiple status messages in the process.
Eliminate the OIDs, which have not been needed for some time.
Add frontend and backend encryption support functions. Keep the
context initiation for authentication-only separate on both the
frontend and backend in order to avoid concerns about changing the
requested flags to include encryption support.
In postmaster, pull GSSAPI authorization checking into a shared
function. Also share the initiator name between the encryption and
non-encryption codepaths.
For HBA, add "hostgssenc" and "hostnogssenc" entries that behave
similarly to their SSL counterparts. "hostgssenc" requires either
"gss", "trust", or "reject" for its authentication.
Similarly, add a "gssencmode" parameter to libpq. Supported values are
"disable", "require", and "prefer". Notably, negotiation will only be
attempted if credentials can be acquired. Move credential acquisition
into its own function to support this behavior.
Add a simple pg_stat_gssapi view similar to pg_stat_ssl, for monitoring
if GSSAPI authentication was used, what principal was used, and if
encryption is being used on the connection.
Finally, add documentation for everything new, and update existing
documentation on connection security.
Thanks to Michael Paquier for the Windows fixes.
Author: Robbie Harwood, with changes to the read/write functions by me.
Reviewed in various forms and at different times by: Michael Paquier,
Andres Freund, David Steele.
Discussion: https://www.postgresql.org/message-id/flat/jlg1tgq1ktm.fsf@thriss.redhat.com
2019-04-03 21:02:33 +02:00
|
|
|
if (!$solution->{options}->{gss})
|
|
|
|
{
|
|
|
|
$postgres->RemoveFile('src/backend/libpq/be-gssapi-common.c');
|
|
|
|
$postgres->RemoveFile('src/backend/libpq/be-secure-gssapi.c');
|
|
|
|
}
|
2012-06-10 21:20:04 +02:00
|
|
|
|
2012-07-05 03:47:49 +02:00
|
|
|
my $snowball = $solution->AddProject('dict_snowball', 'dll', '',
|
2015-04-25 14:52:03 +02:00
|
|
|
'src/backend/snowball');
|
2015-03-11 14:21:01 +01:00
|
|
|
|
2014-08-19 04:59:53 +02:00
|
|
|
# This Makefile uses VPATH to find most source files in a subdirectory.
|
2012-06-10 21:20:04 +02:00
|
|
|
$snowball->RelocateFiles(
|
2015-04-25 14:52:03 +02:00
|
|
|
'src/backend/snowball/libstemmer',
|
2012-06-10 21:20:04 +02:00
|
|
|
sub {
|
2014-08-19 04:59:53 +02:00
|
|
|
return shift !~ /(dict_snowball.c|win32ver.rc)$/;
|
2012-07-05 03:47:49 +02:00
|
|
|
});
|
2015-04-25 14:52:03 +02:00
|
|
|
$snowball->AddIncludeDir('src/include/snowball');
|
2012-06-10 21:20:04 +02:00
|
|
|
$snowball->AddReference($postgres);
|
|
|
|
|
2012-07-05 03:47:49 +02:00
|
|
|
my $plpgsql =
|
2015-04-25 14:52:03 +02:00
|
|
|
$solution->AddProject('plpgsql', 'dll', 'PLs', 'src/pl/plpgsql/src');
|
|
|
|
$plpgsql->AddFiles('src/pl/plpgsql/src', 'pl_gram.y');
|
2012-06-10 21:20:04 +02:00
|
|
|
$plpgsql->AddReference($postgres);
|
|
|
|
|
|
|
|
if ($solution->{options}->{tcl})
|
|
|
|
{
|
2017-05-05 17:05:34 +02:00
|
|
|
my $found = 0;
|
2012-07-05 03:47:49 +02:00
|
|
|
my $pltcl =
|
2015-04-25 14:52:03 +02:00
|
|
|
$solution->AddProject('pltcl', 'dll', 'PLs', 'src/pl/tcl');
|
|
|
|
$pltcl->AddIncludeDir($solution->{options}->{tcl} . '/include');
|
2012-06-10 21:20:04 +02:00
|
|
|
$pltcl->AddReference($postgres);
|
2017-05-05 17:05:34 +02:00
|
|
|
|
2017-07-24 08:53:27 +02:00
|
|
|
for my $tclver (qw(86t 86 85 84))
|
2012-06-10 21:20:04 +02:00
|
|
|
{
|
2017-05-05 17:05:34 +02:00
|
|
|
my $tcllib = $solution->{options}->{tcl} . "/lib/tcl$tclver.lib";
|
|
|
|
if (-e $tcllib)
|
|
|
|
{
|
|
|
|
$pltcl->AddLibrary($tcllib);
|
|
|
|
$found = 1;
|
|
|
|
last;
|
|
|
|
}
|
2012-06-10 21:20:04 +02:00
|
|
|
}
|
2017-05-05 17:05:34 +02:00
|
|
|
die "Unable to find $solution->{options}->{tcl}/lib/tcl<version>.lib"
|
2017-05-18 01:01:23 +02:00
|
|
|
unless $found;
|
2012-06-10 21:20:04 +02:00
|
|
|
}
|
|
|
|
|
2012-07-05 03:47:49 +02:00
|
|
|
$libpq = $solution->AddProject('libpq', 'dll', 'interfaces',
|
2015-04-25 14:52:03 +02:00
|
|
|
'src/interfaces/libpq');
|
2012-06-10 21:20:04 +02:00
|
|
|
$libpq->AddDefine('FRONTEND');
|
|
|
|
$libpq->AddDefine('UNSAFE_STAT_OK');
|
2015-04-25 14:52:03 +02:00
|
|
|
$libpq->AddIncludeDir('src/port');
|
2012-06-10 21:20:04 +02:00
|
|
|
$libpq->AddLibrary('secur32.lib');
|
|
|
|
$libpq->AddLibrary('ws2_32.lib');
|
|
|
|
$libpq->AddLibrary('wldap32.lib') if ($solution->{options}->{ldap});
|
2015-04-25 14:52:03 +02:00
|
|
|
$libpq->UseDef('src/interfaces/libpq/libpqdll.def');
|
2018-09-28 21:49:05 +02:00
|
|
|
$libpq->AddReference($libpgcommon, $libpgport);
|
2015-03-11 14:21:01 +01:00
|
|
|
|
2018-09-28 21:17:07 +02:00
|
|
|
# The OBJS scraper doesn't know about ifdefs, so remove appropriate files
|
|
|
|
# if building without OpenSSL.
|
Break out OpenSSL-specific code to separate files.
This refactoring is in preparation for adding support for other SSL
implementations, with no user-visible effects. There are now two #defines,
USE_OPENSSL which is defined when building with OpenSSL, and USE_SSL which
is defined when building with any SSL implementation. Currently, OpenSSL is
the only implementation so the two #defines go together, but USE_SSL is
supposed to be used for implementation-independent code.
The libpq SSL code is changed to use a custom BIO, which does all the raw
I/O, like we've been doing in the backend for a long time. That makes it
possible to use MSG_NOSIGNAL to block SIGPIPE when using SSL, which avoids
a couple of syscall for each send(). Probably doesn't make much performance
difference in practice - the SSL encryption is expensive enough to mask the
effect - but it was a natural result of this refactoring.
Based on a patch by Martijn van Oosterhout from 2006. Briefly reviewed by
Alvaro Herrera, Andreas Karlsson, Jeff Janes.
2014-08-11 10:54:19 +02:00
|
|
|
if (!$solution->{options}->{openssl})
|
|
|
|
{
|
2018-01-27 19:47:52 +01:00
|
|
|
$libpq->RemoveFile('src/interfaces/libpq/fe-secure-common.c');
|
2015-04-25 14:52:03 +02:00
|
|
|
$libpq->RemoveFile('src/interfaces/libpq/fe-secure-openssl.c');
|
Break out OpenSSL-specific code to separate files.
This refactoring is in preparation for adding support for other SSL
implementations, with no user-visible effects. There are now two #defines,
USE_OPENSSL which is defined when building with OpenSSL, and USE_SSL which
is defined when building with any SSL implementation. Currently, OpenSSL is
the only implementation so the two #defines go together, but USE_SSL is
supposed to be used for implementation-independent code.
The libpq SSL code is changed to use a custom BIO, which does all the raw
I/O, like we've been doing in the backend for a long time. That makes it
possible to use MSG_NOSIGNAL to block SIGPIPE when using SSL, which avoids
a couple of syscall for each send(). Probably doesn't make much performance
difference in practice - the SSL encryption is expensive enough to mask the
effect - but it was a natural result of this refactoring.
Based on a patch by Martijn van Oosterhout from 2006. Briefly reviewed by
Alvaro Herrera, Andreas Karlsson, Jeff Janes.
2014-08-11 10:54:19 +02:00
|
|
|
}
|
GSSAPI encryption support
On both the frontend and backend, prepare for GSSAPI encryption
support by moving common code for error handling into a separate file.
Fix a TODO for handling multiple status messages in the process.
Eliminate the OIDs, which have not been needed for some time.
Add frontend and backend encryption support functions. Keep the
context initiation for authentication-only separate on both the
frontend and backend in order to avoid concerns about changing the
requested flags to include encryption support.
In postmaster, pull GSSAPI authorization checking into a shared
function. Also share the initiator name between the encryption and
non-encryption codepaths.
For HBA, add "hostgssenc" and "hostnogssenc" entries that behave
similarly to their SSL counterparts. "hostgssenc" requires either
"gss", "trust", or "reject" for its authentication.
Similarly, add a "gssencmode" parameter to libpq. Supported values are
"disable", "require", and "prefer". Notably, negotiation will only be
attempted if credentials can be acquired. Move credential acquisition
into its own function to support this behavior.
Add a simple pg_stat_gssapi view similar to pg_stat_ssl, for monitoring
if GSSAPI authentication was used, what principal was used, and if
encryption is being used on the connection.
Finally, add documentation for everything new, and update existing
documentation on connection security.
Thanks to Michael Paquier for the Windows fixes.
Author: Robbie Harwood, with changes to the read/write functions by me.
Reviewed in various forms and at different times by: Michael Paquier,
Andres Freund, David Steele.
Discussion: https://www.postgresql.org/message-id/flat/jlg1tgq1ktm.fsf@thriss.redhat.com
2019-04-03 21:02:33 +02:00
|
|
|
if (!$solution->{options}->{gss})
|
|
|
|
{
|
|
|
|
$libpq->RemoveFile('src/interfaces/libpq/fe-gssapi-common.c');
|
|
|
|
$libpq->RemoveFile('src/interfaces/libpq/fe-secure-gssapi.c');
|
|
|
|
}
|
2012-06-10 21:20:04 +02:00
|
|
|
|
2012-07-05 03:47:49 +02:00
|
|
|
my $libpqwalreceiver =
|
|
|
|
$solution->AddProject('libpqwalreceiver', 'dll', '',
|
2015-04-25 14:52:03 +02:00
|
|
|
'src/backend/replication/libpqwalreceiver');
|
|
|
|
$libpqwalreceiver->AddIncludeDir('src/interfaces/libpq');
|
2012-07-05 03:47:49 +02:00
|
|
|
$libpqwalreceiver->AddReference($postgres, $libpq);
|
2012-06-10 21:20:04 +02:00
|
|
|
|
2017-05-18 01:01:23 +02:00
|
|
|
my $pgoutput = $solution->AddProject('pgoutput', 'dll', '',
|
2017-05-05 12:08:48 +02:00
|
|
|
'src/backend/replication/pgoutput');
|
|
|
|
$pgoutput->AddReference($postgres);
|
|
|
|
|
2012-07-05 03:47:49 +02:00
|
|
|
my $pgtypes = $solution->AddProject(
|
|
|
|
'libpgtypes', 'dll',
|
2015-04-25 14:52:03 +02:00
|
|
|
'interfaces', 'src/interfaces/ecpg/pgtypeslib');
|
2012-06-10 21:20:04 +02:00
|
|
|
$pgtypes->AddDefine('FRONTEND');
|
2018-09-28 21:49:05 +02:00
|
|
|
$pgtypes->AddReference($libpgcommon, $libpgport);
|
2015-04-25 14:52:03 +02:00
|
|
|
$pgtypes->UseDef('src/interfaces/ecpg/pgtypeslib/pgtypeslib.def');
|
|
|
|
$pgtypes->AddIncludeDir('src/interfaces/ecpg/include');
|
2012-06-10 21:20:04 +02:00
|
|
|
|
2012-07-05 03:47:49 +02:00
|
|
|
my $libecpg = $solution->AddProject('libecpg', 'dll', 'interfaces',
|
2015-04-25 14:52:03 +02:00
|
|
|
'src/interfaces/ecpg/ecpglib');
|
2012-06-10 21:20:04 +02:00
|
|
|
$libecpg->AddDefine('FRONTEND');
|
2015-04-25 14:52:03 +02:00
|
|
|
$libecpg->AddIncludeDir('src/interfaces/ecpg/include');
|
|
|
|
$libecpg->AddIncludeDir('src/interfaces/libpq');
|
|
|
|
$libecpg->AddIncludeDir('src/port');
|
|
|
|
$libecpg->UseDef('src/interfaces/ecpg/ecpglib/ecpglib.def');
|
2014-07-15 14:18:39 +02:00
|
|
|
$libecpg->AddLibrary('ws2_32.lib');
|
2012-07-05 03:47:49 +02:00
|
|
|
$libecpg->AddReference($libpq, $pgtypes, $libpgport);
|
2012-06-10 21:20:04 +02:00
|
|
|
|
2012-07-05 03:47:49 +02:00
|
|
|
my $libecpgcompat = $solution->AddProject(
|
|
|
|
'libecpg_compat', 'dll',
|
2015-04-25 14:52:03 +02:00
|
|
|
'interfaces', 'src/interfaces/ecpg/compatlib');
|
2015-04-25 01:29:02 +02:00
|
|
|
$libecpgcompat->AddDefine('FRONTEND');
|
2015-04-25 14:52:03 +02:00
|
|
|
$libecpgcompat->AddIncludeDir('src/interfaces/ecpg/include');
|
|
|
|
$libecpgcompat->AddIncludeDir('src/interfaces/libpq');
|
|
|
|
$libecpgcompat->UseDef('src/interfaces/ecpg/compatlib/compatlib.def');
|
2019-12-05 00:15:11 +01:00
|
|
|
$libecpgcompat->AddReference($pgtypes, $libecpg, $libpgport, $libpgcommon);
|
2012-06-10 21:20:04 +02:00
|
|
|
|
2012-07-05 03:47:49 +02:00
|
|
|
my $ecpg = $solution->AddProject('ecpg', 'exe', 'interfaces',
|
2015-04-25 14:52:03 +02:00
|
|
|
'src/interfaces/ecpg/preproc');
|
|
|
|
$ecpg->AddIncludeDir('src/interfaces/ecpg/include');
|
2018-12-01 23:19:51 +01:00
|
|
|
$ecpg->AddIncludeDir('src/interfaces/ecpg/ecpglib');
|
2015-04-25 14:52:03 +02:00
|
|
|
$ecpg->AddIncludeDir('src/interfaces/libpq');
|
|
|
|
$ecpg->AddPrefixInclude('src/interfaces/ecpg/preproc');
|
|
|
|
$ecpg->AddFiles('src/interfaces/ecpg/preproc', 'pgc.l', 'preproc.y');
|
2013-10-18 14:15:20 +02:00
|
|
|
$ecpg->AddReference($libpgcommon, $libpgport);
|
2012-06-10 21:20:04 +02:00
|
|
|
|
2012-07-05 03:47:49 +02:00
|
|
|
my $pgregress_ecpg =
|
|
|
|
$solution->AddProject('pg_regress_ecpg', 'exe', 'misc');
|
2015-04-25 14:52:03 +02:00
|
|
|
$pgregress_ecpg->AddFile('src/interfaces/ecpg/test/pg_regress_ecpg.c');
|
|
|
|
$pgregress_ecpg->AddFile('src/test/regress/pg_regress.c');
|
|
|
|
$pgregress_ecpg->AddIncludeDir('src/port');
|
|
|
|
$pgregress_ecpg->AddIncludeDir('src/test/regress');
|
2012-06-10 21:20:04 +02:00
|
|
|
$pgregress_ecpg->AddDefine('HOST_TUPLE="i686-pc-win32vc"');
|
2014-12-25 19:52:03 +01:00
|
|
|
$pgregress_ecpg->AddLibrary('ws2_32.lib');
|
2015-04-25 14:52:03 +02:00
|
|
|
$pgregress_ecpg->AddDirResourceFile('src/interfaces/ecpg/test');
|
2019-05-14 20:19:49 +02:00
|
|
|
$pgregress_ecpg->AddReference($libpgcommon, $libpgport);
|
2012-06-10 21:20:04 +02:00
|
|
|
|
2012-07-05 03:47:49 +02:00
|
|
|
my $isolation_tester =
|
|
|
|
$solution->AddProject('isolationtester', 'exe', 'misc');
|
2015-04-25 14:52:03 +02:00
|
|
|
$isolation_tester->AddFile('src/test/isolation/isolationtester.c');
|
|
|
|
$isolation_tester->AddFile('src/test/isolation/specparse.y');
|
|
|
|
$isolation_tester->AddFile('src/test/isolation/specscanner.l');
|
|
|
|
$isolation_tester->AddFile('src/test/isolation/specparse.c');
|
|
|
|
$isolation_tester->AddIncludeDir('src/test/isolation');
|
|
|
|
$isolation_tester->AddIncludeDir('src/port');
|
|
|
|
$isolation_tester->AddIncludeDir('src/test/regress');
|
|
|
|
$isolation_tester->AddIncludeDir('src/interfaces/libpq');
|
2012-06-10 21:20:04 +02:00
|
|
|
$isolation_tester->AddDefine('HOST_TUPLE="i686-pc-win32vc"');
|
2014-07-15 14:18:39 +02:00
|
|
|
$isolation_tester->AddLibrary('ws2_32.lib');
|
2015-04-25 14:52:03 +02:00
|
|
|
$isolation_tester->AddDirResourceFile('src/test/isolation');
|
2013-10-18 15:54:41 +02:00
|
|
|
$isolation_tester->AddReference($libpq, $libpgcommon, $libpgport);
|
2012-06-10 21:20:04 +02:00
|
|
|
|
2012-07-05 03:47:49 +02:00
|
|
|
my $pgregress_isolation =
|
|
|
|
$solution->AddProject('pg_isolation_regress', 'exe', 'misc');
|
2015-04-25 14:52:03 +02:00
|
|
|
$pgregress_isolation->AddFile('src/test/isolation/isolation_main.c');
|
|
|
|
$pgregress_isolation->AddFile('src/test/regress/pg_regress.c');
|
|
|
|
$pgregress_isolation->AddIncludeDir('src/port');
|
|
|
|
$pgregress_isolation->AddIncludeDir('src/test/regress');
|
2012-06-10 21:20:04 +02:00
|
|
|
$pgregress_isolation->AddDefine('HOST_TUPLE="i686-pc-win32vc"');
|
2014-12-25 19:52:03 +01:00
|
|
|
$pgregress_isolation->AddLibrary('ws2_32.lib');
|
2015-04-25 14:52:03 +02:00
|
|
|
$pgregress_isolation->AddDirResourceFile('src/test/isolation');
|
2019-05-14 20:19:49 +02:00
|
|
|
$pgregress_isolation->AddReference($libpgcommon, $libpgport);
|
2012-06-10 21:20:04 +02:00
|
|
|
|
|
|
|
# src/bin
|
2015-03-11 14:21:01 +01:00
|
|
|
my $D;
|
|
|
|
opendir($D, 'src/bin') || croak "Could not opendir on src/bin!\n";
|
|
|
|
while (my $d = readdir($D))
|
|
|
|
{
|
|
|
|
next if ($d =~ /^\./);
|
|
|
|
next unless (-f "src/bin/$d/Makefile");
|
|
|
|
next if (grep { /^$d$/ } @frontend_excludes);
|
|
|
|
AddSimpleFrontend($d);
|
|
|
|
}
|
2012-06-10 21:20:04 +02:00
|
|
|
|
|
|
|
my $pgbasebackup = AddSimpleFrontend('pg_basebackup', 1);
|
2015-04-25 14:52:03 +02:00
|
|
|
$pgbasebackup->AddFile('src/bin/pg_basebackup/pg_basebackup.c');
|
2012-06-10 21:20:04 +02:00
|
|
|
$pgbasebackup->AddLibrary('ws2_32.lib');
|
|
|
|
|
2017-02-09 22:23:46 +01:00
|
|
|
my $pgreceivewal = AddSimpleFrontend('pg_basebackup', 1);
|
|
|
|
$pgreceivewal->{name} = 'pg_receivewal';
|
|
|
|
$pgreceivewal->AddFile('src/bin/pg_basebackup/pg_receivewal.c');
|
|
|
|
$pgreceivewal->AddLibrary('ws2_32.lib');
|
2012-06-10 21:20:04 +02:00
|
|
|
|
2014-05-06 18:12:18 +02:00
|
|
|
my $pgrecvlogical = AddSimpleFrontend('pg_basebackup', 1);
|
2014-04-24 09:30:44 +02:00
|
|
|
$pgrecvlogical->{name} = 'pg_recvlogical';
|
2015-04-25 14:52:03 +02:00
|
|
|
$pgrecvlogical->AddFile('src/bin/pg_basebackup/pg_recvlogical.c');
|
2014-04-24 09:30:44 +02:00
|
|
|
$pgrecvlogical->AddLibrary('ws2_32.lib');
|
|
|
|
|
2015-03-23 18:47:52 +01:00
|
|
|
my $pgrewind = AddSimpleFrontend('pg_rewind', 1);
|
|
|
|
$pgrewind->{name} = 'pg_rewind';
|
2015-04-25 14:52:03 +02:00
|
|
|
$pgrewind->AddFile('src/backend/access/transam/xlogreader.c');
|
2015-03-23 18:47:52 +01:00
|
|
|
$pgrewind->AddLibrary('ws2_32.lib');
|
2015-03-23 19:25:35 +01:00
|
|
|
$pgrewind->AddDefine('FRONTEND');
|
2015-03-23 18:47:52 +01:00
|
|
|
|
2012-07-05 03:47:49 +02:00
|
|
|
my $pgevent = $solution->AddProject('pgevent', 'dll', 'bin');
|
2015-04-25 14:52:03 +02:00
|
|
|
$pgevent->AddFiles('src/bin/pgevent', 'pgevent.c', 'pgmsgevent.rc');
|
|
|
|
$pgevent->AddResourceFile('src/bin/pgevent', 'Eventlog message formatter',
|
2014-07-14 20:07:41 +02:00
|
|
|
'win32');
|
2015-04-25 14:52:03 +02:00
|
|
|
$pgevent->RemoveFile('src/bin/pgevent/win32ver.rc');
|
|
|
|
$pgevent->UseDef('src/bin/pgevent/pgevent.def');
|
2012-06-10 21:20:04 +02:00
|
|
|
$pgevent->DisableLinkerWarnings('4104');
|
|
|
|
|
|
|
|
my $pgdump = AddSimpleFrontend('pg_dump', 1);
|
2015-04-25 14:52:03 +02:00
|
|
|
$pgdump->AddIncludeDir('src/backend');
|
|
|
|
$pgdump->AddFile('src/bin/pg_dump/pg_dump.c');
|
|
|
|
$pgdump->AddFile('src/bin/pg_dump/common.c');
|
|
|
|
$pgdump->AddFile('src/bin/pg_dump/pg_dump_sort.c');
|
2013-03-24 16:27:20 +01:00
|
|
|
$pgdump->AddLibrary('ws2_32.lib');
|
2012-06-10 21:20:04 +02:00
|
|
|
|
|
|
|
my $pgdumpall = AddSimpleFrontend('pg_dump', 1);
|
|
|
|
|
|
|
|
# pg_dumpall doesn't use the files in the Makefile's $(OBJS), unlike
|
|
|
|
# pg_dump and pg_restore.
|
|
|
|
# So remove their sources from the object, keeping the other setup that
|
|
|
|
# AddSimpleFrontend() has done.
|
2015-04-25 14:52:03 +02:00
|
|
|
my @nodumpall = grep { m!src/bin/pg_dump/.*\.c$! }
|
2012-07-05 03:47:49 +02:00
|
|
|
keys %{ $pgdumpall->{files} };
|
|
|
|
delete @{ $pgdumpall->{files} }{@nodumpall};
|
2012-06-10 21:20:04 +02:00
|
|
|
$pgdumpall->{name} = 'pg_dumpall';
|
2015-04-25 14:52:03 +02:00
|
|
|
$pgdumpall->AddIncludeDir('src/backend');
|
|
|
|
$pgdumpall->AddFile('src/bin/pg_dump/pg_dumpall.c');
|
|
|
|
$pgdumpall->AddFile('src/bin/pg_dump/dumputils.c');
|
2013-03-24 16:27:20 +01:00
|
|
|
$pgdumpall->AddLibrary('ws2_32.lib');
|
2012-06-10 21:20:04 +02:00
|
|
|
|
|
|
|
my $pgrestore = AddSimpleFrontend('pg_dump', 1);
|
|
|
|
$pgrestore->{name} = 'pg_restore';
|
2015-04-25 14:52:03 +02:00
|
|
|
$pgrestore->AddIncludeDir('src/backend');
|
|
|
|
$pgrestore->AddFile('src/bin/pg_dump/pg_restore.c');
|
2013-03-24 16:27:20 +01:00
|
|
|
$pgrestore->AddLibrary('ws2_32.lib');
|
2012-06-10 21:20:04 +02:00
|
|
|
|
2012-07-05 03:47:49 +02:00
|
|
|
my $zic = $solution->AddProject('zic', 'exe', 'utils');
|
2016-03-28 22:02:07 +02:00
|
|
|
$zic->AddFiles('src/timezone', 'zic.c');
|
2015-04-25 14:52:03 +02:00
|
|
|
$zic->AddDirResourceFile('src/timezone');
|
2013-10-18 14:15:20 +02:00
|
|
|
$zic->AddReference($libpgcommon, $libpgport);
|
2012-06-10 21:20:04 +02:00
|
|
|
|
2016-09-11 18:46:55 +02:00
|
|
|
if (!$solution->{options}->{xml})
|
2012-06-10 21:20:04 +02:00
|
|
|
{
|
2012-07-05 03:47:49 +02:00
|
|
|
push @contrib_excludes, 'xml2';
|
2012-06-10 21:20:04 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!$solution->{options}->{openssl})
|
|
|
|
{
|
2012-07-05 03:47:49 +02:00
|
|
|
push @contrib_excludes, 'sslinfo';
|
2012-06-10 21:20:04 +02:00
|
|
|
}
|
|
|
|
|
2016-09-11 18:46:55 +02:00
|
|
|
if (!$solution->{options}->{uuid})
|
2012-06-10 21:20:04 +02:00
|
|
|
{
|
2012-07-05 03:47:49 +02:00
|
|
|
push @contrib_excludes, 'uuid-ossp';
|
2012-06-10 21:20:04 +02:00
|
|
|
}
|
|
|
|
|
2014-07-14 20:07:21 +02:00
|
|
|
# AddProject() does not recognize the constructs used to populate OBJS in
|
|
|
|
# the pgcrypto Makefile, so it will discover no files.
|
|
|
|
my $pgcrypto =
|
2015-04-25 14:52:03 +02:00
|
|
|
$solution->AddProject('pgcrypto', 'dll', 'crypto', 'contrib/pgcrypto');
|
2012-06-10 21:20:04 +02:00
|
|
|
$pgcrypto->AddFiles(
|
2015-04-25 14:52:03 +02:00
|
|
|
'contrib/pgcrypto', 'pgcrypto.c',
|
2012-07-05 03:47:49 +02:00
|
|
|
'px.c', 'px-hmac.c',
|
|
|
|
'px-crypt.c', 'crypt-gensalt.c',
|
|
|
|
'crypt-blowfish.c', 'crypt-des.c',
|
|
|
|
'crypt-md5.c', 'mbuf.c',
|
|
|
|
'pgp.c', 'pgp-armor.c',
|
|
|
|
'pgp-cfb.c', 'pgp-compress.c',
|
|
|
|
'pgp-decrypt.c', 'pgp-encrypt.c',
|
|
|
|
'pgp-info.c', 'pgp-mpi.c',
|
|
|
|
'pgp-pubdec.c', 'pgp-pubenc.c',
|
|
|
|
'pgp-pubkey.c', 'pgp-s2k.c',
|
|
|
|
'pgp-pgsql.c');
|
2012-06-10 21:20:04 +02:00
|
|
|
if ($solution->{options}->{openssl})
|
|
|
|
{
|
2015-04-25 14:52:03 +02:00
|
|
|
$pgcrypto->AddFiles('contrib/pgcrypto', 'openssl.c',
|
2012-07-05 03:47:49 +02:00
|
|
|
'pgp-mpi-openssl.c');
|
2012-06-10 21:20:04 +02:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
$pgcrypto->AddFiles(
|
2017-03-07 13:23:49 +01:00
|
|
|
'contrib/pgcrypto', 'md5.c',
|
|
|
|
'sha1.c', 'internal.c',
|
|
|
|
'internal-sha2.c', 'blf.c',
|
|
|
|
'rijndael.c', 'pgp-mpi-internal.c',
|
|
|
|
'imath.c');
|
2012-06-10 21:20:04 +02:00
|
|
|
}
|
|
|
|
$pgcrypto->AddReference($postgres);
|
2014-07-15 14:18:39 +02:00
|
|
|
$pgcrypto->AddLibrary('ws2_32.lib');
|
2012-06-10 21:20:04 +02:00
|
|
|
my $mf = Project::read_file('contrib/pgcrypto/Makefile');
|
|
|
|
GenerateContribSqlFiles('pgcrypto', $mf);
|
|
|
|
|
2015-04-16 20:17:26 +02:00
|
|
|
foreach my $subdir ('contrib', 'src/test/modules')
|
2012-06-10 21:20:04 +02:00
|
|
|
{
|
2015-04-16 20:17:26 +02:00
|
|
|
opendir($D, $subdir) || croak "Could not opendir on $subdir!\n";
|
|
|
|
while (my $d = readdir($D))
|
|
|
|
{
|
|
|
|
next if ($d =~ /^\./);
|
|
|
|
next unless (-f "$subdir/$d/Makefile");
|
|
|
|
next if (grep { /^$d$/ } @contrib_excludes);
|
|
|
|
AddContrib($subdir, $d);
|
|
|
|
}
|
|
|
|
closedir($D);
|
2012-06-10 21:20:04 +02:00
|
|
|
}
|
|
|
|
|
2015-04-28 17:47:08 +02:00
|
|
|
# Build Perl and Python modules after contrib/ modules to satisfy some
|
|
|
|
# dependencies with transform contrib modules, like hstore_plpython
|
|
|
|
# ltree_plpython and hstore_plperl.
|
|
|
|
if ($solution->{options}->{python})
|
|
|
|
{
|
2015-05-24 03:35:49 +02:00
|
|
|
|
2015-04-28 17:47:08 +02:00
|
|
|
# Attempt to get python version and location.
|
|
|
|
# Assume python.exe in specified dir.
|
2015-05-24 03:35:49 +02:00
|
|
|
my $pythonprog = "import sys;print(sys.prefix);"
|
|
|
|
. "print(str(sys.version_info[0])+str(sys.version_info[1]))";
|
|
|
|
my $prefixcmd =
|
|
|
|
$solution->{options}->{python} . "\\python -c \"$pythonprog\"";
|
2015-04-28 17:47:08 +02:00
|
|
|
my $pyout = `$prefixcmd`;
|
|
|
|
die "Could not query for python version!\n" if $?;
|
2015-05-24 03:35:49 +02:00
|
|
|
my ($pyprefix, $pyver) = split(/\r?\n/, $pyout);
|
2015-04-28 17:47:08 +02:00
|
|
|
|
|
|
|
# Sometimes (always?) if python is not present, the execution
|
|
|
|
# appears to work, but gives no data...
|
|
|
|
die "Failed to query python for version information\n"
|
|
|
|
if (!(defined($pyprefix) && defined($pyver)));
|
|
|
|
|
|
|
|
my $pymajorver = substr($pyver, 0, 1);
|
|
|
|
my $plpython = $solution->AddProject('plpython' . $pymajorver,
|
|
|
|
'dll', 'PLs', 'src/pl/plpython');
|
|
|
|
$plpython->AddIncludeDir($pyprefix . '/include');
|
|
|
|
$plpython->AddLibrary($pyprefix . "/Libs/python$pyver.lib");
|
|
|
|
$plpython->AddReference($postgres);
|
|
|
|
|
|
|
|
# Add transform modules dependent on plpython
|
Convert contrib/hstore_plpython to not use direct linking to other modules.
Previously, on most platforms, we allowed hstore_plpython's references
to hstore and plpython to be unresolved symbols at link time, trusting
the dynamic linker to resolve them when the module is loaded. This
has a number of problems, the worst being that the dynamic linker
does not know where the references come from and can do nothing but
fail if those other modules haven't been loaded. We've more or less
gotten away with that for the limited use-case of datatype transform
modules, but even there, it requires some awkward hacks, most recently
commit 83c249200.
Instead, let's not treat these references as linker-resolvable at all,
but use function pointers that are manually filled in by the module's
_PG_init function. There are few enough contact points that this
doesn't seem unmaintainable, at least for these use-cases. (Note that
the same technique wouldn't work at all for decoupling from libpython
itself, but fortunately that's just a standard shared library and can
be linked to normally.)
This is an initial patch that just converts hstore_plpython. If the
buildfarm doesn't find any fatal problems, I'll work on the other
transform modules soon.
Tom Lane, per an idea of Andres Freund's.
Discussion: <2652.1475512158@sss.pgh.pa.us>
2016-10-04 04:27:11 +02:00
|
|
|
my $hstore_plpython = AddTransformModule(
|
2015-05-24 03:35:49 +02:00
|
|
|
'hstore_plpython' . $pymajorver, 'contrib/hstore_plpython',
|
|
|
|
'plpython' . $pymajorver, 'src/pl/plpython',
|
2018-09-16 19:46:45 +02:00
|
|
|
'hstore', 'contrib');
|
2017-05-18 01:01:23 +02:00
|
|
|
$hstore_plpython->AddDefine(
|
|
|
|
'PLPYTHON_LIBNAME="plpython' . $pymajorver . '"');
|
2018-03-28 17:49:23 +02:00
|
|
|
my $jsonb_plpython = AddTransformModule(
|
|
|
|
'jsonb_plpython' . $pymajorver, 'contrib/jsonb_plpython',
|
|
|
|
'plpython' . $pymajorver, 'src/pl/plpython');
|
|
|
|
$jsonb_plpython->AddDefine(
|
|
|
|
'PLPYTHON_LIBNAME="plpython' . $pymajorver . '"');
|
2016-10-04 23:49:07 +02:00
|
|
|
my $ltree_plpython = AddTransformModule(
|
2015-05-24 03:35:49 +02:00
|
|
|
'ltree_plpython' . $pymajorver, 'contrib/ltree_plpython',
|
|
|
|
'plpython' . $pymajorver, 'src/pl/plpython',
|
2018-09-16 19:46:45 +02:00
|
|
|
'ltree', 'contrib');
|
2017-05-18 01:01:23 +02:00
|
|
|
$ltree_plpython->AddDefine(
|
|
|
|
'PLPYTHON_LIBNAME="plpython' . $pymajorver . '"');
|
2015-04-28 17:47:08 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if ($solution->{options}->{perl})
|
|
|
|
{
|
|
|
|
my $plperlsrc = "src/pl/plperl/";
|
|
|
|
my $plperl =
|
|
|
|
$solution->AddProject('plperl', 'dll', 'PLs', 'src/pl/plperl');
|
|
|
|
$plperl->AddIncludeDir($solution->{options}->{perl} . '/lib/CORE');
|
2017-12-09 03:06:05 +01:00
|
|
|
$plperl->AddReference($postgres);
|
|
|
|
|
|
|
|
my $perl_path = $solution->{options}->{perl} . '\lib\CORE\*perl*';
|
|
|
|
|
2018-04-26 20:13:46 +02:00
|
|
|
# ActivePerl 5.16 provided perl516.lib; 5.18 provided libperl518.a
|
|
|
|
# Starting with ActivePerl 5.24, both perlnn.lib and libperlnn.a are provided.
|
|
|
|
# In this case, prefer .lib.
|
2017-12-09 03:06:05 +01:00
|
|
|
my @perl_libs =
|
2018-04-25 20:00:19 +02:00
|
|
|
reverse sort grep { /perl\d+\.lib$|libperl\d+\.a$/ }
|
|
|
|
glob($perl_path);
|
2018-03-02 12:40:49 +01:00
|
|
|
if (@perl_libs > 0)
|
2017-12-09 03:06:05 +01:00
|
|
|
{
|
|
|
|
$plperl->AddLibrary($perl_libs[0]);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
die
|
2018-04-26 17:52:52 +02:00
|
|
|
"could not identify perl library version matching pattern $perl_path\n";
|
2017-12-09 03:06:05 +01:00
|
|
|
}
|
PL/Perl portability fix: absorb relevant -D switches from Perl.
The Perl documentation is very clear that stuff calling libperl should
be built with the compiler switches shown by Perl's $Config{ccflags}.
We'd been ignoring that up to now, and mostly getting away with it,
but recent Perl versions contain ABI compatibility cross-checks that
fail on some builds because of this omission. In particular the
sizeof(PerlInterpreter) can come out different due to some fields being
added or removed; which means we have a live ABI hazard that we'd better
fix rather than continuing to sweep it under the rug.
However, it still seems like a bad idea to just absorb $Config{ccflags}
verbatim. In some environments Perl was built with a different compiler
that doesn't even use the same switch syntax. -D switch syntax is pretty
universal though, and absorbing Perl's -D switches really ought to be
enough to fix the problem.
Furthermore, Perl likes to inject stuff like -D_LARGEFILE_SOURCE and
-D_FILE_OFFSET_BITS=64 into $Config{ccflags}, which affect libc ABIs on
platforms where they're relevant. Adopting those seems dangerous too.
It's unclear whether a build wherein Perl and Postgres have different ideas
of sizeof(off_t) etc would work, or whether anyone would care about making
it work. But it's dead certain that having different stdio ABIs in
core Postgres and PL/Perl will not work; we've seen that movie before.
Therefore, let's also ignore -D switches for symbols beginning with
underscore. The symbols that we actually need to import should be the ones
mentioned in perl.h's PL_bincompat_options stanza, and none of those start
with underscore, so this seems likely to work. (If it turns out not to
work everywhere, we could consider intersecting the symbols mentioned in
PL_bincompat_options with the -D switches. But that will be much more
complicated, so let's try this way first.)
This will need to be back-patched, but first let's see what the
buildfarm makes of it.
Ashutosh Sharma, some adjustments by me
Discussion: https://postgr.es/m/CANFyU97OVQ3+Mzfmt3MhuUm5NwPU=-FtbNH5Eb7nZL9ua8=rcA@mail.gmail.com
2017-07-28 20:25:28 +02:00
|
|
|
|
|
|
|
# Add defines from Perl's ccflags; see PGAC_CHECK_PERL_EMBED_CCFLAGS
|
|
|
|
my @perl_embed_ccflags;
|
2017-08-14 23:29:33 +02:00
|
|
|
foreach my $f (split(" ", $Config{ccflags}))
|
PL/Perl portability fix: absorb relevant -D switches from Perl.
The Perl documentation is very clear that stuff calling libperl should
be built with the compiler switches shown by Perl's $Config{ccflags}.
We'd been ignoring that up to now, and mostly getting away with it,
but recent Perl versions contain ABI compatibility cross-checks that
fail on some builds because of this omission. In particular the
sizeof(PerlInterpreter) can come out different due to some fields being
added or removed; which means we have a live ABI hazard that we'd better
fix rather than continuing to sweep it under the rug.
However, it still seems like a bad idea to just absorb $Config{ccflags}
verbatim. In some environments Perl was built with a different compiler
that doesn't even use the same switch syntax. -D switch syntax is pretty
universal though, and absorbing Perl's -D switches really ought to be
enough to fix the problem.
Furthermore, Perl likes to inject stuff like -D_LARGEFILE_SOURCE and
-D_FILE_OFFSET_BITS=64 into $Config{ccflags}, which affect libc ABIs on
platforms where they're relevant. Adopting those seems dangerous too.
It's unclear whether a build wherein Perl and Postgres have different ideas
of sizeof(off_t) etc would work, or whether anyone would care about making
it work. But it's dead certain that having different stdio ABIs in
core Postgres and PL/Perl will not work; we've seen that movie before.
Therefore, let's also ignore -D switches for symbols beginning with
underscore. The symbols that we actually need to import should be the ones
mentioned in perl.h's PL_bincompat_options stanza, and none of those start
with underscore, so this seems likely to work. (If it turns out not to
work everywhere, we could consider intersecting the symbols mentioned in
PL_bincompat_options with the -D switches. But that will be much more
complicated, so let's try this way first.)
This will need to be back-patched, but first let's see what the
buildfarm makes of it.
Ashutosh Sharma, some adjustments by me
Discussion: https://postgr.es/m/CANFyU97OVQ3+Mzfmt3MhuUm5NwPU=-FtbNH5Eb7nZL9ua8=rcA@mail.gmail.com
2017-07-28 20:25:28 +02:00
|
|
|
{
|
2017-12-09 03:06:05 +01:00
|
|
|
if ($f =~ /^-D[^_]/)
|
PL/Perl portability fix: absorb relevant -D switches from Perl.
The Perl documentation is very clear that stuff calling libperl should
be built with the compiler switches shown by Perl's $Config{ccflags}.
We'd been ignoring that up to now, and mostly getting away with it,
but recent Perl versions contain ABI compatibility cross-checks that
fail on some builds because of this omission. In particular the
sizeof(PerlInterpreter) can come out different due to some fields being
added or removed; which means we have a live ABI hazard that we'd better
fix rather than continuing to sweep it under the rug.
However, it still seems like a bad idea to just absorb $Config{ccflags}
verbatim. In some environments Perl was built with a different compiler
that doesn't even use the same switch syntax. -D switch syntax is pretty
universal though, and absorbing Perl's -D switches really ought to be
enough to fix the problem.
Furthermore, Perl likes to inject stuff like -D_LARGEFILE_SOURCE and
-D_FILE_OFFSET_BITS=64 into $Config{ccflags}, which affect libc ABIs on
platforms where they're relevant. Adopting those seems dangerous too.
It's unclear whether a build wherein Perl and Postgres have different ideas
of sizeof(off_t) etc would work, or whether anyone would care about making
it work. But it's dead certain that having different stdio ABIs in
core Postgres and PL/Perl will not work; we've seen that movie before.
Therefore, let's also ignore -D switches for symbols beginning with
underscore. The symbols that we actually need to import should be the ones
mentioned in perl.h's PL_bincompat_options stanza, and none of those start
with underscore, so this seems likely to work. (If it turns out not to
work everywhere, we could consider intersecting the symbols mentioned in
PL_bincompat_options with the -D switches. But that will be much more
complicated, so let's try this way first.)
This will need to be back-patched, but first let's see what the
buildfarm makes of it.
Ashutosh Sharma, some adjustments by me
Discussion: https://postgr.es/m/CANFyU97OVQ3+Mzfmt3MhuUm5NwPU=-FtbNH5Eb7nZL9ua8=rcA@mail.gmail.com
2017-07-28 20:25:28 +02:00
|
|
|
{
|
|
|
|
$f =~ s/\-D//;
|
|
|
|
push(@perl_embed_ccflags, $f);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-12-09 03:06:05 +01:00
|
|
|
# hack to prevent duplicate definitions of uid_t/gid_t
|
PL/Perl portability fix: absorb relevant -D switches from Perl.
The Perl documentation is very clear that stuff calling libperl should
be built with the compiler switches shown by Perl's $Config{ccflags}.
We'd been ignoring that up to now, and mostly getting away with it,
but recent Perl versions contain ABI compatibility cross-checks that
fail on some builds because of this omission. In particular the
sizeof(PerlInterpreter) can come out different due to some fields being
added or removed; which means we have a live ABI hazard that we'd better
fix rather than continuing to sweep it under the rug.
However, it still seems like a bad idea to just absorb $Config{ccflags}
verbatim. In some environments Perl was built with a different compiler
that doesn't even use the same switch syntax. -D switch syntax is pretty
universal though, and absorbing Perl's -D switches really ought to be
enough to fix the problem.
Furthermore, Perl likes to inject stuff like -D_LARGEFILE_SOURCE and
-D_FILE_OFFSET_BITS=64 into $Config{ccflags}, which affect libc ABIs on
platforms where they're relevant. Adopting those seems dangerous too.
It's unclear whether a build wherein Perl and Postgres have different ideas
of sizeof(off_t) etc would work, or whether anyone would care about making
it work. But it's dead certain that having different stdio ABIs in
core Postgres and PL/Perl will not work; we've seen that movie before.
Therefore, let's also ignore -D switches for symbols beginning with
underscore. The symbols that we actually need to import should be the ones
mentioned in perl.h's PL_bincompat_options stanza, and none of those start
with underscore, so this seems likely to work. (If it turns out not to
work everywhere, we could consider intersecting the symbols mentioned in
PL_bincompat_options with the -D switches. But that will be much more
complicated, so let's try this way first.)
This will need to be back-patched, but first let's see what the
buildfarm makes of it.
Ashutosh Sharma, some adjustments by me
Discussion: https://postgr.es/m/CANFyU97OVQ3+Mzfmt3MhuUm5NwPU=-FtbNH5Eb7nZL9ua8=rcA@mail.gmail.com
2017-07-28 20:25:28 +02:00
|
|
|
push(@perl_embed_ccflags, 'PLPERL_HAVE_UID_GID');
|
|
|
|
|
2017-12-09 03:06:05 +01:00
|
|
|
# Windows offers several 32-bit ABIs. Perl is sensitive to
|
|
|
|
# sizeof(time_t), one of the ABI dimensions. To get 32-bit time_t,
|
|
|
|
# use "cl -D_USE_32BIT_TIME_T" or plain "gcc". For 64-bit time_t, use
|
|
|
|
# "gcc -D__MINGW_USE_VC2005_COMPAT" or plain "cl". Before MSVC 2005,
|
|
|
|
# plain "cl" chose 32-bit time_t. PostgreSQL doesn't support building
|
|
|
|
# with pre-MSVC-2005 compilers, but it does support linking to Perl
|
|
|
|
# built with such a compiler. MSVC-built Perl 5.13.4 and later report
|
|
|
|
# -D_USE_32BIT_TIME_T in $Config{ccflags} if applicable, but
|
|
|
|
# MinGW-built Perl never reports -D_USE_32BIT_TIME_T despite typically
|
|
|
|
# needing it. Ignore the $Config{ccflags} opinion about
|
|
|
|
# -D_USE_32BIT_TIME_T, and use a runtime test to deduce the ABI Perl
|
|
|
|
# expects. Specifically, test use of PL_modglobal, which maps to a
|
|
|
|
# PerlInterpreter field whose position depends on sizeof(time_t).
|
|
|
|
if ($solution->{platform} eq 'Win32')
|
|
|
|
{
|
|
|
|
my $source_file = 'conftest.c';
|
|
|
|
my $obj = 'conftest.obj';
|
|
|
|
my $exe = 'conftest.exe';
|
|
|
|
my @conftest = ($source_file, $obj, $exe);
|
|
|
|
push @unlink_on_exit, @conftest;
|
|
|
|
unlink $source_file;
|
|
|
|
open my $o, '>', $source_file
|
|
|
|
|| croak "Could not write to $source_file";
|
|
|
|
print $o '
|
|
|
|
/* compare to plperl.h */
|
|
|
|
#define __inline__ __inline
|
|
|
|
#define PERL_NO_GET_CONTEXT
|
|
|
|
#include <EXTERN.h>
|
|
|
|
#include <perl.h>
|
|
|
|
|
|
|
|
int
|
|
|
|
main(int argc, char **argv)
|
|
|
|
{
|
|
|
|
int dummy_argc = 1;
|
|
|
|
char *dummy_argv[1] = {""};
|
|
|
|
char *dummy_env[1] = {NULL};
|
|
|
|
static PerlInterpreter *interp;
|
|
|
|
|
|
|
|
PERL_SYS_INIT3(&dummy_argc, (char ***) &dummy_argv,
|
|
|
|
(char ***) &dummy_env);
|
|
|
|
interp = perl_alloc();
|
|
|
|
perl_construct(interp);
|
|
|
|
{
|
|
|
|
dTHX;
|
|
|
|
const char key[] = "dummy";
|
|
|
|
|
|
|
|
PL_exit_flags |= PERL_EXIT_DESTRUCT_END;
|
|
|
|
hv_store(PL_modglobal, key, sizeof(key) - 1, newSViv(1), 0);
|
|
|
|
return hv_fetch(PL_modglobal, key, sizeof(key) - 1, 0) == NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
';
|
|
|
|
close $o;
|
|
|
|
|
|
|
|
# Build $source_file with a given #define, and return a true value
|
|
|
|
# if a run of the resulting binary exits successfully.
|
|
|
|
my $try_define = sub {
|
|
|
|
my $define = shift;
|
|
|
|
|
|
|
|
unlink $obj, $exe;
|
|
|
|
my @cmd = (
|
|
|
|
'cl',
|
|
|
|
'-I' . $solution->{options}->{perl} . '/lib/CORE',
|
|
|
|
(map { "-D$_" } @perl_embed_ccflags, $define || ()),
|
|
|
|
$source_file,
|
|
|
|
'/link',
|
|
|
|
$perl_libs[0]);
|
|
|
|
my $compile_output = `@cmd 2>&1`;
|
|
|
|
-f $exe || die "Failed to build Perl test:\n$compile_output";
|
|
|
|
|
|
|
|
{
|
|
|
|
|
|
|
|
# Some builds exhibit runtime failure through Perl warning
|
2018-11-02 13:56:16 +01:00
|
|
|
# 'Can't spawn "conftest.exe"'; suppress that.
|
2017-12-09 03:06:05 +01:00
|
|
|
no warnings;
|
|
|
|
|
|
|
|
# Disable error dialog boxes like we do in the postmaster.
|
|
|
|
# Here, we run code that triggers relevant errors.
|
|
|
|
use Win32API::File qw(SetErrorMode :SEM_);
|
|
|
|
my $oldmode = SetErrorMode(
|
|
|
|
SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX);
|
|
|
|
system(".\\$exe");
|
|
|
|
SetErrorMode($oldmode);
|
|
|
|
}
|
|
|
|
|
|
|
|
return !($? >> 8);
|
|
|
|
};
|
|
|
|
|
|
|
|
my $define_32bit_time = '_USE_32BIT_TIME_T';
|
|
|
|
my $ok_now = $try_define->(undef);
|
|
|
|
my $ok_32bit = $try_define->($define_32bit_time);
|
|
|
|
unlink @conftest;
|
|
|
|
if (!$ok_now && !$ok_32bit)
|
|
|
|
{
|
|
|
|
|
|
|
|
# Unsupported configuration. Since we used %Config from the
|
|
|
|
# Perl running the build scripts, this is expected if
|
|
|
|
# attempting to link with some other Perl.
|
|
|
|
die "Perl test fails with or without -D$define_32bit_time";
|
|
|
|
}
|
|
|
|
elsif ($ok_now && $ok_32bit)
|
|
|
|
{
|
|
|
|
|
|
|
|
# Resulting build may work, but it's especially important to
|
|
|
|
# verify with "vcregress plcheck". A refined test may avoid
|
|
|
|
# this outcome.
|
|
|
|
warn "Perl test passes with or without -D$define_32bit_time";
|
|
|
|
}
|
|
|
|
elsif ($ok_32bit)
|
|
|
|
{
|
|
|
|
push(@perl_embed_ccflags, $define_32bit_time);
|
|
|
|
} # else $ok_now, hence no flag required
|
|
|
|
}
|
|
|
|
|
|
|
|
print "CFLAGS recommended by Perl: $Config{ccflags}\n";
|
|
|
|
print "CFLAGS to compile embedded Perl: ",
|
|
|
|
(join ' ', map { "-D$_" } @perl_embed_ccflags), "\n";
|
PL/Perl portability fix: absorb relevant -D switches from Perl.
The Perl documentation is very clear that stuff calling libperl should
be built with the compiler switches shown by Perl's $Config{ccflags}.
We'd been ignoring that up to now, and mostly getting away with it,
but recent Perl versions contain ABI compatibility cross-checks that
fail on some builds because of this omission. In particular the
sizeof(PerlInterpreter) can come out different due to some fields being
added or removed; which means we have a live ABI hazard that we'd better
fix rather than continuing to sweep it under the rug.
However, it still seems like a bad idea to just absorb $Config{ccflags}
verbatim. In some environments Perl was built with a different compiler
that doesn't even use the same switch syntax. -D switch syntax is pretty
universal though, and absorbing Perl's -D switches really ought to be
enough to fix the problem.
Furthermore, Perl likes to inject stuff like -D_LARGEFILE_SOURCE and
-D_FILE_OFFSET_BITS=64 into $Config{ccflags}, which affect libc ABIs on
platforms where they're relevant. Adopting those seems dangerous too.
It's unclear whether a build wherein Perl and Postgres have different ideas
of sizeof(off_t) etc would work, or whether anyone would care about making
it work. But it's dead certain that having different stdio ABIs in
core Postgres and PL/Perl will not work; we've seen that movie before.
Therefore, let's also ignore -D switches for symbols beginning with
underscore. The symbols that we actually need to import should be the ones
mentioned in perl.h's PL_bincompat_options stanza, and none of those start
with underscore, so this seems likely to work. (If it turns out not to
work everywhere, we could consider intersecting the symbols mentioned in
PL_bincompat_options with the -D switches. But that will be much more
complicated, so let's try this way first.)
This will need to be back-patched, but first let's see what the
buildfarm makes of it.
Ashutosh Sharma, some adjustments by me
Discussion: https://postgr.es/m/CANFyU97OVQ3+Mzfmt3MhuUm5NwPU=-FtbNH5Eb7nZL9ua8=rcA@mail.gmail.com
2017-07-28 20:25:28 +02:00
|
|
|
foreach my $f (@perl_embed_ccflags)
|
|
|
|
{
|
|
|
|
$plperl->AddDefine($f);
|
|
|
|
}
|
|
|
|
|
2015-04-28 17:47:08 +02:00
|
|
|
foreach my $xs ('SPI.xs', 'Util.xs')
|
|
|
|
{
|
|
|
|
(my $xsc = $xs) =~ s/\.xs/.c/;
|
|
|
|
if (Solution::IsNewer("$plperlsrc$xsc", "$plperlsrc$xs"))
|
|
|
|
{
|
2018-05-18 16:46:38 +02:00
|
|
|
my $xsubppdir = first { -e "$_/ExtUtils/xsubpp" } (@INC);
|
2015-04-28 17:47:08 +02:00
|
|
|
print "Building $plperlsrc$xsc...\n";
|
|
|
|
system( $solution->{options}->{perl}
|
|
|
|
. '/bin/perl '
|
|
|
|
. "$xsubppdir/ExtUtils/xsubpp -typemap "
|
|
|
|
. $solution->{options}->{perl}
|
|
|
|
. '/lib/ExtUtils/typemap '
|
|
|
|
. "$plperlsrc$xs "
|
|
|
|
. ">$plperlsrc$xsc");
|
|
|
|
if ((!(-f "$plperlsrc$xsc")) || -z "$plperlsrc$xsc")
|
|
|
|
{
|
|
|
|
unlink("$plperlsrc$xsc"); # if zero size
|
|
|
|
die "Failed to create $xsc.\n";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (Solution::IsNewer(
|
|
|
|
'src/pl/plperl/perlchunks.h',
|
|
|
|
'src/pl/plperl/plc_perlboot.pl')
|
|
|
|
|| Solution::IsNewer(
|
|
|
|
'src/pl/plperl/perlchunks.h',
|
|
|
|
'src/pl/plperl/plc_trusted.pl'))
|
|
|
|
{
|
|
|
|
print 'Building src/pl/plperl/perlchunks.h ...' . "\n";
|
|
|
|
my $basedir = getcwd;
|
|
|
|
chdir 'src/pl/plperl';
|
|
|
|
system( $solution->{options}->{perl}
|
|
|
|
. '/bin/perl '
|
|
|
|
. 'text2macro.pl '
|
|
|
|
. '--strip="^(\#.*|\s*)$$" '
|
|
|
|
. 'plc_perlboot.pl plc_trusted.pl '
|
|
|
|
. '>perlchunks.h');
|
|
|
|
chdir $basedir;
|
|
|
|
if ((!(-f 'src/pl/plperl/perlchunks.h'))
|
|
|
|
|| -z 'src/pl/plperl/perlchunks.h')
|
|
|
|
{
|
|
|
|
unlink('src/pl/plperl/perlchunks.h'); # if zero size
|
|
|
|
die 'Failed to create perlchunks.h' . "\n";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (Solution::IsNewer(
|
|
|
|
'src/pl/plperl/plperl_opmask.h',
|
|
|
|
'src/pl/plperl/plperl_opmask.pl'))
|
|
|
|
{
|
|
|
|
print 'Building src/pl/plperl/plperl_opmask.h ...' . "\n";
|
|
|
|
my $basedir = getcwd;
|
|
|
|
chdir 'src/pl/plperl';
|
|
|
|
system( $solution->{options}->{perl}
|
|
|
|
. '/bin/perl '
|
|
|
|
. 'plperl_opmask.pl '
|
|
|
|
. 'plperl_opmask.h');
|
|
|
|
chdir $basedir;
|
|
|
|
if ((!(-f 'src/pl/plperl/plperl_opmask.h'))
|
|
|
|
|| -z 'src/pl/plperl/plperl_opmask.h')
|
|
|
|
{
|
|
|
|
unlink('src/pl/plperl/plperl_opmask.h'); # if zero size
|
|
|
|
die 'Failed to create plperl_opmask.h' . "\n";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-04-03 16:43:16 +02:00
|
|
|
# Add transform modules dependent on plperl
|
2015-05-24 03:35:49 +02:00
|
|
|
my $hstore_plperl = AddTransformModule(
|
|
|
|
'hstore_plperl', 'contrib/hstore_plperl',
|
|
|
|
'plperl', 'src/pl/plperl',
|
2018-09-16 19:46:45 +02:00
|
|
|
'hstore', 'contrib');
|
2018-04-03 16:43:16 +02:00
|
|
|
my $jsonb_plperl = AddTransformModule(
|
|
|
|
'jsonb_plperl', 'contrib/jsonb_plperl',
|
2018-04-25 20:00:19 +02:00
|
|
|
'plperl', 'src/pl/plperl');
|
PL/Perl portability fix: absorb relevant -D switches from Perl.
The Perl documentation is very clear that stuff calling libperl should
be built with the compiler switches shown by Perl's $Config{ccflags}.
We'd been ignoring that up to now, and mostly getting away with it,
but recent Perl versions contain ABI compatibility cross-checks that
fail on some builds because of this omission. In particular the
sizeof(PerlInterpreter) can come out different due to some fields being
added or removed; which means we have a live ABI hazard that we'd better
fix rather than continuing to sweep it under the rug.
However, it still seems like a bad idea to just absorb $Config{ccflags}
verbatim. In some environments Perl was built with a different compiler
that doesn't even use the same switch syntax. -D switch syntax is pretty
universal though, and absorbing Perl's -D switches really ought to be
enough to fix the problem.
Furthermore, Perl likes to inject stuff like -D_LARGEFILE_SOURCE and
-D_FILE_OFFSET_BITS=64 into $Config{ccflags}, which affect libc ABIs on
platforms where they're relevant. Adopting those seems dangerous too.
It's unclear whether a build wherein Perl and Postgres have different ideas
of sizeof(off_t) etc would work, or whether anyone would care about making
it work. But it's dead certain that having different stdio ABIs in
core Postgres and PL/Perl will not work; we've seen that movie before.
Therefore, let's also ignore -D switches for symbols beginning with
underscore. The symbols that we actually need to import should be the ones
mentioned in perl.h's PL_bincompat_options stanza, and none of those start
with underscore, so this seems likely to work. (If it turns out not to
work everywhere, we could consider intersecting the symbols mentioned in
PL_bincompat_options with the -D switches. But that will be much more
complicated, so let's try this way first.)
This will need to be back-patched, but first let's see what the
buildfarm makes of it.
Ashutosh Sharma, some adjustments by me
Discussion: https://postgr.es/m/CANFyU97OVQ3+Mzfmt3MhuUm5NwPU=-FtbNH5Eb7nZL9ua8=rcA@mail.gmail.com
2017-07-28 20:25:28 +02:00
|
|
|
|
|
|
|
foreach my $f (@perl_embed_ccflags)
|
|
|
|
{
|
|
|
|
$hstore_plperl->AddDefine($f);
|
2018-04-03 16:43:16 +02:00
|
|
|
$jsonb_plperl->AddDefine($f);
|
PL/Perl portability fix: absorb relevant -D switches from Perl.
The Perl documentation is very clear that stuff calling libperl should
be built with the compiler switches shown by Perl's $Config{ccflags}.
We'd been ignoring that up to now, and mostly getting away with it,
but recent Perl versions contain ABI compatibility cross-checks that
fail on some builds because of this omission. In particular the
sizeof(PerlInterpreter) can come out different due to some fields being
added or removed; which means we have a live ABI hazard that we'd better
fix rather than continuing to sweep it under the rug.
However, it still seems like a bad idea to just absorb $Config{ccflags}
verbatim. In some environments Perl was built with a different compiler
that doesn't even use the same switch syntax. -D switch syntax is pretty
universal though, and absorbing Perl's -D switches really ought to be
enough to fix the problem.
Furthermore, Perl likes to inject stuff like -D_LARGEFILE_SOURCE and
-D_FILE_OFFSET_BITS=64 into $Config{ccflags}, which affect libc ABIs on
platforms where they're relevant. Adopting those seems dangerous too.
It's unclear whether a build wherein Perl and Postgres have different ideas
of sizeof(off_t) etc would work, or whether anyone would care about making
it work. But it's dead certain that having different stdio ABIs in
core Postgres and PL/Perl will not work; we've seen that movie before.
Therefore, let's also ignore -D switches for symbols beginning with
underscore. The symbols that we actually need to import should be the ones
mentioned in perl.h's PL_bincompat_options stanza, and none of those start
with underscore, so this seems likely to work. (If it turns out not to
work everywhere, we could consider intersecting the symbols mentioned in
PL_bincompat_options with the -D switches. But that will be much more
complicated, so let's try this way first.)
This will need to be back-patched, but first let's see what the
buildfarm makes of it.
Ashutosh Sharma, some adjustments by me
Discussion: https://postgr.es/m/CANFyU97OVQ3+Mzfmt3MhuUm5NwPU=-FtbNH5Eb7nZL9ua8=rcA@mail.gmail.com
2017-07-28 20:25:28 +02:00
|
|
|
}
|
2015-04-28 17:47:08 +02:00
|
|
|
}
|
|
|
|
|
2012-07-05 03:47:49 +02:00
|
|
|
$mf =
|
2015-04-25 14:52:03 +02:00
|
|
|
Project::read_file('src/backend/utils/mb/conversion_procs/Makefile');
|
2014-07-14 20:07:27 +02:00
|
|
|
$mf =~ s{\\\r?\n}{}g;
|
2012-07-05 03:47:49 +02:00
|
|
|
$mf =~ m{SUBDIRS\s*=\s*(.*)$}m
|
|
|
|
|| die 'Could not match in conversion makefile' . "\n";
|
|
|
|
foreach my $sub (split /\s+/, $1)
|
2012-06-10 21:20:04 +02:00
|
|
|
{
|
2015-04-25 14:52:03 +02:00
|
|
|
my $dir = 'src/backend/utils/mb/conversion_procs/' . $sub;
|
2014-07-14 20:07:21 +02:00
|
|
|
my $p = $solution->AddProject($sub, 'dll', 'conversion procs', $dir);
|
2015-04-25 14:52:03 +02:00
|
|
|
$p->AddFile("$dir/$sub.c"); # implicit source file
|
2012-06-10 21:20:04 +02:00
|
|
|
$p->AddReference($postgres);
|
|
|
|
}
|
|
|
|
|
2015-04-25 14:52:03 +02:00
|
|
|
$mf = Project::read_file('src/bin/scripts/Makefile');
|
2014-07-14 20:07:27 +02:00
|
|
|
$mf =~ s{\\\r?\n}{}g;
|
2012-07-05 03:47:49 +02:00
|
|
|
$mf =~ m{PROGRAMS\s*=\s*(.*)$}m
|
2015-04-25 14:52:03 +02:00
|
|
|
|| die 'Could not match in bin/scripts/Makefile' . "\n";
|
2012-07-05 03:47:49 +02:00
|
|
|
foreach my $prg (split /\s+/, $1)
|
2012-06-10 21:20:04 +02:00
|
|
|
{
|
2012-07-05 03:47:49 +02:00
|
|
|
my $proj = $solution->AddProject($prg, 'exe', 'bin');
|
|
|
|
$mf =~ m{$prg\s*:\s*(.*)$}m
|
|
|
|
|| die 'Could not find script define for $prg' . "\n";
|
|
|
|
my @files = split /\s+/, $1;
|
2012-06-10 21:20:04 +02:00
|
|
|
foreach my $f (@files)
|
|
|
|
{
|
|
|
|
$f =~ s/\.o$/\.c/;
|
2016-03-24 23:27:28 +01:00
|
|
|
if ($f =~ /\.c$/)
|
2012-06-10 21:20:04 +02:00
|
|
|
{
|
2015-04-25 14:52:03 +02:00
|
|
|
$proj->AddFile('src/bin/scripts/' . $f);
|
2012-06-10 21:20:04 +02:00
|
|
|
}
|
|
|
|
}
|
2015-04-25 14:52:03 +02:00
|
|
|
$proj->AddIncludeDir('src/interfaces/libpq');
|
2016-06-12 10:19:56 +02:00
|
|
|
$proj->AddReference($libpq, $libpgfeutils, $libpgcommon, $libpgport);
|
2015-04-25 14:52:03 +02:00
|
|
|
$proj->AddDirResourceFile('src/bin/scripts');
|
2013-03-24 16:27:20 +01:00
|
|
|
$proj->AddLibrary('ws2_32.lib');
|
2012-06-10 21:20:04 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
# Regression DLL and EXE
|
2012-07-05 03:47:49 +02:00
|
|
|
my $regress = $solution->AddProject('regress', 'dll', 'misc');
|
2015-04-25 14:52:03 +02:00
|
|
|
$regress->AddFile('src/test/regress/regress.c');
|
|
|
|
$regress->AddDirResourceFile('src/test/regress');
|
2012-06-10 21:20:04 +02:00
|
|
|
$regress->AddReference($postgres);
|
|
|
|
|
2012-07-05 03:47:49 +02:00
|
|
|
my $pgregress = $solution->AddProject('pg_regress', 'exe', 'misc');
|
2015-04-25 14:52:03 +02:00
|
|
|
$pgregress->AddFile('src/test/regress/pg_regress.c');
|
|
|
|
$pgregress->AddFile('src/test/regress/pg_regress_main.c');
|
|
|
|
$pgregress->AddIncludeDir('src/port');
|
2012-06-10 21:20:04 +02:00
|
|
|
$pgregress->AddDefine('HOST_TUPLE="i686-pc-win32vc"');
|
2014-12-25 19:52:03 +01:00
|
|
|
$pgregress->AddLibrary('ws2_32.lib');
|
2015-04-25 14:52:03 +02:00
|
|
|
$pgregress->AddDirResourceFile('src/test/regress');
|
2019-05-14 20:19:49 +02:00
|
|
|
$pgregress->AddReference($libpgcommon, $libpgport);
|
2012-06-10 21:20:04 +02:00
|
|
|
|
2017-02-09 22:23:46 +01:00
|
|
|
# fix up pg_waldump once it's been set up
|
2013-02-25 18:00:53 +01:00
|
|
|
# files symlinked on Unix are copied on windows
|
2017-02-09 22:23:46 +01:00
|
|
|
my $pg_waldump = AddSimpleFrontend('pg_waldump');
|
|
|
|
$pg_waldump->AddDefine('FRONTEND');
|
2015-04-25 14:52:03 +02:00
|
|
|
foreach my $xf (glob('src/backend/access/rmgrdesc/*desc.c'))
|
2013-02-25 18:00:53 +01:00
|
|
|
{
|
2017-02-09 22:23:46 +01:00
|
|
|
$pg_waldump->AddFile($xf);
|
2013-02-25 18:00:53 +01:00
|
|
|
}
|
2017-02-09 22:23:46 +01:00
|
|
|
$pg_waldump->AddFile('src/backend/access/transam/xlogreader.c');
|
2013-02-25 02:28:42 +01:00
|
|
|
|
2012-06-10 21:20:04 +02:00
|
|
|
$solution->Save();
|
|
|
|
return $solution->{vcver};
|
2007-03-17 14:50:42 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
#####################
|
|
|
|
# Utility functions #
|
|
|
|
#####################
|
|
|
|
|
|
|
|
# Add a simple frontend project (exe)
|
|
|
|
sub AddSimpleFrontend
|
|
|
|
{
|
2012-07-05 03:47:49 +02:00
|
|
|
my $n = shift;
|
|
|
|
my $uselibpq = shift;
|
2012-06-10 21:20:04 +02:00
|
|
|
|
2012-07-05 03:47:49 +02:00
|
|
|
my $p = $solution->AddProject($n, 'exe', 'bin');
|
2015-04-25 14:52:03 +02:00
|
|
|
$p->AddDir('src/bin/' . $n);
|
2016-03-24 20:55:44 +01:00
|
|
|
$p->AddReference($libpgfeutils, $libpgcommon, $libpgport);
|
2012-06-10 21:20:04 +02:00
|
|
|
if ($uselibpq)
|
|
|
|
{
|
2015-04-25 14:52:03 +02:00
|
|
|
$p->AddIncludeDir('src/interfaces/libpq');
|
2012-06-10 21:20:04 +02:00
|
|
|
$p->AddReference($libpq);
|
|
|
|
}
|
2015-03-11 14:21:01 +01:00
|
|
|
|
2015-04-09 14:15:39 +02:00
|
|
|
# Adjust module definition using frontend variables
|
2015-03-11 14:21:01 +01:00
|
|
|
AdjustFrontendProj($p);
|
|
|
|
|
2012-06-10 21:20:04 +02:00
|
|
|
return $p;
|
2007-03-17 14:50:42 +01:00
|
|
|
}
|
|
|
|
|
2015-04-28 17:47:08 +02:00
|
|
|
# Add a simple transform module
|
|
|
|
sub AddTransformModule
|
|
|
|
{
|
2018-04-25 20:00:19 +02:00
|
|
|
my $n = shift;
|
|
|
|
my $n_src = shift;
|
|
|
|
my $pl_proj_name = shift;
|
|
|
|
my $pl_src = shift;
|
|
|
|
my $type_name = shift;
|
|
|
|
my $type_src = shift;
|
2015-04-28 17:47:08 +02:00
|
|
|
|
2018-03-28 17:49:23 +02:00
|
|
|
my $type_proj = undef;
|
|
|
|
if ($type_name)
|
2015-04-28 17:47:08 +02:00
|
|
|
{
|
2018-03-28 17:49:23 +02:00
|
|
|
foreach my $proj (@{ $solution->{projects}->{'contrib'} })
|
2015-04-28 17:47:08 +02:00
|
|
|
{
|
2018-03-28 17:49:23 +02:00
|
|
|
if ($proj->{name} eq $type_name)
|
|
|
|
{
|
|
|
|
$type_proj = $proj;
|
|
|
|
last;
|
|
|
|
}
|
2015-04-28 17:47:08 +02:00
|
|
|
}
|
2018-03-28 17:49:23 +02:00
|
|
|
die "could not find base module $type_name for transform module $n"
|
|
|
|
if (!defined($type_proj));
|
2015-04-28 17:47:08 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
my $pl_proj = undef;
|
|
|
|
foreach my $proj (@{ $solution->{projects}->{'PLs'} })
|
|
|
|
{
|
|
|
|
if ($proj->{name} eq $pl_proj_name)
|
|
|
|
{
|
|
|
|
$pl_proj = $proj;
|
|
|
|
last;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
die "could not find PL $pl_proj_name for transform module $n"
|
2015-05-24 03:35:49 +02:00
|
|
|
if (!defined($pl_proj));
|
2015-04-28 17:47:08 +02:00
|
|
|
|
|
|
|
my $p = $solution->AddProject($n, 'dll', 'contrib', $n_src);
|
|
|
|
for my $file (glob("$n_src/*.c"))
|
|
|
|
{
|
|
|
|
$p->AddFile($file);
|
|
|
|
}
|
|
|
|
$p->AddReference($postgres);
|
|
|
|
|
|
|
|
# Add PL dependencies
|
|
|
|
$p->AddIncludeDir($pl_src);
|
|
|
|
$p->AddReference($pl_proj);
|
|
|
|
$p->AddIncludeDir($pl_proj->{includes});
|
2015-05-24 03:35:49 +02:00
|
|
|
foreach my $pl_lib (@{ $pl_proj->{libraries} })
|
2015-04-28 17:47:08 +02:00
|
|
|
{
|
|
|
|
$p->AddLibrary($pl_lib);
|
|
|
|
}
|
|
|
|
|
|
|
|
# Add base module dependencies
|
2018-03-28 17:49:23 +02:00
|
|
|
if ($type_proj)
|
2015-04-28 17:47:08 +02:00
|
|
|
{
|
2018-03-28 17:49:23 +02:00
|
|
|
$p->AddIncludeDir($type_src);
|
|
|
|
$p->AddIncludeDir($type_proj->{includes});
|
|
|
|
foreach my $type_lib (@{ $type_proj->{libraries} })
|
|
|
|
{
|
|
|
|
$p->AddLibrary($type_lib);
|
|
|
|
}
|
|
|
|
$p->AddReference($type_proj);
|
2015-04-28 17:47:08 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return $p;
|
|
|
|
}
|
|
|
|
|
2007-03-17 14:50:42 +01:00
|
|
|
# Add a simple contrib project
|
|
|
|
sub AddContrib
|
|
|
|
{
|
2015-04-16 20:17:26 +02:00
|
|
|
my $subdir = shift;
|
2015-05-24 03:35:49 +02:00
|
|
|
my $n = shift;
|
|
|
|
my $mf = Project::read_file("$subdir/$n/Makefile");
|
2012-06-10 21:20:04 +02:00
|
|
|
|
|
|
|
if ($mf =~ /^MODULE_big\s*=\s*(.*)$/mg)
|
|
|
|
{
|
|
|
|
my $dn = $1;
|
2015-05-24 03:35:49 +02:00
|
|
|
my $proj = $solution->AddProject($dn, 'dll', 'contrib', "$subdir/$n");
|
2012-06-10 21:20:04 +02:00
|
|
|
$proj->AddReference($postgres);
|
|
|
|
AdjustContribProj($proj);
|
|
|
|
}
|
|
|
|
elsif ($mf =~ /^MODULES\s*=\s*(.*)$/mg)
|
|
|
|
{
|
|
|
|
foreach my $mod (split /\s+/, $1)
|
|
|
|
{
|
2014-07-14 20:07:21 +02:00
|
|
|
my $proj =
|
2015-04-16 20:17:26 +02:00
|
|
|
$solution->AddProject($mod, 'dll', 'contrib', "$subdir/$n");
|
|
|
|
my $filename = $mod . '.c';
|
2015-04-25 14:52:03 +02:00
|
|
|
$proj->AddFile("$subdir/$n/$filename");
|
2012-06-10 21:20:04 +02:00
|
|
|
$proj->AddReference($postgres);
|
|
|
|
AdjustContribProj($proj);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
elsif ($mf =~ /^PROGRAM\s*=\s*(.*)$/mg)
|
|
|
|
{
|
2015-05-24 03:35:49 +02:00
|
|
|
my $proj = $solution->AddProject($1, 'exe', 'contrib', "$subdir/$n");
|
2012-06-10 21:20:04 +02:00
|
|
|
AdjustContribProj($proj);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
croak "Could not determine contrib module type for $n\n";
|
|
|
|
}
|
|
|
|
|
|
|
|
# Are there any output data files to build?
|
|
|
|
GenerateContribSqlFiles($n, $mf);
|
2018-05-27 15:08:42 +02:00
|
|
|
return;
|
2007-03-23 10:53:33 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
sub GenerateContribSqlFiles
|
|
|
|
{
|
2012-07-05 03:47:49 +02:00
|
|
|
my $n = shift;
|
2012-06-10 21:20:04 +02:00
|
|
|
my $mf = shift;
|
2014-07-14 20:07:27 +02:00
|
|
|
$mf =~ s{\\\r?\n}{}g;
|
2012-06-10 21:20:04 +02:00
|
|
|
if ($mf =~ /^DATA_built\s*=\s*(.*)$/mg)
|
|
|
|
{
|
|
|
|
my $l = $1;
|
|
|
|
|
|
|
|
# Strip out $(addsuffix) rules
|
|
|
|
if (index($l, '$(addsuffix ') >= 0)
|
|
|
|
{
|
|
|
|
my $pcount = 0;
|
|
|
|
my $i;
|
|
|
|
for ($i = index($l, '$(addsuffix ') + 12; $i < length($l); $i++)
|
|
|
|
{
|
|
|
|
$pcount++ if (substr($l, $i, 1) eq '(');
|
|
|
|
$pcount-- if (substr($l, $i, 1) eq ')');
|
2012-07-05 03:47:49 +02:00
|
|
|
last if ($pcount < 0);
|
2012-06-10 21:20:04 +02:00
|
|
|
}
|
2012-07-05 03:47:49 +02:00
|
|
|
$l =
|
|
|
|
substr($l, 0, index($l, '$(addsuffix ')) . substr($l, $i + 1);
|
2012-06-10 21:20:04 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
foreach my $d (split /\s+/, $l)
|
|
|
|
{
|
2012-07-05 03:47:49 +02:00
|
|
|
my $in = "$d.in";
|
2012-06-10 21:20:04 +02:00
|
|
|
my $out = "$d";
|
|
|
|
|
|
|
|
if (Solution::IsNewer("contrib/$n/$out", "contrib/$n/$in"))
|
|
|
|
{
|
|
|
|
print "Building $out from $in (contrib/$n)...\n";
|
|
|
|
my $cont = Project::read_file("contrib/$n/$in");
|
2012-07-05 03:47:49 +02:00
|
|
|
my $dn = $out;
|
2018-04-25 20:00:19 +02:00
|
|
|
$dn =~ s/\.sql$//;
|
2012-06-10 21:20:04 +02:00
|
|
|
$cont =~ s/MODULE_PATHNAME/\$libdir\/$dn/g;
|
|
|
|
my $o;
|
2017-03-27 04:24:13 +02:00
|
|
|
open($o, '>', "contrib/$n/$out")
|
2012-06-10 21:20:04 +02:00
|
|
|
|| croak "Could not write to contrib/$n/$d";
|
|
|
|
print $o $cont;
|
|
|
|
close($o);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2018-05-27 15:08:42 +02:00
|
|
|
return;
|
2007-03-17 14:50:42 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
sub AdjustContribProj
|
|
|
|
{
|
2012-06-10 21:20:04 +02:00
|
|
|
my $proj = shift;
|
2015-03-11 14:21:01 +01:00
|
|
|
AdjustModule(
|
|
|
|
$proj, $contrib_defines,
|
|
|
|
\@contrib_uselibpq, \@contrib_uselibpgport,
|
|
|
|
\@contrib_uselibpgcommon, $contrib_extralibs,
|
|
|
|
$contrib_extrasource, $contrib_extraincludes);
|
2018-05-27 15:08:42 +02:00
|
|
|
return;
|
2015-03-11 14:21:01 +01:00
|
|
|
}
|
2012-06-10 21:20:04 +02:00
|
|
|
|
2015-03-11 14:21:01 +01:00
|
|
|
sub AdjustFrontendProj
|
|
|
|
{
|
|
|
|
my $proj = shift;
|
2015-05-24 03:35:49 +02:00
|
|
|
AdjustModule(
|
|
|
|
$proj, $frontend_defines,
|
|
|
|
\@frontend_uselibpq, \@frontend_uselibpgport,
|
|
|
|
\@frontend_uselibpgcommon, $frontend_extralibs,
|
|
|
|
$frontend_extrasource, $frontend_extraincludes);
|
2018-05-27 15:08:42 +02:00
|
|
|
return;
|
2015-03-11 14:21:01 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
sub AdjustModule
|
|
|
|
{
|
|
|
|
my $proj = shift;
|
|
|
|
my $module_defines = shift;
|
|
|
|
my $module_uselibpq = shift;
|
|
|
|
my $module_uselibpgport = shift;
|
|
|
|
my $module_uselibpgcommon = shift;
|
|
|
|
my $module_extralibs = shift;
|
|
|
|
my $module_extrasource = shift;
|
|
|
|
my $module_extraincludes = shift;
|
|
|
|
my $n = $proj->{name};
|
|
|
|
|
|
|
|
if ($module_defines->{$n})
|
2012-06-10 21:20:04 +02:00
|
|
|
{
|
2015-03-11 14:21:01 +01:00
|
|
|
foreach my $d ($module_defines->{$n})
|
2012-06-10 21:20:04 +02:00
|
|
|
{
|
|
|
|
$proj->AddDefine($d);
|
|
|
|
}
|
|
|
|
}
|
2015-03-11 14:21:01 +01:00
|
|
|
if (grep { /^$n$/ } @{$module_uselibpq})
|
2012-06-10 21:20:04 +02:00
|
|
|
{
|
|
|
|
$proj->AddIncludeDir('src\interfaces\libpq');
|
|
|
|
$proj->AddReference($libpq);
|
|
|
|
}
|
2015-03-11 14:21:01 +01:00
|
|
|
if (grep { /^$n$/ } @{$module_uselibpgport})
|
2012-06-10 21:20:04 +02:00
|
|
|
{
|
|
|
|
$proj->AddReference($libpgport);
|
|
|
|
}
|
2015-03-11 14:21:01 +01:00
|
|
|
if (grep { /^$n$/ } @{$module_uselibpgcommon})
|
Create libpgcommon, and move pg_malloc et al to it
libpgcommon is a new static library to allow sharing code among the
various frontend programs and backend; this lets us eliminate duplicate
implementations of common routines. We avoid libpgport, because that's
intended as a place for porting issues; per discussion, it seems better
to keep them separate.
The first use case, and the only implemented by this patch, is pg_malloc
and friends, which many frontend programs were already using.
At the same time, we can use this to provide palloc emulation functions
for the frontend; this way, some palloc-using files in the backend can
also be used by the frontend cleanly. To do this, we change palloc() in
the backend to be a function instead of a macro on top of
MemoryContextAlloc(). This was previously believed to cause loss of
performance, but this implementation has been tweaked by Tom and Andres
so that on modern compilers it provides a slight improvement over the
previous one.
This lets us clean up some places that were already with
localized hacks.
Most of the pg_malloc/palloc changes in this patch were authored by
Andres Freund. Zoltán Böszörményi also independently provided a form of
that. libpgcommon infrastructure was authored by Álvaro.
2013-02-12 14:33:40 +01:00
|
|
|
{
|
|
|
|
$proj->AddReference($libpgcommon);
|
|
|
|
}
|
2015-03-11 14:21:01 +01:00
|
|
|
if ($module_extralibs->{$n})
|
2012-06-10 21:20:04 +02:00
|
|
|
{
|
2015-03-11 14:21:01 +01:00
|
|
|
foreach my $l (@{ $module_extralibs->{$n} })
|
2012-06-10 21:20:04 +02:00
|
|
|
{
|
|
|
|
$proj->AddLibrary($l);
|
|
|
|
}
|
|
|
|
}
|
2015-03-11 14:21:01 +01:00
|
|
|
if ($module_extraincludes->{$n})
|
2012-06-10 21:20:04 +02:00
|
|
|
{
|
2015-03-11 14:21:01 +01:00
|
|
|
foreach my $i (@{ $module_extraincludes->{$n} })
|
2012-06-10 21:20:04 +02:00
|
|
|
{
|
|
|
|
$proj->AddIncludeDir($i);
|
|
|
|
}
|
|
|
|
}
|
2015-03-11 14:21:01 +01:00
|
|
|
if ($module_extrasource->{$n})
|
2012-06-10 21:20:04 +02:00
|
|
|
{
|
2015-03-11 14:21:01 +01:00
|
|
|
foreach my $i (@{ $module_extrasource->{$n} })
|
|
|
|
{
|
|
|
|
print "Files $i\n";
|
|
|
|
$proj->AddFile($i);
|
|
|
|
}
|
2012-06-10 21:20:04 +02:00
|
|
|
}
|
2018-05-27 15:08:42 +02:00
|
|
|
return;
|
2007-03-17 14:50:42 +01:00
|
|
|
}
|
|
|
|
|
2017-12-09 03:06:05 +01:00
|
|
|
END
|
|
|
|
{
|
|
|
|
unlink @unlink_on_exit;
|
|
|
|
}
|
|
|
|
|
2007-03-17 14:50:42 +01:00
|
|
|
1;
|