LIBS_including_readline="$LIBS"

LIBS=`echo "$LIBS" | sed -e 's/-ledit//g' -e 's/-lreadline//g'`

for ac_func in backtrace_symbols copyfile getifaddrs getpeerucred inet_pton kqueue mbstowcs_l memset_s posix_fallocate ppoll pthread_is_threaded_np setproctitle setproctitle_fast strchrnul strsignal syncfs sync_file_range uselocale wcstombs_l

for ac_func in backtrace_symbols copyfilecopy_file_rangegetifaddrs getpeerucred inet_pton kqueue mbstowcs_l memset_s posix_fallocate ppoll pthread_is_threaded_np setproctitle setproctitle_fast strchrnul strsignal syncfs sync_file_range uselocale wcstombs_l

do :

as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh`

ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var"

</listitem>

</varlistentry>

<varlistentry>

<term><option>--copy-file-range</option></term>

<listitem>

<para>

Use the <function>copy_file_range</function> system call for efficient

copying. On some file systems this gives results similar to

<option>--clone</option>, sharing physical disk blocks, while on others

it may still copy blocks, but do so via an optimized path. At present,

it is supported on Linux and FreeBSD.

</para>

</listitem>

</varlistentry>

<varlistentry>

<term><option>-?</option></term>

<term><option>--help</option></term>

['backtrace_symbols', {'dependencies': [execinfo_dep]}],

['clock_gettime', {'dependencies': [rt_dep],'define':false}],

['copyfile'],

['copy_file_range'],

See DETAILS below for more information about creation of the dump.

You can also test the different transfer modes (--copy, --link,

--clone) by setting the environment variable PG_TEST_PG_UPGRADE_MODE

to the respective command-line option, like

--clone, --copy-file-range) by setting the environment variable

PG_TEST_PG_UPGRADE_MODEto the respective command-line option, like

make check PG_TEST_PG_UPGRADE_MODE=--link

break;

caseTRANSFER_MODE_COPY:

break;

caseTRANSFER_MODE_COPY_FILE_RANGE:

check_copy_file_range();

break;

caseTRANSFER_MODE_LINK:

check_hard_link();

break;

}

copyFileByRange(constchar*src,constchar*dst,

constchar*schemaName,constchar*relName)

{

intsrc_fd;

intdest_fd;

ssize_tnbytes;

if ((src_fd=open(src,O_RDONLY |PG_BINARY,0))<0)

pg_fatal("error while copying relation \"%s.%s\": could not open file \"%s\": %s",

schemaName,relName,src,strerror(errno));

if ((dest_fd=open(dst,O_RDWR |O_CREAT |O_EXCL |PG_BINARY,

pg_file_create_mode))<0)

pg_fatal("error while copying relation \"%s.%s\": could not create file \"%s\": %s",

schemaName,relName,dst,strerror(errno));

{

nbytes=copy_file_range(src_fd,NULL,dest_fd,NULL,SSIZE_MAX,0);

if (nbytes<0)

pg_fatal("error while copying relation \"%s.%s\": could not copy file range from \"%s\" to \"%s\": %s",

schemaName,relName,src,dst,strerror(errno));

}

while (nbytes>0);

close(src_fd);

close(dest_fd);

}

unlink(new_link_file);

}

check_copy_file_range(void)

{

charexisting_file[MAXPGPATH];

charnew_link_file[MAXPGPATH];

snprintf(existing_file,sizeof(existing_file),"%s/PG_VERSION",old_cluster.pgdata);

snprintf(new_link_file,sizeof(new_link_file),"%s/PG_VERSION.copy_file_range_test",new_cluster.pgdata);

unlink(new_link_file);/* might fail */

#if defined(HAVE_COPY_FILE_RANGE)

{

intsrc_fd;

intdest_fd;

if ((src_fd=open(existing_file,O_RDONLY |PG_BINARY,0))<0)

pg_fatal("could not open file \"%s\": %s",

existing_file,strerror(errno));

if ((dest_fd=open(new_link_file,O_RDWR |O_CREAT |O_EXCL |PG_BINARY,

pg_file_create_mode))<0)

pg_fatal("could not create file \"%s\": %s",

new_link_file,strerror(errno));

if (copy_file_range(src_fd,NULL,dest_fd,NULL,SSIZE_MAX,0)<0)

pg_fatal("could not copy file range between old and new data directories: %s",

strerror(errno));

close(src_fd);

close(dest_fd);

}

pg_fatal("copy_file_range not supported on this platform");

unlink(new_link_file);

}

check_hard_link(void)

{

{"verbose",no_argument,NULL,'v'},

{"clone",no_argument,NULL,1},

{"copy",no_argument,NULL,2},

{"sync-method",required_argument,NULL,3},

{"copy-file-range",no_argument,NULL,3},

{"sync-method",required_argument,NULL,4},

{NULL,0,NULL,0}

};

break;

case3:

user_opts.transfer_mode=TRANSFER_MODE_COPY_FILE_RANGE;

break;

case4:

if (!parse_sync_method(optarg,&unused))

exit(1);

user_opts.sync_method=pg_strdup(optarg);

printf(_(" -V, --version display version information, then exit\n"));

printf(_(" --clone clone instead of copying files to new cluster\n"));

printf(_(" --copy copy files to new cluster (default)\n"));

printf(_(" --copy-file-range copy files to new cluster with copy_file_range\n"));

printf(_(" --sync-method=METHOD set method for syncing files to disk\n"));

printf(_(" -?, --help show this help, then exit\n"));

printf(_("\n"

{

TRANSFER_MODE_CLONE,

TRANSFER_MODE_COPY,

TRANSFER_MODE_COPY_FILE_RANGE,

TRANSFER_MODE_LINK,

}transferMode;

constchar*schemaName,constchar*relName);

voidcopyFile(constchar*src,constchar*dst,

constchar*schemaName,constchar*relName);

voidcopyFileByRange(constchar*src,constchar*dst,

constchar*schemaName,constchar*relName);

voidlinkFile(constchar*src,constchar*dst,

constchar*schemaName,constchar*relName);

voidrewriteVisibilityMap(constchar*fromfile,constchar*tofile,

constchar*schemaName,constchar*relName);

voidcheck_file_clone(void);

voidcheck_copy_file_range(void);

voidcheck_hard_link(void);

caseTRANSFER_MODE_COPY:

prep_status_progress("Copying user relation files");

break;

caseTRANSFER_MODE_COPY_FILE_RANGE:

prep_status_progress("Copying user relation files with copy_file_range");

break;

caseTRANSFER_MODE_LINK:

prep_status_progress("Linking user relation files");

break;

old_file,new_file);

copyFile(old_file,new_file,map->nspname,map->relname);

break;

caseTRANSFER_MODE_COPY_FILE_RANGE:

pg_log(PG_VERBOSE,"copying \"%s\" to \"%s\" with copy_file_range",

old_file,new_file);

copyFileByRange(old_file,new_file,map->nspname,map->relname);

break;

caseTRANSFER_MODE_LINK:

pg_log(PG_VERBOSE,"linking \"%s\" to \"%s\"",

old_file,new_file);