sparc64 performance problems. Submitted by: Oleg Moskalenko <oleg.moskalenko@citrix.com> Tested by: trasz
1341 lines
28 KiB
C
1341 lines
28 KiB
C
/*-
|
|
* Copyright (C) 2009 Gabor Kovesdan <gabor@FreeBSD.org>
|
|
* Copyright (C) 2012 Oleg Moskalenko <oleg.moskalenko@citrix.com>
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*/
|
|
|
|
#include <sys/cdefs.h>
|
|
__FBSDID("$FreeBSD$");
|
|
|
|
#include <sys/stat.h>
|
|
#include <sys/sysctl.h>
|
|
#include <sys/types.h>
|
|
|
|
#include <err.h>
|
|
#include <errno.h>
|
|
#include <getopt.h>
|
|
#include <limits.h>
|
|
#include <locale.h>
|
|
#include <md5.h>
|
|
#include <regex.h>
|
|
#include <signal.h>
|
|
#include <stdbool.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
#include <wchar.h>
|
|
#include <wctype.h>
|
|
|
|
#include "coll.h"
|
|
#include "file.h"
|
|
#include "sort.h"
|
|
|
|
#ifndef WITHOUT_NLS
|
|
#include <nl_types.h>
|
|
nl_catd catalog;
|
|
#endif
|
|
|
|
#define OPTIONS "bcCdfghik:Mmno:RrsS:t:T:uVz"
|
|
|
|
#define DEFAULT_RANDOM_SORT_SEED_FILE ("/dev/random")
|
|
#define MAX_DEFAULT_RANDOM_SEED_DATA_SIZE (1024)
|
|
|
|
static bool need_random;
|
|
static const char *random_source = DEFAULT_RANDOM_SORT_SEED_FILE;
|
|
static const void *random_seed;
|
|
static size_t random_seed_size;
|
|
|
|
MD5_CTX md5_ctx;
|
|
|
|
/*
|
|
* Default messages to use when NLS is disabled or no catalogue
|
|
* is found.
|
|
*/
|
|
const char *nlsstr[] = { "",
|
|
/* 1*/"mutually exclusive flags",
|
|
/* 2*/"extra argument not allowed with -c",
|
|
/* 3*/"Unknown feature",
|
|
/* 4*/"Wrong memory buffer specification",
|
|
/* 5*/"0 field in key specs",
|
|
/* 6*/"0 column in key specs",
|
|
/* 7*/"Wrong file mode",
|
|
/* 8*/"Cannot open file for reading",
|
|
/* 9*/"Radix sort cannot be used with these sort options",
|
|
/*10*/"The chosen sort method cannot be used with stable and/or unique sort",
|
|
/*11*/"Invalid key position",
|
|
/*12*/"Usage: %s [-bcCdfigMmnrsuz] [-kPOS1[,POS2] ... ] "
|
|
"[+POS1 [-POS2]] [-S memsize] [-T tmpdir] [-t separator] "
|
|
"[-o outfile] [--batch-size size] [--files0-from file] "
|
|
"[--heapsort] [--mergesort] [--radixsort] [--qsort] "
|
|
"[--mmap] "
|
|
#if defined(SORT_THREADS)
|
|
"[--parallel thread_no] "
|
|
#endif
|
|
"[--human-numeric-sort] "
|
|
"[--version-sort] [--random-sort [--random-source file]] "
|
|
"[--compress-program program] [file ...]\n" };
|
|
|
|
struct sort_opts sort_opts_vals;
|
|
|
|
bool debug_sort;
|
|
bool need_hint;
|
|
|
|
#if defined(SORT_THREADS)
|
|
unsigned int ncpu = 1;
|
|
size_t nthreads = 1;
|
|
#endif
|
|
|
|
static bool gnusort_numeric_compatibility;
|
|
|
|
static struct sort_mods default_sort_mods_object;
|
|
struct sort_mods * const default_sort_mods = &default_sort_mods_object;
|
|
|
|
static bool print_symbols_on_debug;
|
|
|
|
/*
|
|
* Arguments from file (when file0-from option is used:
|
|
*/
|
|
static size_t argc_from_file0 = (size_t)-1;
|
|
static char **argv_from_file0;
|
|
|
|
/*
|
|
* Placeholder symbols for options which have no single-character equivalent
|
|
*/
|
|
enum
|
|
{
|
|
SORT_OPT = CHAR_MAX + 1,
|
|
HELP_OPT,
|
|
FF_OPT,
|
|
BS_OPT,
|
|
VERSION_OPT,
|
|
DEBUG_OPT,
|
|
#if defined(SORT_THREADS)
|
|
PARALLEL_OPT,
|
|
#endif
|
|
RANDOMSOURCE_OPT,
|
|
COMPRESSPROGRAM_OPT,
|
|
QSORT_OPT,
|
|
MERGESORT_OPT,
|
|
HEAPSORT_OPT,
|
|
RADIXSORT_OPT,
|
|
MMAP_OPT
|
|
};
|
|
|
|
#define NUMBER_OF_MUTUALLY_EXCLUSIVE_FLAGS 6
|
|
static const char mutually_exclusive_flags[NUMBER_OF_MUTUALLY_EXCLUSIVE_FLAGS] = { 'M', 'n', 'g', 'R', 'h', 'V' };
|
|
|
|
static struct option long_options[] = {
|
|
{ "batch-size", required_argument, NULL, BS_OPT },
|
|
{ "buffer-size", required_argument, NULL, 'S' },
|
|
{ "check", optional_argument, NULL, 'c' },
|
|
{ "check=silent|quiet", optional_argument, NULL, 'C' },
|
|
{ "compress-program", required_argument, NULL, COMPRESSPROGRAM_OPT },
|
|
{ "debug", no_argument, NULL, DEBUG_OPT },
|
|
{ "dictionary-order", no_argument, NULL, 'd' },
|
|
{ "field-separator", required_argument, NULL, 't' },
|
|
{ "files0-from", required_argument, NULL, FF_OPT },
|
|
{ "general-numeric-sort", no_argument, NULL, 'g' },
|
|
{ "heapsort", no_argument, NULL, HEAPSORT_OPT },
|
|
{ "help",no_argument, NULL, HELP_OPT },
|
|
{ "human-numeric-sort", no_argument, NULL, 'h' },
|
|
{ "ignore-leading-blanks", no_argument, NULL, 'b' },
|
|
{ "ignore-case", no_argument, NULL, 'f' },
|
|
{ "ignore-nonprinting", no_argument, NULL, 'i' },
|
|
{ "key", required_argument, NULL, 'k' },
|
|
{ "merge", no_argument, NULL, 'm' },
|
|
{ "mergesort", no_argument, NULL, MERGESORT_OPT },
|
|
{ "mmap", no_argument, NULL, MMAP_OPT },
|
|
{ "month-sort", no_argument, NULL, 'M' },
|
|
{ "numeric-sort", no_argument, NULL, 'n' },
|
|
{ "output", required_argument, NULL, 'o' },
|
|
#if defined(SORT_THREADS)
|
|
{ "parallel", required_argument, NULL, PARALLEL_OPT },
|
|
#endif
|
|
{ "qsort", no_argument, NULL, QSORT_OPT },
|
|
{ "radixsort", no_argument, NULL, RADIXSORT_OPT },
|
|
{ "random-sort", no_argument, NULL, 'R' },
|
|
{ "random-source", required_argument, NULL, RANDOMSOURCE_OPT },
|
|
{ "reverse", no_argument, NULL, 'r' },
|
|
{ "sort", required_argument, NULL, SORT_OPT },
|
|
{ "stable", no_argument, NULL, 's' },
|
|
{ "temporary-directory",required_argument, NULL, 'T' },
|
|
{ "unique", no_argument, NULL, 'u' },
|
|
{ "version", no_argument, NULL, VERSION_OPT },
|
|
{ "version-sort",no_argument, NULL, 'V' },
|
|
{ "zero-terminated", no_argument, NULL, 'z' },
|
|
{ NULL, no_argument, NULL, 0 }
|
|
};
|
|
|
|
void fix_obsolete_keys(int *argc, char **argv);
|
|
|
|
/*
|
|
* Check where sort modifier is present
|
|
*/
|
|
static bool
|
|
sort_modifier_empty(struct sort_mods *sm)
|
|
{
|
|
|
|
if (sm == NULL)
|
|
return (true);
|
|
return (!(sm->Mflag || sm->Vflag || sm->nflag || sm->gflag ||
|
|
sm->rflag || sm->Rflag || sm->hflag || sm->dflag || sm->fflag));
|
|
}
|
|
|
|
/*
|
|
* Print out usage text.
|
|
*/
|
|
static void
|
|
usage(bool opt_err)
|
|
{
|
|
struct option *o;
|
|
FILE *out;
|
|
|
|
out = stdout;
|
|
o = &(long_options[0]);
|
|
|
|
if (opt_err)
|
|
out = stderr;
|
|
fprintf(out, getstr(12), getprogname());
|
|
if (opt_err)
|
|
exit(2);
|
|
exit(0);
|
|
}
|
|
|
|
/*
|
|
* Read input file names from a file (file0-from option).
|
|
*/
|
|
static void
|
|
read_fns_from_file0(const char *fn)
|
|
{
|
|
if (fn) {
|
|
struct file0_reader f0r;
|
|
FILE *f;
|
|
|
|
f = fopen(fn, "r");
|
|
if (f == NULL)
|
|
err(2, NULL);
|
|
|
|
memset(&f0r, 0, sizeof(f0r));
|
|
f0r.f = f;
|
|
|
|
while (!feof(f)) {
|
|
char *line = read_file0_line(&f0r);
|
|
|
|
if (line && *line) {
|
|
if (argc_from_file0 == (size_t)-1)
|
|
argc_from_file0 = 0;
|
|
++argc_from_file0;
|
|
argv_from_file0 = sort_realloc(argv_from_file0,
|
|
argc_from_file0 * sizeof(char *));
|
|
if (argv_from_file0 == NULL)
|
|
err(2, NULL);
|
|
argv_from_file0[argc_from_file0 - 1] =
|
|
sort_strdup(line);
|
|
}
|
|
}
|
|
closefile(f, fn);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Check how much RAM is available for the sort.
|
|
*/
|
|
static void
|
|
set_hw_params(void)
|
|
{
|
|
#if defined(SORT_THREADS)
|
|
size_t ncpusz;
|
|
#endif
|
|
unsigned int pages, psize;
|
|
size_t psz, pszsz;
|
|
|
|
pages = psize = 0;
|
|
#if defined(SORT_THREADS)
|
|
ncpu = 1;
|
|
ncpusz = sizeof(size_t);
|
|
#endif
|
|
psz = sizeof(pages);
|
|
pszsz = sizeof(psize);
|
|
|
|
if (sysctlbyname("vm.stats.vm.v_free_count", &pages, &psz,
|
|
NULL, 0) < 0) {
|
|
perror("vm.stats.vm.v_free_count");
|
|
return;
|
|
}
|
|
if (sysctlbyname("vm.stats.vm.v_page_size", &psize, &pszsz,
|
|
NULL, 0) < 0) {
|
|
perror("vm.stats.vm.v_page_size");
|
|
return;
|
|
}
|
|
#if defined(SORT_THREADS)
|
|
if (sysctlbyname("hw.ncpu", &ncpu, &ncpusz,
|
|
NULL, 0) < 0)
|
|
ncpu = 1;
|
|
else if(ncpu > 32)
|
|
ncpu = 32;
|
|
|
|
nthreads = ncpu;
|
|
#endif
|
|
|
|
free_memory = (unsigned long long) pages * (unsigned long long) psize;
|
|
available_free_memory = (free_memory * 9) / 10;
|
|
|
|
if (available_free_memory < 1024)
|
|
available_free_memory = 1024;
|
|
}
|
|
|
|
/*
|
|
* Convert "plain" symbol to wide symbol, with default value.
|
|
*/
|
|
static void
|
|
conv_mbtowc(wchar_t *wc, const char *c, const wchar_t def)
|
|
{
|
|
|
|
if (wc && c) {
|
|
int res;
|
|
|
|
res = mbtowc(wc, c, MB_CUR_MAX);
|
|
if (res < 1)
|
|
*wc = def;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Set current locale symbols.
|
|
*/
|
|
static void
|
|
set_locale(void)
|
|
{
|
|
struct lconv *lc;
|
|
const char *locale;
|
|
|
|
setlocale(LC_ALL, "");
|
|
|
|
lc = localeconv();
|
|
|
|
if (lc) {
|
|
/* obtain LC_NUMERIC info */
|
|
/* Convert to wide char form */
|
|
conv_mbtowc(&symbol_decimal_point, lc->decimal_point,
|
|
symbol_decimal_point);
|
|
conv_mbtowc(&symbol_thousands_sep, lc->thousands_sep,
|
|
symbol_thousands_sep);
|
|
conv_mbtowc(&symbol_positive_sign, lc->positive_sign,
|
|
symbol_positive_sign);
|
|
conv_mbtowc(&symbol_negative_sign, lc->negative_sign,
|
|
symbol_negative_sign);
|
|
}
|
|
|
|
if (getenv("GNUSORT_NUMERIC_COMPATIBILITY"))
|
|
gnusort_numeric_compatibility = true;
|
|
|
|
locale = setlocale(LC_COLLATE, NULL);
|
|
|
|
if (locale) {
|
|
char *tmpl;
|
|
const char *cclocale;
|
|
|
|
tmpl = sort_strdup(locale);
|
|
cclocale = setlocale(LC_COLLATE, "C");
|
|
if (cclocale && !strcmp(cclocale, tmpl))
|
|
byte_sort = true;
|
|
else {
|
|
const char *pclocale;
|
|
|
|
pclocale = setlocale(LC_COLLATE, "POSIX");
|
|
if (pclocale && !strcmp(pclocale, tmpl))
|
|
byte_sort = true;
|
|
}
|
|
setlocale(LC_COLLATE, tmpl);
|
|
sort_free(tmpl);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Set directory temporary files.
|
|
*/
|
|
static void
|
|
set_tmpdir(void)
|
|
{
|
|
char *td;
|
|
|
|
td = getenv("TMPDIR");
|
|
if (td != NULL)
|
|
tmpdir = sort_strdup(td);
|
|
}
|
|
|
|
/*
|
|
* Parse -S option.
|
|
*/
|
|
static unsigned long long
|
|
parse_memory_buffer_value(const char *value)
|
|
{
|
|
|
|
if (value == NULL)
|
|
return (available_free_memory);
|
|
else {
|
|
char *endptr;
|
|
unsigned long long membuf;
|
|
|
|
endptr = NULL;
|
|
errno = 0;
|
|
membuf = strtoll(value, &endptr, 10);
|
|
|
|
if (errno != 0) {
|
|
warn("%s",getstr(4));
|
|
membuf = available_free_memory;
|
|
} else {
|
|
switch (*endptr){
|
|
case 'Y':
|
|
membuf *= 1024;
|
|
/* FALLTHROUGH */
|
|
case 'Z':
|
|
membuf *= 1024;
|
|
/* FALLTHROUGH */
|
|
case 'E':
|
|
membuf *= 1024;
|
|
/* FALLTHROUGH */
|
|
case 'P':
|
|
membuf *= 1024;
|
|
/* FALLTHROUGH */
|
|
case 'T':
|
|
membuf *= 1024;
|
|
/* FALLTHROUGH */
|
|
case 'G':
|
|
membuf *= 1024;
|
|
/* FALLTHROUGH */
|
|
case 'M':
|
|
membuf *= 1024;
|
|
/* FALLTHROUGH */
|
|
case '\0':
|
|
case 'K':
|
|
membuf *= 1024;
|
|
/* FALLTHROUGH */
|
|
case 'b':
|
|
break;
|
|
case '%':
|
|
membuf = (available_free_memory * membuf) /
|
|
100;
|
|
break;
|
|
default:
|
|
fprintf(stderr, "%s: %s\n", strerror(EINVAL),
|
|
optarg);
|
|
membuf = available_free_memory;
|
|
}
|
|
}
|
|
return (membuf);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Signal handler that clears the temporary files.
|
|
*/
|
|
static void
|
|
sig_handler(int sig __unused, siginfo_t *siginfo __unused,
|
|
void *context __unused)
|
|
{
|
|
|
|
clear_tmp_files();
|
|
exit(-1);
|
|
}
|
|
|
|
/*
|
|
* Set signal handler on panic signals.
|
|
*/
|
|
static void
|
|
set_signal_handler(void)
|
|
{
|
|
struct sigaction sa;
|
|
|
|
memset(&sa, 0, sizeof(sa));
|
|
sa.sa_sigaction = &sig_handler;
|
|
sa.sa_flags = SA_SIGINFO;
|
|
|
|
if (sigaction(SIGTERM, &sa, NULL) < 0) {
|
|
perror("sigaction");
|
|
return;
|
|
}
|
|
if (sigaction(SIGHUP, &sa, NULL) < 0) {
|
|
perror("sigaction");
|
|
return;
|
|
}
|
|
if (sigaction(SIGINT, &sa, NULL) < 0) {
|
|
perror("sigaction");
|
|
return;
|
|
}
|
|
if (sigaction(SIGQUIT, &sa, NULL) < 0) {
|
|
perror("sigaction");
|
|
return;
|
|
}
|
|
if (sigaction(SIGABRT, &sa, NULL) < 0) {
|
|
perror("sigaction");
|
|
return;
|
|
}
|
|
if (sigaction(SIGBUS, &sa, NULL) < 0) {
|
|
perror("sigaction");
|
|
return;
|
|
}
|
|
if (sigaction(SIGSEGV, &sa, NULL) < 0) {
|
|
perror("sigaction");
|
|
return;
|
|
}
|
|
if (sigaction(SIGUSR1, &sa, NULL) < 0) {
|
|
perror("sigaction");
|
|
return;
|
|
}
|
|
if (sigaction(SIGUSR2, &sa, NULL) < 0) {
|
|
perror("sigaction");
|
|
return;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Print "unknown" message and exit with status 2.
|
|
*/
|
|
static void
|
|
unknown(const char *what)
|
|
{
|
|
|
|
errx(2, "%s: %s", getstr(3), what);
|
|
}
|
|
|
|
/*
|
|
* Check whether contradictory input options are used.
|
|
*/
|
|
static void
|
|
check_mutually_exclusive_flags(char c, bool *mef_flags)
|
|
{
|
|
int fo_index, mec;
|
|
bool found_others, found_this;
|
|
|
|
found_others = found_this =false;
|
|
fo_index = 0;
|
|
|
|
for (int i = 0; i < NUMBER_OF_MUTUALLY_EXCLUSIVE_FLAGS; i++) {
|
|
mec = mutually_exclusive_flags[i];
|
|
|
|
if (mec != c) {
|
|
if (mef_flags[i]) {
|
|
if (found_this)
|
|
errx(1, "%c:%c: %s", c, mec, getstr(1));
|
|
found_others = true;
|
|
fo_index = i;
|
|
}
|
|
} else {
|
|
if (found_others)
|
|
errx(1, "%c:%c: %s", c, mutually_exclusive_flags[fo_index], getstr(1));
|
|
mef_flags[i] = true;
|
|
found_this = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Initialise sort opts data.
|
|
*/
|
|
static void
|
|
set_sort_opts(void)
|
|
{
|
|
|
|
memset(&default_sort_mods_object, 0,
|
|
sizeof(default_sort_mods_object));
|
|
memset(&sort_opts_vals, 0, sizeof(sort_opts_vals));
|
|
default_sort_mods_object.func =
|
|
get_sort_func(&default_sort_mods_object);
|
|
}
|
|
|
|
/*
|
|
* Set a sort modifier on a sort modifiers object.
|
|
*/
|
|
static bool
|
|
set_sort_modifier(struct sort_mods *sm, int c)
|
|
{
|
|
|
|
if (sm) {
|
|
switch (c){
|
|
case 'b':
|
|
sm->bflag = true;
|
|
break;
|
|
case 'd':
|
|
sm->dflag = true;
|
|
break;
|
|
case 'f':
|
|
sm->fflag = true;
|
|
break;
|
|
case 'g':
|
|
sm->gflag = true;
|
|
need_hint = true;
|
|
break;
|
|
case 'i':
|
|
sm->iflag = true;
|
|
break;
|
|
case 'R':
|
|
sm->Rflag = true;
|
|
need_random = true;
|
|
break;
|
|
case 'M':
|
|
initialise_months();
|
|
sm->Mflag = true;
|
|
need_hint = true;
|
|
break;
|
|
case 'n':
|
|
sm->nflag = true;
|
|
need_hint = true;
|
|
print_symbols_on_debug = true;
|
|
break;
|
|
case 'r':
|
|
sm->rflag = true;
|
|
break;
|
|
case 'V':
|
|
sm->Vflag = true;
|
|
break;
|
|
case 'h':
|
|
sm->hflag = true;
|
|
need_hint = true;
|
|
print_symbols_on_debug = true;
|
|
break;
|
|
default:
|
|
return false;
|
|
}
|
|
sort_opts_vals.complex_sort = true;
|
|
sm->func = get_sort_func(sm);
|
|
}
|
|
return (true);
|
|
}
|
|
|
|
/*
|
|
* Parse POS in -k option.
|
|
*/
|
|
static int
|
|
parse_pos(const char *s, struct key_specs *ks, bool *mef_flags, bool second)
|
|
{
|
|
regmatch_t pmatch[4];
|
|
regex_t re;
|
|
char *c, *f;
|
|
const char *sregexp = "^([0-9]+)(\\.[0-9]+)?([bdfirMngRhV]+)?$";
|
|
size_t len, nmatch;
|
|
int ret;
|
|
|
|
ret = -1;
|
|
nmatch = 4;
|
|
c = f = NULL;
|
|
|
|
if (regcomp(&re, sregexp, REG_EXTENDED) != 0)
|
|
return (-1);
|
|
|
|
if (regexec(&re, s, nmatch, pmatch, 0) != 0)
|
|
goto end;
|
|
|
|
if (pmatch[0].rm_eo <= pmatch[0].rm_so)
|
|
goto end;
|
|
|
|
if (pmatch[1].rm_eo <= pmatch[1].rm_so)
|
|
goto end;
|
|
|
|
len = pmatch[1].rm_eo - pmatch[1].rm_so;
|
|
f = sort_malloc((len + 1) * sizeof(char));
|
|
|
|
strncpy(f, s + pmatch[1].rm_so, len);
|
|
f[len] = '\0';
|
|
|
|
if (second) {
|
|
errno = 0;
|
|
ks->f2 = (size_t) strtoul(f, NULL, 10);
|
|
if (errno != 0)
|
|
errx(2, "%s: -k", strerror(errno));
|
|
if (ks->f2 == 0) {
|
|
warn("%s",getstr(5));
|
|
goto end;
|
|
}
|
|
} else {
|
|
errno = 0;
|
|
ks->f1 = (size_t) strtoul(f, NULL, 10);
|
|
if (errno != 0)
|
|
errx(2, "%s: -k", strerror(errno));
|
|
if (ks->f1 == 0) {
|
|
warn("%s",getstr(5));
|
|
goto end;
|
|
}
|
|
}
|
|
|
|
if (pmatch[2].rm_eo > pmatch[2].rm_so) {
|
|
len = pmatch[2].rm_eo - pmatch[2].rm_so - 1;
|
|
c = sort_malloc((len + 1) * sizeof(char));
|
|
|
|
strncpy(c, s + pmatch[2].rm_so + 1, len);
|
|
c[len] = '\0';
|
|
|
|
if (second) {
|
|
errno = 0;
|
|
ks->c2 = (size_t) strtoul(c, NULL, 10);
|
|
if (errno != 0)
|
|
errx(2, "%s: -k", strerror(errno));
|
|
} else {
|
|
errno = 0;
|
|
ks->c1 = (size_t) strtoul(c, NULL, 10);
|
|
if (errno != 0)
|
|
errx(2, "%s: -k", strerror(errno));
|
|
if (ks->c1 == 0) {
|
|
warn("%s",getstr(6));
|
|
goto end;
|
|
}
|
|
}
|
|
} else {
|
|
if (second)
|
|
ks->c2 = 0;
|
|
else
|
|
ks->c1 = 1;
|
|
}
|
|
|
|
if (pmatch[3].rm_eo > pmatch[3].rm_so) {
|
|
regoff_t i = 0;
|
|
|
|
for (i = pmatch[3].rm_so; i < pmatch[3].rm_eo; i++) {
|
|
check_mutually_exclusive_flags(s[i], mef_flags);
|
|
if (s[i] == 'b') {
|
|
if (second)
|
|
ks->pos2b = true;
|
|
else
|
|
ks->pos1b = true;
|
|
} else if (!set_sort_modifier(&(ks->sm), s[i]))
|
|
goto end;
|
|
}
|
|
}
|
|
|
|
ret = 0;
|
|
|
|
end:
|
|
|
|
if (c)
|
|
sort_free(c);
|
|
if (f)
|
|
sort_free(f);
|
|
regfree(&re);
|
|
|
|
return (ret);
|
|
}
|
|
|
|
/*
|
|
* Parse -k option value.
|
|
*/
|
|
static int
|
|
parse_k(const char *s, struct key_specs *ks)
|
|
{
|
|
int ret = -1;
|
|
bool mef_flags[NUMBER_OF_MUTUALLY_EXCLUSIVE_FLAGS] =
|
|
{ false, false, false, false, false, false };
|
|
|
|
if (s && *s) {
|
|
char *sptr;
|
|
|
|
sptr = strchr(s, ',');
|
|
if (sptr) {
|
|
size_t size1;
|
|
char *pos1, *pos2;
|
|
|
|
size1 = sptr - s;
|
|
|
|
if (size1 < 1)
|
|
return (-1);
|
|
pos1 = sort_malloc((size1 + 1) * sizeof(char));
|
|
|
|
strncpy(pos1, s, size1);
|
|
pos1[size1] = '\0';
|
|
|
|
ret = parse_pos(pos1, ks, mef_flags, false);
|
|
|
|
sort_free(pos1);
|
|
if (ret < 0)
|
|
return (ret);
|
|
|
|
pos2 = sort_strdup(sptr + 1);
|
|
ret = parse_pos(pos2, ks, mef_flags, true);
|
|
sort_free(pos2);
|
|
} else
|
|
ret = parse_pos(s, ks, mef_flags, false);
|
|
}
|
|
|
|
return (ret);
|
|
}
|
|
|
|
/*
|
|
* Parse POS in +POS -POS option.
|
|
*/
|
|
static int
|
|
parse_pos_obs(const char *s, int *nf, int *nc, char* sopts)
|
|
{
|
|
regex_t re;
|
|
regmatch_t pmatch[4];
|
|
char *c, *f;
|
|
const char *sregexp = "^([0-9]+)(\\.[0-9]+)?([A-Za-z]+)?$";
|
|
int ret;
|
|
size_t len, nmatch;
|
|
|
|
ret = -1;
|
|
nmatch = 4;
|
|
c = f = NULL;
|
|
*nc = *nf = 0;
|
|
|
|
if (regcomp(&re, sregexp, REG_EXTENDED) != 0)
|
|
return (-1);
|
|
|
|
if (regexec(&re, s, nmatch, pmatch, 0) != 0)
|
|
goto end;
|
|
|
|
if (pmatch[0].rm_eo <= pmatch[0].rm_so)
|
|
goto end;
|
|
|
|
if (pmatch[1].rm_eo <= pmatch[1].rm_so)
|
|
goto end;
|
|
|
|
len = pmatch[1].rm_eo - pmatch[1].rm_so;
|
|
f = sort_malloc((len + 1) * sizeof(char));
|
|
|
|
strncpy(f, s + pmatch[1].rm_so, len);
|
|
f[len] = '\0';
|
|
|
|
errno = 0;
|
|
*nf = (size_t) strtoul(f, NULL, 10);
|
|
if (errno != 0)
|
|
errx(2, "%s", getstr(11));
|
|
|
|
if (pmatch[2].rm_eo > pmatch[2].rm_so) {
|
|
len = pmatch[2].rm_eo - pmatch[2].rm_so - 1;
|
|
c = sort_malloc((len + 1) * sizeof(char));
|
|
|
|
strncpy(c, s + pmatch[2].rm_so + 1, len);
|
|
c[len] = '\0';
|
|
|
|
errno = 0;
|
|
*nc = (size_t) strtoul(c, NULL, 10);
|
|
if (errno != 0)
|
|
errx(2, "%s", getstr(11));
|
|
}
|
|
|
|
if (pmatch[3].rm_eo > pmatch[3].rm_so) {
|
|
|
|
len = pmatch[3].rm_eo - pmatch[3].rm_so;
|
|
|
|
strncpy(sopts, s + pmatch[3].rm_so, len);
|
|
sopts[len] = '\0';
|
|
}
|
|
|
|
ret = 0;
|
|
|
|
end:
|
|
if (c)
|
|
sort_free(c);
|
|
if (f)
|
|
sort_free(f);
|
|
regfree(&re);
|
|
|
|
return (ret);
|
|
}
|
|
|
|
/*
|
|
* "Translate" obsolete +POS1 -POS2 syntax into new -kPOS1,POS2 syntax
|
|
*/
|
|
void
|
|
fix_obsolete_keys(int *argc, char **argv)
|
|
{
|
|
char sopt[129];
|
|
|
|
for (int i = 1; i < *argc; i++) {
|
|
char *arg1;
|
|
|
|
arg1 = argv[i];
|
|
|
|
if (strlen(arg1) > 1 && arg1[0] == '+') {
|
|
int c1, f1;
|
|
char sopts1[128];
|
|
|
|
sopts1[0] = 0;
|
|
c1 = f1 = 0;
|
|
|
|
if (parse_pos_obs(arg1 + 1, &f1, &c1, sopts1) < 0)
|
|
continue;
|
|
else {
|
|
f1 += 1;
|
|
c1 += 1;
|
|
if (i + 1 < *argc) {
|
|
char *arg2 = argv[i + 1];
|
|
|
|
if (strlen(arg2) > 1 &&
|
|
arg2[0] == '-') {
|
|
int c2, f2;
|
|
char sopts2[128];
|
|
|
|
sopts2[0] = 0;
|
|
c2 = f2 = 0;
|
|
|
|
if (parse_pos_obs(arg2 + 1,
|
|
&f2, &c2, sopts2) >= 0) {
|
|
if (c2 > 0)
|
|
f2 += 1;
|
|
sprintf(sopt, "-k%d.%d%s,%d.%d%s",
|
|
f1, c1, sopts1, f2, c2, sopts2);
|
|
argv[i] = sort_strdup(sopt);
|
|
for (int j = i + 1; j + 1 < *argc; j++)
|
|
argv[j] = argv[j + 1];
|
|
*argc -= 1;
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
sprintf(sopt, "-k%d.%d", f1, c1);
|
|
argv[i] = sort_strdup(sopt);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Set random seed
|
|
*/
|
|
static void
|
|
set_random_seed(void)
|
|
{
|
|
if (need_random) {
|
|
|
|
if (strcmp(random_source, DEFAULT_RANDOM_SORT_SEED_FILE) == 0) {
|
|
FILE* fseed;
|
|
MD5_CTX ctx;
|
|
char rsd[MAX_DEFAULT_RANDOM_SEED_DATA_SIZE];
|
|
size_t sz = 0;
|
|
|
|
fseed = openfile(random_source, "r");
|
|
while (!feof(fseed)) {
|
|
int cr;
|
|
|
|
cr = fgetc(fseed);
|
|
if (cr == EOF)
|
|
break;
|
|
|
|
rsd[sz++] = (char) cr;
|
|
|
|
if (sz >= MAX_DEFAULT_RANDOM_SEED_DATA_SIZE)
|
|
break;
|
|
}
|
|
|
|
closefile(fseed, random_source);
|
|
|
|
MD5Init(&ctx);
|
|
MD5Update(&ctx, rsd, sz);
|
|
|
|
random_seed = MD5End(&ctx, NULL);
|
|
random_seed_size = strlen(random_seed);
|
|
|
|
} else {
|
|
MD5_CTX ctx;
|
|
char *b;
|
|
|
|
MD5Init(&ctx);
|
|
b = MD5File(random_source, NULL);
|
|
if (b == NULL)
|
|
err(2, NULL);
|
|
|
|
random_seed = b;
|
|
random_seed_size = strlen(b);
|
|
}
|
|
|
|
MD5Init(&md5_ctx);
|
|
if(random_seed_size>0) {
|
|
MD5Update(&md5_ctx, random_seed, random_seed_size);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Main function.
|
|
*/
|
|
int
|
|
main(int argc, char **argv)
|
|
{
|
|
char *outfile, *real_outfile;
|
|
int c, result;
|
|
bool mef_flags[NUMBER_OF_MUTUALLY_EXCLUSIVE_FLAGS] =
|
|
{ false, false, false, false, false, false };
|
|
|
|
result = 0;
|
|
outfile = sort_strdup("-");
|
|
real_outfile = NULL;
|
|
|
|
struct sort_mods *sm = &default_sort_mods_object;
|
|
|
|
init_tmp_files();
|
|
|
|
set_signal_handler();
|
|
|
|
set_hw_params();
|
|
set_locale();
|
|
set_tmpdir();
|
|
set_sort_opts();
|
|
|
|
#if 0
|
|
{
|
|
static int counter = 0;
|
|
char fn[128];
|
|
sprintf(fn, "/var/tmp/debug.sort.%d", counter++);
|
|
FILE* f = fopen(fn, "w");
|
|
fprintf(f, ">>sort>>");
|
|
for (int i = 0; i < argc; i++) {
|
|
fprintf(f, "<%s>", argv[i]);
|
|
}
|
|
fprintf(f, "<<sort<<\n");
|
|
fclose(f);
|
|
}
|
|
#endif
|
|
|
|
fix_obsolete_keys(&argc, argv);
|
|
|
|
while (((c = getopt_long(argc, argv, OPTIONS, long_options, NULL))
|
|
!= -1)) {
|
|
|
|
check_mutually_exclusive_flags(c, mef_flags);
|
|
|
|
if (!set_sort_modifier(sm, c)) {
|
|
|
|
switch (c) {
|
|
case 'c':
|
|
sort_opts_vals.cflag = true;
|
|
if (optarg) {
|
|
if (!strcmp(optarg, "diagnose-first"))
|
|
;
|
|
else if (!strcmp(optarg, "silent") ||
|
|
!strcmp(optarg, "quiet"))
|
|
sort_opts_vals.csilentflag = true;
|
|
else if (*optarg)
|
|
unknown(optarg);
|
|
}
|
|
break;
|
|
case 'C':
|
|
sort_opts_vals.cflag = true;
|
|
sort_opts_vals.csilentflag = true;
|
|
break;
|
|
case 'k':
|
|
{
|
|
sort_opts_vals.complex_sort = true;
|
|
sort_opts_vals.kflag = true;
|
|
|
|
keys_num++;
|
|
keys = sort_realloc(keys, keys_num *
|
|
sizeof(struct key_specs));
|
|
memset(&(keys[keys_num - 1]), 0,
|
|
sizeof(struct key_specs));
|
|
|
|
if (parse_k(optarg, &(keys[keys_num - 1]))
|
|
< 0) {
|
|
errx(2, "%s: -k %s\n",
|
|
strerror(EINVAL), optarg);
|
|
}
|
|
|
|
break;
|
|
}
|
|
case 'm':
|
|
sort_opts_vals.mflag = true;
|
|
break;
|
|
case 'o':
|
|
outfile = sort_realloc(outfile, (strlen(optarg) + 1));
|
|
strcpy(outfile, optarg);
|
|
break;
|
|
case 's':
|
|
sort_opts_vals.sflag = true;
|
|
break;
|
|
case 'S':
|
|
available_free_memory =
|
|
parse_memory_buffer_value(optarg);
|
|
break;
|
|
case 'T':
|
|
tmpdir = sort_strdup(optarg);
|
|
break;
|
|
case 't':
|
|
while (strlen(optarg) > 1) {
|
|
if (optarg[0] != '\\') {
|
|
errx(2, "%s: %s\n",
|
|
strerror(EINVAL), optarg);
|
|
}
|
|
optarg += 1;
|
|
if (*optarg == '0') {
|
|
*optarg = 0;
|
|
break;
|
|
}
|
|
}
|
|
sort_opts_vals.tflag = true;
|
|
sort_opts_vals.field_sep = btowc(optarg[0]);
|
|
if (sort_opts_vals.field_sep == WEOF) {
|
|
errno = EINVAL;
|
|
err(2, NULL);
|
|
}
|
|
if (!gnusort_numeric_compatibility) {
|
|
if (symbol_decimal_point == sort_opts_vals.field_sep)
|
|
symbol_decimal_point = WEOF;
|
|
if (symbol_thousands_sep == sort_opts_vals.field_sep)
|
|
symbol_thousands_sep = WEOF;
|
|
if (symbol_negative_sign == sort_opts_vals.field_sep)
|
|
symbol_negative_sign = WEOF;
|
|
if (symbol_positive_sign == sort_opts_vals.field_sep)
|
|
symbol_positive_sign = WEOF;
|
|
}
|
|
break;
|
|
case 'u':
|
|
sort_opts_vals.uflag = true;
|
|
/* stable sort for the correct unique val */
|
|
sort_opts_vals.sflag = true;
|
|
break;
|
|
case 'z':
|
|
sort_opts_vals.zflag = true;
|
|
break;
|
|
case SORT_OPT:
|
|
if (optarg) {
|
|
if (!strcmp(optarg, "general-numeric"))
|
|
set_sort_modifier(sm, 'g');
|
|
else if (!strcmp(optarg, "human-numeric"))
|
|
set_sort_modifier(sm, 'h');
|
|
else if (!strcmp(optarg, "numeric"))
|
|
set_sort_modifier(sm, 'n');
|
|
else if (!strcmp(optarg, "month"))
|
|
set_sort_modifier(sm, 'M');
|
|
else if (!strcmp(optarg, "random"))
|
|
set_sort_modifier(sm, 'R');
|
|
else
|
|
unknown(optarg);
|
|
}
|
|
break;
|
|
#if defined(SORT_THREADS)
|
|
case PARALLEL_OPT:
|
|
nthreads = (size_t)(atoi(optarg));
|
|
if (nthreads < 1)
|
|
nthreads = 1;
|
|
if (nthreads > 1024)
|
|
nthreads = 1024;
|
|
break;
|
|
#endif
|
|
case QSORT_OPT:
|
|
sort_opts_vals.sort_method = SORT_QSORT;
|
|
break;
|
|
case MERGESORT_OPT:
|
|
sort_opts_vals.sort_method = SORT_MERGESORT;
|
|
break;
|
|
case MMAP_OPT:
|
|
use_mmap = true;
|
|
break;
|
|
case HEAPSORT_OPT:
|
|
sort_opts_vals.sort_method = SORT_HEAPSORT;
|
|
break;
|
|
case RADIXSORT_OPT:
|
|
sort_opts_vals.sort_method = SORT_RADIXSORT;
|
|
break;
|
|
case RANDOMSOURCE_OPT:
|
|
random_source = strdup(optarg);
|
|
break;
|
|
case COMPRESSPROGRAM_OPT:
|
|
compress_program = strdup(optarg);
|
|
break;
|
|
case FF_OPT:
|
|
read_fns_from_file0(optarg);
|
|
break;
|
|
case BS_OPT:
|
|
{
|
|
errno = 0;
|
|
long mof = strtol(optarg, NULL, 10);
|
|
if (errno != 0)
|
|
errx(2, "--batch-size: %s",
|
|
strerror(errno));
|
|
if (mof >= 2)
|
|
max_open_files = (size_t) mof + 1;
|
|
}
|
|
break;
|
|
case VERSION_OPT:
|
|
printf("%s\n", VERSION);
|
|
exit(EXIT_SUCCESS);
|
|
/* NOTREACHED */
|
|
break;
|
|
case DEBUG_OPT:
|
|
debug_sort = true;
|
|
break;
|
|
case HELP_OPT:
|
|
usage(false);
|
|
/* NOTREACHED */
|
|
break;
|
|
default:
|
|
usage(true);
|
|
/* NOTREACHED */
|
|
}
|
|
}
|
|
}
|
|
|
|
argc -= optind;
|
|
argv += optind;
|
|
|
|
#ifndef WITHOUT_NLS
|
|
catalog = catopen("sort", NL_CAT_LOCALE);
|
|
#endif
|
|
|
|
if (sort_opts_vals.cflag && sort_opts_vals.mflag)
|
|
errx(1, "%c:%c: %s", 'm', 'c', getstr(1));
|
|
|
|
#ifndef WITHOUT_NLS
|
|
catclose(catalog);
|
|
#endif
|
|
|
|
if (keys_num == 0) {
|
|
keys_num = 1;
|
|
keys = sort_realloc(keys, sizeof(struct key_specs));
|
|
memset(&(keys[0]), 0, sizeof(struct key_specs));
|
|
keys[0].c1 = 1;
|
|
keys[0].pos1b = default_sort_mods->bflag;
|
|
keys[0].pos2b = default_sort_mods->bflag;
|
|
memcpy(&(keys[0].sm), default_sort_mods,
|
|
sizeof(struct sort_mods));
|
|
}
|
|
|
|
for (size_t i = 0; i < keys_num; i++) {
|
|
struct key_specs *ks;
|
|
|
|
ks = &(keys[i]);
|
|
|
|
if (sort_modifier_empty(&(ks->sm)) && !(ks->pos1b) &&
|
|
!(ks->pos2b)) {
|
|
ks->pos1b = sm->bflag;
|
|
ks->pos2b = sm->bflag;
|
|
memcpy(&(ks->sm), sm, sizeof(struct sort_mods));
|
|
}
|
|
|
|
ks->sm.func = get_sort_func(&(ks->sm));
|
|
}
|
|
|
|
if (argv_from_file0) {
|
|
argc = argc_from_file0;
|
|
argv = argv_from_file0;
|
|
}
|
|
|
|
if (debug_sort) {
|
|
#if defined(SORT_THREADS)
|
|
nthreads = 1;
|
|
#endif
|
|
printf("Using collate rules of %s locale\n",
|
|
setlocale(LC_COLLATE, NULL));
|
|
if (byte_sort)
|
|
printf("Byte sort is used\n");
|
|
if (print_symbols_on_debug) {
|
|
printf("Decimal Point: <%lc>\n", symbol_decimal_point);
|
|
if (symbol_thousands_sep)
|
|
printf("Thousands separator: <%lc>\n",
|
|
symbol_thousands_sep);
|
|
printf("Positive sign: <%lc>\n", symbol_positive_sign);
|
|
printf("Negative sign: <%lc>\n", symbol_negative_sign);
|
|
}
|
|
}
|
|
|
|
set_random_seed();
|
|
|
|
/* Case when the outfile equals one of the input files: */
|
|
if (strcmp(outfile, "-")) {
|
|
|
|
for(int i = 0; i < argc; ++i) {
|
|
if (strcmp(argv[i], outfile) == 0) {
|
|
real_outfile = sort_strdup(outfile);
|
|
for(;;) {
|
|
char* tmp = sort_malloc(strlen(outfile) +
|
|
strlen(".tmp") + 1);
|
|
|
|
strcpy(tmp, outfile);
|
|
strcpy(tmp + strlen(tmp), ".tmp");
|
|
sort_free(outfile);
|
|
outfile = tmp;
|
|
if (access(outfile, F_OK) < 0)
|
|
break;
|
|
}
|
|
tmp_file_atexit(outfile);
|
|
}
|
|
}
|
|
}
|
|
|
|
#if defined(SORT_THREADS)
|
|
if ((argc < 1) || (strcmp(outfile, "-") == 0) || (*outfile == 0))
|
|
nthreads = 1;
|
|
#endif
|
|
|
|
if (!sort_opts_vals.cflag && !sort_opts_vals.mflag) {
|
|
struct file_list fl;
|
|
struct sort_list list;
|
|
|
|
sort_list_init(&list);
|
|
file_list_init(&fl, true);
|
|
|
|
if (argc < 1)
|
|
procfile("-", &list, &fl);
|
|
else {
|
|
while (argc > 0) {
|
|
procfile(*argv, &list, &fl);
|
|
--argc;
|
|
++argv;
|
|
}
|
|
}
|
|
|
|
if (fl.count < 1)
|
|
sort_list_to_file(&list, outfile);
|
|
else {
|
|
if (list.count > 0) {
|
|
char *flast = new_tmp_file_name();
|
|
|
|
sort_list_to_file(&list, flast);
|
|
file_list_add(&fl, flast, false);
|
|
}
|
|
merge_files(&fl, outfile);
|
|
}
|
|
|
|
file_list_clean(&fl);
|
|
|
|
/*
|
|
* We are about to exit the program, so we can ignore
|
|
* the clean-up for speed
|
|
*
|
|
* sort_list_clean(&list);
|
|
*/
|
|
|
|
} else if (sort_opts_vals.cflag) {
|
|
result = (argc == 0) ? (check("-")) : (check(*argv));
|
|
} else if (sort_opts_vals.mflag) {
|
|
struct file_list fl;
|
|
|
|
file_list_init(&fl, false);
|
|
file_list_populate(&fl, argc, argv, true);
|
|
merge_files(&fl, outfile);
|
|
file_list_clean(&fl);
|
|
}
|
|
|
|
if (real_outfile) {
|
|
unlink(real_outfile);
|
|
if (rename(outfile, real_outfile) < 0)
|
|
err(2, NULL);
|
|
sort_free(real_outfile);
|
|
}
|
|
|
|
sort_free(outfile);
|
|
|
|
return (result);
|
|
}
|