usr.bin/sort/file.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (C) 2009 Gabor Kovesdan <gabor@FreeBSD.org>
   5  * Copyright (C) 2012 Oleg Moskalenko <mom040267@gmail.com>
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  */
  29
  30 #include <sys/cdefs.h>
  31 __FBSDID("$FreeBSD$");
  32
  33 #include <sys/mman.h>
  34 #include <sys/stat.h>
  35 #include <sys/types.h>
  36 #include <sys/queue.h>
  37
  38 #include <err.h>
  39 #include <fcntl.h>
  40 #if defined(SORT_THREADS)
  41 #include <pthread.h>
  42 #endif
  43 #include <semaphore.h>
  44 #include <stdio.h>
  45 #include <stdlib.h>
  46 #include <string.h>
  47 #include <unistd.h>
  48 #include <wchar.h>
  49 #include <wctype.h>
  50
  51 #include "coll.h"
  52 #include "file.h"
  53 #include "radixsort.h"
  54
  55 unsigned long long free_memory = 1000000;
  56 unsigned long long available_free_memory = 1000000;
  57
  58 bool use_mmap;
  59
  60 const char *tmpdir = "/var/tmp";
  61 const char *compress_program;
  62
  63 size_t max_open_files = 16;
  64
  65 /*
  66  * How much space we read from file at once
  67  */
  68 #define READ_CHUNK (4096)
  69
  70 /*
  71  * File reader structure
  72  */
  73 struct file_reader
  74 {
  75         struct reader_buffer     rb;
  76         FILE                    *file;
  77         char                    *fname;
  78         unsigned char           *buffer;
  79         unsigned char           *mmapaddr;
  80         unsigned char           *mmapptr;
  81         size_t                   bsz;
  82         size_t                   cbsz;
  83         size_t                   mmapsize;
  84         size_t                   strbeg;
  85         int                      fd;
  86         char                     elsymb;
  87 };
  88
  89 /*
  90  * Structure to be used in file merge process.
  91  */
  92 struct file_header
  93 {
  94         struct file_reader              *fr;
  95         struct sort_list_item           *si; /* current top line */
  96         size_t                           file_pos;
  97 };
  98
  99 /*
 100  * List elements of "cleanable" files list.
 101  */
 102 struct CLEANABLE_FILE
 103 {
 104         char                            *fn;
 105         LIST_ENTRY(CLEANABLE_FILE)       files;
 106 };
 107
 108 /*
 109  * List header of "cleanable" files list.
 110  */
 111 static LIST_HEAD(CLEANABLE_FILES,CLEANABLE_FILE) tmp_files;
 112
 113 /*
 114  * Semaphore to protect the tmp file list.
 115  * We use semaphore here because it is signal-safe, according to POSIX.
 116  * And semaphore does not require pthread library.
 117  */
 118 static sem_t tmp_files_sem;
 119
 120 static void mt_sort(struct sort_list *list,
 121     int (*sort_func)(void *, size_t, size_t,
 122     int (*)(const void *, const void *)), const char* fn);
 123
 124 /*
 125  * Init tmp files list
 126  */
 127 void
 128 init_tmp_files(void)
 129 {
 130
 131         LIST_INIT(&tmp_files);
 132         sem_init(&tmp_files_sem, 0, 1);
 133 }
 134
 135 /*
 136  * Save name of a tmp file for signal cleanup
 137  */
 138 void
 139 tmp_file_atexit(const char *tmp_file)
 140 {
 141
 142         if (tmp_file) {
 143                 sem_wait(&tmp_files_sem);
 144                 struct CLEANABLE_FILE *item =
 145                     sort_malloc(sizeof(struct CLEANABLE_FILE));
 146                 item->fn = sort_strdup(tmp_file);
 147                 LIST_INSERT_HEAD(&tmp_files, item, files);
 148                 sem_post(&tmp_files_sem);
 149         }
 150 }
 151
 152 /*
 153  * Clear tmp files
 154  */
 155 void
 156 clear_tmp_files(void)
 157 {
 158         struct CLEANABLE_FILE *item;
 159
 160         sem_wait(&tmp_files_sem);
 161         LIST_FOREACH(item,&tmp_files,files) {
 162                 if ((item) && (item->fn))
 163                         unlink(item->fn);
 164         }
 165         sem_post(&tmp_files_sem);
 166 }
 167
 168 /*
 169  * Check whether a file is a temporary file
 170  */
 171 static bool
 172 file_is_tmp(const char* fn)
 173 {
 174         struct CLEANABLE_FILE *item;
 175         bool ret = false;
 176
 177         if (fn) {
 178                 sem_wait(&tmp_files_sem);
 179                 LIST_FOREACH(item,&tmp_files,files) {
 180                         if ((item) && (item->fn))
 181                                 if (strcmp(item->fn, fn) == 0) {
 182                                         ret = true;
 183                                         break;
 184                                 }
 185                 }
 186                 sem_post(&tmp_files_sem);
 187         }
 188
 189         return (ret);
 190 }
 191
 192 /*
 193  * Generate new temporary file name
 194  */
 195 char *
 196 new_tmp_file_name(void)
 197 {
 198         static size_t tfcounter = 0;
 199         static const char *fn = ".bsdsort.";
 200         char *ret;
 201         size_t sz;
 202
 203         sz = strlen(tmpdir) + 1 + strlen(fn) + 32 + 1;
 204         ret = sort_malloc(sz);
 205
 206         sprintf(ret, "%s/%s%d.%lu", tmpdir, fn, (int) getpid(), (unsigned long)(tfcounter++));
 207         tmp_file_atexit(ret);
 208         return (ret);
 209 }
 210
 211 /*
 212  * Initialize file list
 213  */
 214 void
 215 file_list_init(struct file_list *fl, bool tmp)
 216 {
 217
 218         if (fl) {
 219                 fl->count = 0;
 220                 fl->sz = 0;
 221                 fl->fns = NULL;
 222                 fl->tmp = tmp;
 223         }
 224 }
 225
 226 /*
 227  * Add a file name to the list
 228  */
 229 void
 230 file_list_add(struct file_list *fl, const char *fn, bool allocate)
 231 {
 232
 233         if (fl && fn) {
 234                 if (fl->count >= fl->sz || (fl->fns == NULL)) {
 235                         fl->sz = (fl->sz) * 2 + 1;
 236                         fl->fns = sort_realloc(fl->fns, fl->sz *
 237                             sizeof(char *));
 238                 }
 239                 fl->fns[fl->count] = allocate ? sort_strdup(fn) : fn;
 240                 fl->count += 1;
 241         }
 242 }
 243
 244 /*
 245  * Populate file list from array of file names
 246  */
 247 void
 248 file_list_populate(struct file_list *fl, int argc, char **argv, bool allocate)
 249 {
 250
 251         if (fl && argv) {
 252                 int i;
 253
 254                 for (i = 0; i < argc; i++)
 255                         file_list_add(fl, argv[i], allocate);
 256         }
 257 }
 258
 259 /*
 260  * Clean file list data and delete the files,
 261  * if this is a list of temporary files
 262  */
 263 void
 264 file_list_clean(struct file_list *fl)
 265 {
 266
 267         if (fl) {
 268                 if (fl->fns) {
 269                         size_t i;
 270
 271                         for (i = 0; i < fl->count; i++) {
 272                                 if (fl->fns[i]) {
 273                                         if (fl->tmp)
 274                                                 unlink(fl->fns[i]);
 275                                         sort_free(fl->fns[i]);
 276                                         fl->fns[i] = 0;
 277                                 }
 278                         }
 279                         sort_free(fl->fns);
 280                         fl->fns = NULL;
 281                 }
 282                 fl->sz = 0;
 283                 fl->count = 0;
 284                 fl->tmp = false;
 285         }
 286 }
 287
 288 /*
 289  * Init sort list
 290  */
 291 void
 292 sort_list_init(struct sort_list *l)
 293 {
 294
 295         if (l) {
 296                 l->count = 0;
 297                 l->size = 0;
 298                 l->memsize = sizeof(struct sort_list);
 299                 l->list = NULL;
 300         }
 301 }
 302
 303 /*
 304  * Add string to sort list
 305  */
 306 void
 307 sort_list_add(struct sort_list *l, struct bwstring *str)
 308 {
 309
 310         if (l && str) {
 311                 size_t indx = l->count;
 312
 313                 if ((l->list == NULL) || (indx >= l->size)) {
 314                         size_t newsize = (l->size + 1) + 1024;
 315
 316                         l->list = sort_realloc(l->list,
 317                             sizeof(struct sort_list_item*) * newsize);
 318                         l->memsize += (newsize - l->size) *
 319                             sizeof(struct sort_list_item*);
 320                         l->size = newsize;
 321                 }
 322                 l->list[indx] = sort_list_item_alloc();
 323                 sort_list_item_set(l->list[indx], str);
 324                 l->memsize += sort_list_item_size(l->list[indx]);
 325                 l->count += 1;
 326         }
 327 }
 328
 329 /*
 330  * Clean sort list data
 331  */
 332 void
 333 sort_list_clean(struct sort_list *l)
 334 {
 335
 336         if (l) {
 337                 if (l->list) {
 338                         size_t i;
 339
 340                         for (i = 0; i < l->count; i++) {
 341                                 struct sort_list_item *item;
 342
 343                                 item = l->list[i];
 344
 345                                 if (item) {
 346                                         sort_list_item_clean(item);
 347                                         sort_free(item);
 348                                         l->list[i] = NULL;
 349                                 }
 350                         }
 351                         sort_free(l->list);
 352                         l->list = NULL;
 353                 }
 354                 l->count = 0;
 355                 l->size = 0;
 356                 l->memsize = sizeof(struct sort_list);
 357         }
 358 }
 359
 360 /*
 361  * Write sort list to file
 362  */
 363 void
 364 sort_list_dump(struct sort_list *l, const char *fn)
 365 {
 366
 367         if (l && fn) {
 368                 FILE *f;
 369
 370                 f = openfile(fn, "w");
 371                 if (f == NULL)
 372                         err(2, NULL);
 373
 374                 if (l->list) {
 375                         size_t i;
 376                         if (!(sort_opts_vals.uflag)) {
 377                                 for (i = 0; i < l->count; ++i)
 378                                         bwsfwrite(l->list[i]->str, f,
 379                                             sort_opts_vals.zflag);
 380                         } else {
 381                                 struct sort_list_item *last_printed_item = NULL;
 382                                 struct sort_list_item *item;
 383                                 for (i = 0; i < l->count; ++i) {
 384                                         item = l->list[i];
 385                                         if ((last_printed_item == NULL) ||
 386                                             list_coll(&last_printed_item, &item)) {
 387                                                 bwsfwrite(item->str, f, sort_opts_vals.zflag);
 388                                                 last_printed_item = item;
 389                                         }
 390                                 }
 391                         }
 392                 }
 393
 394                 closefile(f, fn);
 395         }
 396 }
 397
 398 /*
 399  * Checks if the given file is sorted.  Stops at the first disorder,
 400  * prints the disordered line and returns 1.
 401  */
 402 int
 403 check(const char *fn)
 404 {
 405         struct bwstring *s1, *s2, *s1disorder, *s2disorder;
 406         struct file_reader *fr;
 407         struct keys_array *ka1, *ka2;
 408         int res;
 409         size_t pos, posdisorder;
 410
 411         s1 = s2 = s1disorder = s2disorder = NULL;
 412         ka1 = ka2 = NULL;
 413
 414         fr = file_reader_init(fn);
 415
 416         res = 0;
 417         pos = 1;
 418         posdisorder = 1;
 419
 420         if (fr == NULL) {
 421                 err(2, NULL);
 422                 goto end;
 423         }
 424
 425         s1 = file_reader_readline(fr);
 426         if (s1 == NULL)
 427                 goto end;
 428
 429         ka1 = keys_array_alloc();
 430         preproc(s1, ka1);
 431
 432         s2 = file_reader_readline(fr);
 433         if (s2 == NULL)
 434                 goto end;
 435
 436         ka2 = keys_array_alloc();
 437         preproc(s2, ka2);
 438
 439         for (;;) {
 440
 441                 if (debug_sort) {
 442                         bwsprintf(stdout, s2, "s1=<", ">");
 443                         bwsprintf(stdout, s1, "s2=<", ">");
 444                 }
 445                 int cmp = key_coll(ka2, ka1, 0);
 446                 if (debug_sort)
 447                         printf("; cmp1=%d", cmp);
 448
 449                 if (!cmp && sort_opts_vals.complex_sort &&
 450                     !(sort_opts_vals.uflag) && !(sort_opts_vals.sflag)) {
 451                         cmp = top_level_str_coll(s2, s1);
 452                         if (debug_sort)
 453                                 printf("; cmp2=%d", cmp);
 454                 }
 455                 if (debug_sort)
 456                         printf("\n");
 457
 458                 if ((sort_opts_vals.uflag && (cmp <= 0)) || (cmp < 0)) {
 459                         if (!(sort_opts_vals.csilentflag)) {
 460                                 s2disorder = bwsdup(s2);
 461                                 posdisorder = pos;
 462                                 if (debug_sort)
 463                                         s1disorder = bwsdup(s1);
 464                         }
 465                         res = 1;
 466                         goto end;
 467                 }
 468
 469                 pos++;
 470
 471                 clean_keys_array(s1, ka1);
 472                 sort_free(ka1);
 473                 ka1 = ka2;
 474                 ka2 = NULL;
 475
 476                 bwsfree(s1);
 477                 s1 = s2;
 478
 479                 s2 = file_reader_readline(fr);
 480                 if (s2 == NULL)
 481                         goto end;
 482
 483                 ka2 = keys_array_alloc();
 484                 preproc(s2, ka2);
 485         }
 486
 487 end:
 488         if (ka1) {
 489                 clean_keys_array(s1, ka1);
 490                 sort_free(ka1);
 491         }
 492
 493         if (s1)
 494                 bwsfree(s1);
 495
 496         if (ka2) {
 497                 clean_keys_array(s2, ka2);
 498                 sort_free(ka2);
 499         }
 500
 501         if (s2)
 502                 bwsfree(s2);
 503
 504         if ((fn == NULL) || (*fn == 0) || (strcmp(fn, "-") == 0)) {
 505                 for (;;) {
 506                         s2 = file_reader_readline(fr);
 507                         if (s2 == NULL)
 508                                 break;
 509                         bwsfree(s2);
 510                 }
 511         }
 512
 513         file_reader_free(fr);
 514
 515         if (s2disorder) {
 516                 bws_disorder_warnx(s2disorder, fn, posdisorder);
 517                 if (s1disorder) {
 518                         bws_disorder_warnx(s1disorder, fn, posdisorder);
 519                         if (s1disorder != s2disorder)
 520                                 bwsfree(s1disorder);
 521                 }
 522                 bwsfree(s2disorder);
 523                 s1disorder = NULL;
 524                 s2disorder = NULL;
 525         }
 526
 527         if (res)
 528                 exit(res);
 529
 530         return (0);
 531 }
 532
 533 /*
 534  * Opens a file.  If the given filename is "-", stdout will be
 535  * opened.
 536  */
 537 FILE *
 538 openfile(const char *fn, const char *mode)
 539 {
 540         FILE *file;
 541
 542         if (strcmp(fn, "-") == 0) {
 543                 return ((mode && mode[0] == 'r') ? stdin : stdout);
 544         } else {
 545                 mode_t orig_file_mask = 0;
 546                 int is_tmp = file_is_tmp(fn);
 547
 548                 if (is_tmp && (mode[0] == 'w'))
 549                         orig_file_mask = umask(S_IWGRP | S_IWOTH |
 550                             S_IRGRP | S_IROTH);
 551
 552                 if (is_tmp && (compress_program != NULL)) {
 553                         char *cmd;
 554                         size_t cmdsz;
 555
 556                         cmdsz = strlen(fn) + 128;
 557                         cmd = sort_malloc(cmdsz);
 558
 559                         fflush(stdout);
 560
 561                         if (mode[0] == 'r')
 562                                 snprintf(cmd, cmdsz - 1, "cat %s | %s -d",
 563                                     fn, compress_program);
 564                         else if (mode[0] == 'w')
 565                                 snprintf(cmd, cmdsz - 1, "%s > %s",
 566                                     compress_program, fn);
 567                         else
 568                                 err(2, "%s", getstr(7));
 569
 570                         if ((file = popen(cmd, mode)) == NULL)
 571                                 err(2, NULL);
 572
 573                         sort_free(cmd);
 574
 575                 } else
 576                         if ((file = fopen(fn, mode)) == NULL)
 577                                 err(2, NULL);
 578
 579                 if (is_tmp && (mode[0] == 'w'))
 580                         umask(orig_file_mask);
 581         }
 582
 583         return (file);
 584 }
 585
 586 /*
 587  * Close file
 588  */
 589 void
 590 closefile(FILE *f, const char *fn)
 591 {
 592         if (f == NULL) {
 593                 ;
 594         } else if (f == stdin) {
 595                 ;
 596         } else if (f == stdout) {
 597                 fflush(f);
 598         } else {
 599                 if (file_is_tmp(fn) && compress_program != NULL) {
 600                         if(pclose(f)<0)
 601                                 err(2,NULL);
 602                 } else
 603                         fclose(f);
 604         }
 605 }
 606
 607 /*
 608  * Reads a file into the internal buffer.
 609  */
 610 struct file_reader *
 611 file_reader_init(const char *fsrc)
 612 {
 613         struct file_reader *ret;
 614
 615         if (fsrc == NULL)
 616                 fsrc = "-";
 617
 618         ret = sort_malloc(sizeof(struct file_reader));
 619         memset(ret, 0, sizeof(struct file_reader));
 620
 621         ret->elsymb = '\n';
 622         if (sort_opts_vals.zflag)
 623                 ret->elsymb = 0;
 624
 625         ret->fname = sort_strdup(fsrc);
 626
 627         if (strcmp(fsrc, "-") && (compress_program == NULL) && use_mmap) {
 628
 629                 do {
 630                         struct stat stat_buf;
 631                         void *addr;
 632                         size_t sz = 0;
 633                         int fd, flags;
 634
 635                         flags = MAP_NOCORE | MAP_NOSYNC;
 636                         addr = MAP_FAILED;
 637
 638                         fd = open(fsrc, O_RDONLY);
 639                         if (fd < 0)
 640                                 err(2, NULL);
 641
 642                         if (fstat(fd, &stat_buf) < 0) {
 643                                 close(fd);
 644                                 break;
 645                         }
 646
 647                         sz = stat_buf.st_size;
 648
 649 #if defined(MAP_PREFAULT_READ)
 650                         flags |= MAP_PREFAULT_READ;
 651 #endif
 652
 653                         addr = mmap(NULL, sz, PROT_READ, flags, fd, 0);
 654                         if (addr == MAP_FAILED) {
 655                                 close(fd);
 656                                 break;
 657                         }
 658
 659                         ret->fd = fd;
 660                         ret->mmapaddr = addr;
 661                         ret->mmapsize = sz;
 662                         ret->mmapptr = ret->mmapaddr;
 663
 664                 } while (0);
 665         }
 666
 667         if (ret->mmapaddr == NULL) {
 668                 ret->file = openfile(fsrc, "r");
 669                 if (ret->file == NULL)
 670                         err(2, NULL);
 671
 672                 if (strcmp(fsrc, "-")) {
 673                         ret->cbsz = READ_CHUNK;
 674                         ret->buffer = sort_malloc(ret->cbsz);
 675                         ret->bsz = 0;
 676                         ret->strbeg = 0;
 677
 678                         ret->bsz = fread(ret->buffer, 1, ret->cbsz, ret->file);
 679                         if (ret->bsz == 0) {
 680                                 if (ferror(ret->file))
 681                                         err(2, NULL);
 682                         }
 683                 }
 684         }
 685
 686         return (ret);
 687 }
 688
 689 struct bwstring *
 690 file_reader_readline(struct file_reader *fr)
 691 {
 692         struct bwstring *ret = NULL;
 693
 694         if (fr->mmapaddr) {
 695                 unsigned char *mmapend;
 696
 697                 mmapend = fr->mmapaddr + fr->mmapsize;
 698                 if (fr->mmapptr >= mmapend)
 699                         return (NULL);
 700                 else {
 701                         unsigned char *strend;
 702                         size_t sz;
 703
 704                         sz = mmapend - fr->mmapptr;
 705                         strend = memchr(fr->mmapptr, fr->elsymb, sz);
 706
 707                         if (strend == NULL) {
 708                                 ret = bwscsbdup(fr->mmapptr, sz);
 709                                 fr->mmapptr = mmapend;
 710                         } else {
 711                                 ret = bwscsbdup(fr->mmapptr, strend -
 712                                     fr->mmapptr);
 713                                 fr->mmapptr = strend + 1;
 714                         }
 715                 }
 716
 717         } else if (fr->file != stdin) {
 718                 unsigned char *strend;
 719                 size_t bsz1, remsz, search_start;
 720
 721                 search_start = 0;
 722                 remsz = 0;
 723                 strend = NULL;
 724
 725                 if (fr->bsz > fr->strbeg)
 726                         remsz = fr->bsz - fr->strbeg;
 727
 728                 /* line read cycle */
 729                 for (;;) {
 730                         if (remsz > search_start)
 731                                 strend = memchr(fr->buffer + fr->strbeg +
 732                                     search_start, fr->elsymb, remsz -
 733                                     search_start);
 734                         else
 735                                 strend = NULL;
 736
 737                         if (strend)
 738                                 break;
 739                         if (feof(fr->file))
 740                                 break;
 741
 742                         if (fr->bsz != fr->cbsz)
 743                                 /* NOTREACHED */
 744                                 err(2, "File read software error 1");
 745
 746                         if (remsz > (READ_CHUNK >> 1)) {
 747                                 search_start = fr->cbsz - fr->strbeg;
 748                                 fr->cbsz += READ_CHUNK;
 749                                 fr->buffer = sort_realloc(fr->buffer,
 750                                     fr->cbsz);
 751                                 bsz1 = fread(fr->buffer + fr->bsz, 1,
 752                                     READ_CHUNK, fr->file);
 753                                 if (bsz1 == 0) {
 754                                         if (ferror(fr->file))
 755                                                 err(2, NULL);
 756                                         break;
 757                                 }
 758                                 fr->bsz += bsz1;
 759                                 remsz += bsz1;
 760                         } else {
 761                                 if (remsz > 0 && fr->strbeg>0)
 762                                         bcopy(fr->buffer + fr->strbeg,
 763                                             fr->buffer, remsz);
 764
 765                                 fr->strbeg = 0;
 766                                 search_start = remsz;
 767                                 bsz1 = fread(fr->buffer + remsz, 1,
 768                                     fr->cbsz - remsz, fr->file);
 769                                 if (bsz1 == 0) {
 770                                         if (ferror(fr->file))
 771                                                 err(2, NULL);
 772                                         break;
 773                                 }
 774                                 fr->bsz = remsz + bsz1;
 775                                 remsz = fr->bsz;
 776                         }
 777                 }
 778
 779                 if (strend == NULL)
 780                         strend = fr->buffer + fr->bsz;
 781
 782                 if ((fr->buffer + fr->strbeg <= strend) &&
 783                     (fr->strbeg < fr->bsz) && (remsz>0))
 784                         ret = bwscsbdup(fr->buffer + fr->strbeg, strend -
 785                             fr->buffer - fr->strbeg);
 786
 787                 fr->strbeg = (strend - fr->buffer) + 1;
 788
 789         } else {
 790                 size_t len = 0;
 791
 792                 ret = bwsfgetln(fr->file, &len, sort_opts_vals.zflag,
 793                     &(fr->rb));
 794         }
 795
 796         return (ret);
 797 }
 798
 799 static void
 800 file_reader_clean(struct file_reader *fr)
 801 {
 802
 803         if (fr) {
 804                 if (fr->mmapaddr)
 805                         munmap(fr->mmapaddr, fr->mmapsize);
 806
 807                 if (fr->fd)
 808                         close(fr->fd);
 809
 810                 if (fr->buffer)
 811                         sort_free(fr->buffer);
 812
 813                 if (fr->file)
 814                         if (fr->file != stdin)
 815                                 closefile(fr->file, fr->fname);
 816
 817                 if(fr->fname)
 818                         sort_free(fr->fname);
 819
 820                 memset(fr, 0, sizeof(struct file_reader));
 821         }
 822 }
 823
 824 void
 825 file_reader_free(struct file_reader *fr)
 826 {
 827
 828         if (fr) {
 829                 file_reader_clean(fr);
 830                 sort_free(fr);
 831         }
 832 }
 833
 834 int
 835 procfile(const char *fsrc, struct sort_list *list, struct file_list *fl)
 836 {
 837         struct file_reader *fr;
 838
 839         fr = file_reader_init(fsrc);
 840         if (fr == NULL)
 841                 err(2, NULL);
 842
 843         /* file browse cycle */
 844         for (;;) {
 845                 struct bwstring *bws;
 846
 847                 bws = file_reader_readline(fr);
 848
 849                 if (bws == NULL)
 850                         break;
 851
 852                 sort_list_add(list, bws);
 853
 854                 if (list->memsize >= available_free_memory) {
 855                         char *fn;
 856
 857                         fn = new_tmp_file_name();
 858                         sort_list_to_file(list, fn);
 859                         file_list_add(fl, fn, false);
 860                         sort_list_clean(list);
 861                 }
 862         }
 863
 864         file_reader_free(fr);
 865
 866         return (0);
 867 }
 868
 869 /*
 870  * Compare file headers. Files with EOF always go to the end of the list.
 871  */
 872 static int
 873 file_header_cmp(struct file_header *f1, struct file_header *f2)
 874 {
 875
 876         if (f1 == f2)
 877                 return (0);
 878         else {
 879                 if (f1->fr == NULL) {
 880                         return ((f2->fr == NULL) ? 0 : +1);
 881                 } else if (f2->fr == NULL)
 882                         return (-1);
 883                 else {
 884                         int ret;
 885
 886                         ret = list_coll(&(f1->si), &(f2->si));
 887                         if (!ret)
 888                                 return ((f1->file_pos < f2->file_pos) ? -1 : +1);
 889                         return (ret);
 890                 }
 891         }
 892 }
 893
 894 /*
 895  * Allocate and init file header structure
 896  */
 897 static void
 898 file_header_init(struct file_header **fh, const char *fn, size_t file_pos)
 899 {
 900
 901         if (fh && fn) {
 902                 struct bwstring *line;
 903
 904                 *fh = sort_malloc(sizeof(struct file_header));
 905                 (*fh)->file_pos = file_pos;
 906                 (*fh)->fr = file_reader_init(fn);
 907                 if ((*fh)->fr == NULL) {
 908                         perror(fn);
 909                         err(2, "%s", getstr(8));
 910                 }
 911                 line = file_reader_readline((*fh)->fr);
 912                 if (line == NULL) {
 913                         file_reader_free((*fh)->fr);
 914                         (*fh)->fr = NULL;
 915                         (*fh)->si = NULL;
 916                 } else {
 917                         (*fh)->si = sort_list_item_alloc();
 918                         sort_list_item_set((*fh)->si, line);
 919                 }
 920         }
 921 }
 922
 923 /*
 924  * Close file
 925  */
 926 static void
 927 file_header_close(struct file_header **fh)
 928 {
 929
 930         if (fh && *fh) {
 931                 if ((*fh)->fr) {
 932                         file_reader_free((*fh)->fr);
 933                         (*fh)->fr = NULL;
 934                 }
 935                 if ((*fh)->si) {
 936                         sort_list_item_clean((*fh)->si);
 937                         sort_free((*fh)->si);
 938                         (*fh)->si = NULL;
 939                 }
 940                 sort_free(*fh);
 941                 *fh = NULL;
 942         }
 943 }
 944
 945 /*
 946  * Swap two array elements
 947  */
 948 static void
 949 file_header_swap(struct file_header **fh, size_t i1, size_t i2)
 950 {
 951         struct file_header *tmp;
 952
 953         tmp = fh[i1];
 954         fh[i1] = fh[i2];
 955         fh[i2] = tmp;
 956 }
 957
 958 /* heap algorithm ==>> */
 959
 960 /*
 961  * See heap sort algorithm
 962  * "Raises" last element to its right place
 963  */
 964 static void
 965 file_header_heap_swim(struct file_header **fh, size_t indx)
 966 {
 967
 968         if (indx > 0) {
 969                 size_t parent_index;
 970
 971                 parent_index = (indx - 1) >> 1;
 972
 973                 if (file_header_cmp(fh[indx], fh[parent_index]) < 0) {
 974                         /* swap child and parent and continue */
 975                         file_header_swap(fh, indx, parent_index);
 976                         file_header_heap_swim(fh, parent_index);
 977                 }
 978         }
 979 }
 980
 981 /*
 982  * Sink the top element to its correct position
 983  */
 984 static void
 985 file_header_heap_sink(struct file_header **fh, size_t indx, size_t size)
 986 {
 987         size_t left_child_index;
 988         size_t right_child_index;
 989
 990         left_child_index = indx + indx + 1;
 991         right_child_index = left_child_index + 1;
 992
 993         if (left_child_index < size) {
 994                 size_t min_child_index;
 995
 996                 min_child_index = left_child_index;
 997
 998                 if ((right_child_index < size) &&
 999                     (file_header_cmp(fh[left_child_index],
1000                     fh[right_child_index]) > 0))
1001                         min_child_index = right_child_index;
1002                 if (file_header_cmp(fh[indx], fh[min_child_index]) > 0) {
1003                         file_header_swap(fh, indx, min_child_index);
1004                         file_header_heap_sink(fh, min_child_index, size);
1005                 }
1006         }
1007 }
1008
1009 /* <<== heap algorithm */
1010
1011 /*
1012  * Adds element to the "left" end
1013  */
1014 static void
1015 file_header_list_rearrange_from_header(struct file_header **fh, size_t size)
1016 {
1017
1018         file_header_heap_sink(fh, 0, size);
1019 }
1020
1021 /*
1022  * Adds element to the "right" end
1023  */
1024 static void
1025 file_header_list_push(struct file_header *f, struct file_header **fh, size_t size)
1026 {
1027
1028         fh[size++] = f;
1029         file_header_heap_swim(fh, size - 1);
1030 }
1031
1032 struct last_printed
1033 {
1034         struct bwstring *str;
1035 };
1036
1037 /*
1038  * Prints the current line of the file
1039  */
1040 static void
1041 file_header_print(struct file_header *fh, FILE *f_out, struct last_printed *lp)
1042 {
1043
1044         if (fh && fh->fr && f_out && fh->si && fh->si->str) {
1045                 if (sort_opts_vals.uflag) {
1046                         if ((lp->str == NULL) || (str_list_coll(lp->str, &(fh->si)))) {
1047                                 bwsfwrite(fh->si->str, f_out, sort_opts_vals.zflag);
1048                                 if (lp->str)
1049                                         bwsfree(lp->str);
1050                                 lp->str = bwsdup(fh->si->str);
1051                         }
1052                 } else
1053                         bwsfwrite(fh->si->str, f_out, sort_opts_vals.zflag);
1054         }
1055 }
1056
1057 /*
1058  * Read next line
1059  */
1060 static void
1061 file_header_read_next(struct file_header *fh)
1062 {
1063
1064         if (fh && fh->fr) {
1065                 struct bwstring *tmp;
1066
1067                 tmp = file_reader_readline(fh->fr);
1068                 if (tmp == NULL) {
1069                         file_reader_free(fh->fr);
1070                         fh->fr = NULL;
1071                         if (fh->si) {
1072                                 sort_list_item_clean(fh->si);
1073                                 sort_free(fh->si);
1074                                 fh->si = NULL;
1075                         }
1076                 } else {
1077                         if (fh->si == NULL)
1078                                 fh->si = sort_list_item_alloc();
1079                         sort_list_item_set(fh->si, tmp);
1080                 }
1081         }
1082 }
1083
1084 /*
1085  * Merge array of "files headers"
1086  */
1087 static void
1088 file_headers_merge(size_t fnum, struct file_header **fh, FILE *f_out)
1089 {
1090         struct last_printed lp;
1091         size_t i;
1092
1093         memset(&lp, 0, sizeof(lp));
1094
1095         /*
1096          * construct the initial sort structure
1097          */
1098         for (i = 0; i < fnum; i++)
1099                 file_header_list_push(fh[i], fh, i);
1100
1101         while (fh[0]->fr) { /* unfinished files are always in front */
1102                 /* output the smallest line: */
1103                 file_header_print(fh[0], f_out, &lp);
1104                 /* read a new line, if possible: */
1105                 file_header_read_next(fh[0]);
1106                 /* re-arrange the list: */
1107                 file_header_list_rearrange_from_header(fh, fnum);
1108         }
1109
1110         if (lp.str)
1111                 bwsfree(lp.str);
1112 }
1113
1114 /*
1115  * Merges the given files into the output file, which can be
1116  * stdout.
1117  */
1118 static void
1119 merge_files_array(size_t argc, const char **argv, const char *fn_out)
1120 {
1121
1122         if (argv && fn_out) {
1123                 struct file_header **fh;
1124                 FILE *f_out;
1125                 size_t i;
1126
1127                 f_out = openfile(fn_out, "w");
1128
1129                 if (f_out == NULL)
1130                         err(2, NULL);
1131
1132                 fh = sort_malloc((argc + 1) * sizeof(struct file_header *));
1133
1134                 for (i = 0; i < argc; i++)
1135                         file_header_init(fh + i, argv[i], (size_t) i);
1136
1137                 file_headers_merge(argc, fh, f_out);
1138
1139                 for (i = 0; i < argc; i++)
1140                         file_header_close(fh + i);
1141
1142                 sort_free(fh);
1143
1144                 closefile(f_out, fn_out);
1145         }
1146 }
1147
1148 /*
1149  * Shrinks the file list until its size smaller than max number of opened files
1150  */
1151 static int
1152 shrink_file_list(struct file_list *fl)
1153 {
1154
1155         if ((fl == NULL) || (size_t) (fl->count) < max_open_files)
1156                 return (0);
1157         else {
1158                 struct file_list new_fl;
1159                 size_t indx = 0;
1160
1161                 file_list_init(&new_fl, true);
1162                 while (indx < fl->count) {
1163                         char *fnew;
1164                         size_t num;
1165
1166                         num = fl->count - indx;
1167                         fnew = new_tmp_file_name();
1168
1169                         if ((size_t) num >= max_open_files)
1170                                 num = max_open_files - 1;
1171                         merge_files_array(num, fl->fns + indx, fnew);
1172                         if (fl->tmp) {
1173                                 size_t i;
1174
1175                                 for (i = 0; i < num; i++)
1176                                         unlink(fl->fns[indx + i]);
1177                         }
1178                         file_list_add(&new_fl, fnew, false);
1179                         indx += num;
1180                 }
1181                 fl->tmp = false; /* already taken care of */
1182                 file_list_clean(fl);
1183
1184                 fl->count = new_fl.count;
1185                 fl->fns = new_fl.fns;
1186                 fl->sz = new_fl.sz;
1187                 fl->tmp = new_fl.tmp;
1188
1189                 return (1);
1190         }
1191 }
1192
1193 /*
1194  * Merge list of files
1195  */
1196 void
1197 merge_files(struct file_list *fl, const char *fn_out)
1198 {
1199
1200         if (fl && fn_out) {
1201                 while (shrink_file_list(fl));
1202
1203                 merge_files_array(fl->count, fl->fns, fn_out);
1204         }
1205 }
1206
1207 static const char *
1208 get_sort_method_name(int sm)
1209 {
1210
1211         if (sm == SORT_MERGESORT)
1212                 return "mergesort";
1213         else if (sort_opts_vals.sort_method == SORT_RADIXSORT)
1214                 return "radixsort";
1215         else if (sort_opts_vals.sort_method == SORT_HEAPSORT)
1216                 return "heapsort";
1217         else
1218                 return "quicksort";
1219 }
1220
1221 /*
1222  * Wrapper for qsort
1223  */
1224 static int sort_qsort(void *list, size_t count, size_t elem_size,
1225     int (*cmp_func)(const void *, const void *))
1226 {
1227
1228         qsort(list, count, elem_size, cmp_func);
1229         return (0);
1230 }
1231
1232 /*
1233  * Sort list of lines and writes it to the file
1234  */
1235 void
1236 sort_list_to_file(struct sort_list *list, const char *outfile)
1237 {
1238         struct sort_mods *sm = &(keys[0].sm);
1239
1240         if (!(sm->Mflag) && !(sm->Rflag) && !(sm->Vflag) && !(sm->Vflag) &&
1241             !(sm->gflag) && !(sm->hflag) && !(sm->nflag)) {
1242                 if ((sort_opts_vals.sort_method == SORT_DEFAULT) && byte_sort)
1243                         sort_opts_vals.sort_method = SORT_RADIXSORT;
1244
1245         } else if (sort_opts_vals.sort_method == SORT_RADIXSORT)
1246                 err(2, "%s", getstr(9));
1247
1248         /*
1249          * to handle stable sort and the unique cases in the
1250          * right order, we need stable basic algorithm
1251          */
1252         if (sort_opts_vals.sflag) {
1253                 switch (sort_opts_vals.sort_method){
1254                 case SORT_MERGESORT:
1255                         break;
1256                 case SORT_RADIXSORT:
1257                         break;
1258                 case SORT_DEFAULT:
1259                         sort_opts_vals.sort_method = SORT_MERGESORT;
1260                         break;
1261                 default:
1262                         errx(2, "%s", getstr(10));
1263                 }
1264         }
1265
1266         if (sort_opts_vals.sort_method == SORT_DEFAULT)
1267                 sort_opts_vals.sort_method = DEFAULT_SORT_ALGORITHM;
1268
1269         if (debug_sort)
1270                 printf("sort_method=%s\n",
1271                     get_sort_method_name(sort_opts_vals.sort_method));
1272
1273         switch (sort_opts_vals.sort_method){
1274         case SORT_RADIXSORT:
1275                 rxsort(list->list, list->count);
1276                 sort_list_dump(list, outfile);
1277                 break;
1278         case SORT_MERGESORT:
1279                 mt_sort(list, mergesort, outfile);
1280                 break;
1281         case SORT_HEAPSORT:
1282                 mt_sort(list, heapsort, outfile);
1283                 break;
1284         case SORT_QSORT:
1285                 mt_sort(list, sort_qsort, outfile);
1286                 break;
1287         default:
1288                 mt_sort(list, DEFAULT_SORT_FUNC, outfile);
1289                 break;
1290         }
1291 }
1292
1293 /******************* MT SORT ************************/
1294
1295 #if defined(SORT_THREADS)
1296 /* semaphore to count threads */
1297 static sem_t mtsem;
1298
1299 /* current system sort function */
1300 static int (*g_sort_func)(void *, size_t, size_t,
1301     int(*)(const void *, const void *));
1302
1303 /*
1304  * Sort cycle thread (in multi-threaded mode)
1305  */
1306 static void*
1307 mt_sort_thread(void* arg)
1308 {
1309         struct sort_list *list = arg;
1310
1311         g_sort_func(list->list, list->count, sizeof(struct sort_list_item *),
1312             (int(*)(const void *, const void *)) list_coll);
1313
1314         sem_post(&mtsem);
1315
1316         return (arg);
1317 }
1318
1319 /*
1320  * Compare sub-lists. Empty sub-lists always go to the end of the list.
1321  */
1322 static int
1323 sub_list_cmp(struct sort_list *l1, struct sort_list *l2)
1324 {
1325
1326         if (l1 == l2)
1327                 return (0);
1328         else {
1329                 if (l1->count == 0) {
1330                         return ((l2->count == 0) ? 0 : +1);
1331                 } else if (l2->count == 0) {
1332                         return (-1);
1333                 } else {
1334                         int ret;
1335
1336                         ret = list_coll(&(l1->list[0]), &(l2->list[0]));
1337                         if (!ret)
1338                                 return ((l1->sub_list_pos < l2->sub_list_pos) ?
1339                                     -1 : +1);
1340                         return (ret);
1341                 }
1342         }
1343 }
1344
1345 /*
1346  * Swap two array elements
1347  */
1348 static void
1349 sub_list_swap(struct sort_list **sl, size_t i1, size_t i2)
1350 {
1351         struct sort_list *tmp;
1352
1353         tmp = sl[i1];
1354         sl[i1] = sl[i2];
1355         sl[i2] = tmp;
1356 }
1357
1358 /* heap algorithm ==>> */
1359
1360 /*
1361  * See heap sort algorithm
1362  * "Raises" last element to its right place
1363  */
1364 static void
1365 sub_list_swim(struct sort_list **sl, size_t indx)
1366 {
1367
1368         if (indx > 0) {
1369                 size_t parent_index;
1370
1371                 parent_index = (indx - 1) >> 1;
1372
1373                 if (sub_list_cmp(sl[indx], sl[parent_index]) < 0) {
1374                         /* swap child and parent and continue */
1375                         sub_list_swap(sl, indx, parent_index);
1376                         sub_list_swim(sl, parent_index);
1377                 }
1378         }
1379 }
1380
1381 /*
1382  * Sink the top element to its correct position
1383  */
1384 static void
1385 sub_list_sink(struct sort_list **sl, size_t indx, size_t size)
1386 {
1387         size_t left_child_index;
1388         size_t right_child_index;
1389
1390         left_child_index = indx + indx + 1;
1391         right_child_index = left_child_index + 1;
1392
1393         if (left_child_index < size) {
1394                 size_t min_child_index;
1395
1396                 min_child_index = left_child_index;
1397
1398                 if ((right_child_index < size) &&
1399                     (sub_list_cmp(sl[left_child_index],
1400                     sl[right_child_index]) > 0))
1401                         min_child_index = right_child_index;
1402                 if (sub_list_cmp(sl[indx], sl[min_child_index]) > 0) {
1403                         sub_list_swap(sl, indx, min_child_index);
1404                         sub_list_sink(sl, min_child_index, size);
1405                 }
1406         }
1407 }
1408
1409 /* <<== heap algorithm */
1410
1411 /*
1412  * Adds element to the "right" end
1413  */
1414 static void
1415 sub_list_push(struct sort_list *s, struct sort_list **sl, size_t size)
1416 {
1417
1418         sl[size++] = s;
1419         sub_list_swim(sl, size - 1);
1420 }
1421
1422 struct last_printed_item
1423 {
1424         struct sort_list_item *item;
1425 };
1426
1427 /*
1428  * Prints the current line of the file
1429  */
1430 static void
1431 sub_list_header_print(struct sort_list *sl, FILE *f_out,
1432     struct last_printed_item *lp)
1433 {
1434
1435         if (sl && sl->count && f_out && sl->list[0]->str) {
1436                 if (sort_opts_vals.uflag) {
1437                         if ((lp->item == NULL) || (list_coll(&(lp->item),
1438                             &(sl->list[0])))) {
1439                                 bwsfwrite(sl->list[0]->str, f_out,
1440                                     sort_opts_vals.zflag);
1441                                 lp->item = sl->list[0];
1442                         }
1443                 } else
1444                         bwsfwrite(sl->list[0]->str, f_out,
1445                             sort_opts_vals.zflag);
1446         }
1447 }
1448
1449 /*
1450  * Read next line
1451  */
1452 static void
1453 sub_list_next(struct sort_list *sl)
1454 {
1455
1456         if (sl && sl->count) {
1457                 sl->list += 1;
1458                 sl->count -= 1;
1459         }
1460 }
1461
1462 /*
1463  * Merge sub-lists to a file
1464  */
1465 static void
1466 merge_sub_lists(struct sort_list **sl, size_t n, FILE* f_out)
1467 {
1468         struct last_printed_item lp;
1469         size_t i;
1470
1471         memset(&lp,0,sizeof(lp));
1472
1473         /* construct the initial list: */
1474         for (i = 0; i < n; i++)
1475                 sub_list_push(sl[i], sl, i);
1476
1477         while (sl[0]->count) { /* unfinished lists are always in front */
1478                 /* output the smallest line: */
1479                 sub_list_header_print(sl[0], f_out, &lp);
1480                 /* move to a new line, if possible: */
1481                 sub_list_next(sl[0]);
1482                 /* re-arrange the list: */
1483                 sub_list_sink(sl, 0, n);
1484         }
1485 }
1486
1487 /*
1488  * Merge sub-lists to a file
1489  */
1490 static void
1491 merge_list_parts(struct sort_list **parts, size_t n, const char *fn)
1492 {
1493         FILE* f_out;
1494
1495         f_out = openfile(fn,"w");
1496
1497         merge_sub_lists(parts, n, f_out);
1498
1499         closefile(f_out, fn);
1500 }
1501
1502 #endif /* defined(SORT_THREADS) */
1503 /*
1504  * Multi-threaded sort algorithm "driver"
1505  */
1506 static void
1507 mt_sort(struct sort_list *list,
1508     int(*sort_func)(void *, size_t, size_t, int(*)(const void *, const void *)),
1509     const char* fn)
1510 {
1511 #if defined(SORT_THREADS)
1512         if (nthreads < 2 || list->count < MT_SORT_THRESHOLD) {
1513                 size_t nthreads_save = nthreads;
1514                 nthreads = 1;
1515 #endif
1516                 /* if single thread or small data, do simple sort */
1517                 sort_func(list->list, list->count,
1518                     sizeof(struct sort_list_item *),
1519                     (int(*)(const void *, const void *)) list_coll);
1520                 sort_list_dump(list, fn);
1521 #if defined(SORT_THREADS)
1522                 nthreads = nthreads_save;
1523         } else {
1524                 /* multi-threaded sort */
1525                 struct sort_list **parts;
1526                 size_t avgsize, cstart, i;
1527
1528                 /* array of sub-lists */
1529                 parts = sort_malloc(sizeof(struct sort_list*) * nthreads);
1530                 cstart = 0;
1531                 avgsize = list->count / nthreads;
1532
1533                 /* set global system sort function */
1534                 g_sort_func = sort_func;
1535
1536                 /* set sublists */
1537                 for (i = 0; i < nthreads; ++i) {
1538                         size_t sz = 0;
1539
1540                         parts[i] = sort_malloc(sizeof(struct sort_list));
1541                         parts[i]->list = list->list + cstart;
1542                         parts[i]->memsize = 0;
1543                         parts[i]->sub_list_pos = i;
1544
1545                         sz = (i == nthreads - 1) ? list->count - cstart :
1546                             avgsize;
1547
1548                         parts[i]->count = sz;
1549
1550                         parts[i]->size = parts[i]->count;
1551
1552                         cstart += sz;
1553                 }
1554
1555                 /* init threads counting semaphore */
1556                 sem_init(&mtsem, 0, 0);
1557
1558                 /* start threads */
1559                 for (i = 0; i < nthreads; ++i) {
1560                         pthread_t pth;
1561                         pthread_attr_t attr;
1562
1563                         pthread_attr_init(&attr);
1564                         pthread_attr_setdetachstate(&attr, PTHREAD_DETACHED);
1565
1566                         for (;;) {
1567                                 int res = pthread_create(&pth, &attr,
1568                                     mt_sort_thread, parts[i]);
1569
1570                                 if (res >= 0)
1571                                         break;
1572                                 if (errno == EAGAIN) {
1573                                         pthread_yield();
1574                                         continue;
1575                                 }
1576                                 err(2, NULL);
1577                         }
1578
1579                         pthread_attr_destroy(&attr);
1580                 }
1581
1582                 /* wait for threads completion */
1583                 for (i = 0; i < nthreads; ++i) {
1584                         sem_wait(&mtsem);
1585                 }
1586                 /* destroy the semaphore - we do not need it anymore */
1587                 sem_destroy(&mtsem);
1588
1589                 /* merge sorted sub-lists to the file */
1590                 merge_list_parts(parts, nthreads, fn);
1591
1592                 /* free sub-lists data */
1593                 for (i = 0; i < nthreads; ++i) {
1594                         sort_free(parts[i]);
1595                 }
1596                 sort_free(parts);
1597         }
1598 #endif /* defined(SORT_THREADS) */
1599 }