1 /* CTF archive files. 2 Copyright (C) 2019-2020 Free Software Foundation, Inc. 3 4 This file is part of libctf. 5 6 libctf is free software; you can redistribute it and/or modify it under 7 the terms of the GNU General Public License as published by the Free 8 Software Foundation; either version 3, or (at your option) any later 9 version. 10 11 This program is distributed in the hope that it will be useful, but 12 WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 14 See the GNU General Public License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with this program; see the file COPYING. If not see 18 <http://www.gnu.org/licenses/>. */ 19 20 #include <ctf-impl.h> 21 #include <sys/types.h> 22 #include <sys/stat.h> 23 #include <elf.h> 24 #include "ctf-endian.h" 25 #include <errno.h> 26 #include <fcntl.h> 27 #include <stdio.h> 28 #include <string.h> 29 #include <unistd.h> 30 31 #ifdef HAVE_MMAP 32 #include <sys/mman.h> 33 #endif 34 35 static off_t arc_write_one_ctf (ctf_file_t * f, int fd, size_t threshold); 36 static ctf_file_t *ctf_arc_open_by_offset (const struct ctf_archive *arc, 37 const ctf_sect_t *symsect, 38 const ctf_sect_t *strsect, 39 size_t offset, int *errp); 40 static int sort_modent_by_name (const void *one, const void *two, void *n); 41 static void *arc_mmap_header (int fd, size_t headersz); 42 static void *arc_mmap_file (int fd, size_t size); 43 static int arc_mmap_writeout (int fd, void *header, size_t headersz, 44 const char **errmsg); 45 static int arc_mmap_unmap (void *header, size_t headersz, const char **errmsg); 46 47 /* bsearch() internal state. */ 48 static __thread char *search_nametbl; 49 50 /* Write out a CTF archive to the start of the file referenced by the passed-in 51 fd. The entries in CTF_FILES are referenced by name: the names are passed in 52 the names array, which must have CTF_FILES entries. 53 54 Returns 0 on success, or an errno, or an ECTF_* value. */ 55 int 56 ctf_arc_write_fd (int fd, ctf_file_t **ctf_files, size_t ctf_file_cnt, 57 const char **names, size_t threshold) 58 { 59 const char *errmsg; 60 struct ctf_archive *archdr; 61 size_t i; 62 char dummy = 0; 63 size_t headersz; 64 ssize_t namesz; 65 size_t ctf_startoffs; /* Start of the section we are working over. */ 66 char *nametbl = NULL; /* The name table. */ 67 char *np; 68 off_t nameoffs; 69 struct ctf_archive_modent *modent; 70 71 ctf_dprintf ("Writing CTF archive with %lu files\n", 72 (unsigned long) ctf_file_cnt); 73 74 /* Figure out the size of the mmap()ed header, including the 75 ctf_archive_modent array. We assume that all of this needs no 76 padding: a likely assumption, given that it's all made up of 77 uint64_t's. */ 78 headersz = sizeof (struct ctf_archive) 79 + (ctf_file_cnt * sizeof (uint64_t) * 2); 80 ctf_dprintf ("headersz is %lu\n", (unsigned long) headersz); 81 82 /* From now on we work in two pieces: an mmap()ed region from zero up to the 83 headersz, and a region updated via write() starting after that, containing 84 all the tables. Platforms that do not support mmap() just use write(). */ 85 ctf_startoffs = headersz; 86 if (lseek (fd, ctf_startoffs - 1, SEEK_SET) < 0) 87 { 88 errmsg = "ctf_arc_write(): cannot extend file while writing: %s\n"; 89 goto err; 90 } 91 92 if (write (fd, &dummy, 1) < 0) 93 { 94 errmsg = "ctf_arc_write(): cannot extend file while writing: %s\n"; 95 goto err; 96 } 97 98 if ((archdr = arc_mmap_header (fd, headersz)) == NULL) 99 { 100 errmsg = "ctf_arc_write(): Cannot mmap(): %s\n"; 101 goto err; 102 } 103 104 /* Fill in everything we can, which is everything other than the name 105 table offset. */ 106 archdr->ctfa_magic = htole64 (CTFA_MAGIC); 107 archdr->ctfa_nfiles = htole64 (ctf_file_cnt); 108 archdr->ctfa_ctfs = htole64 (ctf_startoffs); 109 110 /* We could validate that all CTF files have the same data model, but 111 since any reasonable construction process will be building things of 112 only one bitness anyway, this is pretty pointless, so just use the 113 model of the first CTF file for all of them. (It *is* valid to 114 create an empty archive: the value of ctfa_model is irrelevant in 115 this case, but we must be sure not to dereference uninitialized 116 memory.) */ 117 118 if (ctf_file_cnt > 0) 119 archdr->ctfa_model = htole64 (ctf_getmodel (ctf_files[0])); 120 121 /* Now write out the CTFs: ctf_archive_modent array via the mapping, 122 ctfs via write(). The names themselves have not been written yet: we 123 track them in a local strtab until the time is right, and sort the 124 modents array after construction. 125 126 The name table is not sorted. */ 127 128 for (i = 0, namesz = 0; i < le64toh (archdr->ctfa_nfiles); i++) 129 namesz += strlen (names[i]) + 1; 130 131 nametbl = malloc (namesz); 132 if (nametbl == NULL) 133 { 134 errmsg = "Error writing named CTF to archive: %s\n"; 135 goto err_unmap; 136 } 137 138 for (i = 0, namesz = 0, 139 modent = (ctf_archive_modent_t *) ((char *) archdr 140 + sizeof (struct ctf_archive)); 141 i < le64toh (archdr->ctfa_nfiles); i++) 142 { 143 off_t off; 144 145 strcpy (&nametbl[namesz], names[i]); 146 147 off = arc_write_one_ctf (ctf_files[i], fd, threshold); 148 if ((off < 0) && (off > -ECTF_BASE)) 149 { 150 errmsg = "ctf_arc_write(): Cannot determine file " 151 "position while writing to archive: %s"; 152 goto err_free; 153 } 154 if (off < 0) 155 { 156 errmsg = "ctf_arc_write(): Cannot write CTF file to archive: %s\n"; 157 errno = off * -1; 158 goto err_free; 159 } 160 161 modent->name_offset = htole64 (namesz); 162 modent->ctf_offset = htole64 (off - ctf_startoffs); 163 namesz += strlen (names[i]) + 1; 164 modent++; 165 } 166 167 ctf_qsort_r ((ctf_archive_modent_t *) ((char *) archdr 168 + sizeof (struct ctf_archive)), 169 le64toh (archdr->ctfa_nfiles), 170 sizeof (struct ctf_archive_modent), sort_modent_by_name, 171 nametbl); 172 173 /* Now the name table. */ 174 175 if ((nameoffs = lseek (fd, 0, SEEK_CUR)) < 0) 176 { 177 errmsg = "ctf_arc_write(): Cannot get current file position " 178 "in archive: %s\n"; 179 goto err_free; 180 } 181 archdr->ctfa_names = htole64 (nameoffs); 182 np = nametbl; 183 while (namesz > 0) 184 { 185 ssize_t len; 186 if ((len = write (fd, np, namesz)) < 0) 187 { 188 errmsg = "ctf_arc_write(): Cannot write name table to archive: %s\n"; 189 goto err_free; 190 } 191 namesz -= len; 192 np += len; 193 } 194 free (nametbl); 195 196 if (arc_mmap_writeout (fd, archdr, headersz, &errmsg) < 0) 197 goto err_unmap; 198 if (arc_mmap_unmap (archdr, headersz, &errmsg) < 0) 199 goto err; 200 return 0; 201 202 err_free: 203 free (nametbl); 204 err_unmap: 205 arc_mmap_unmap (archdr, headersz, NULL); 206 err: 207 ctf_dprintf (errmsg, errno < ECTF_BASE ? strerror (errno) : 208 ctf_errmsg (errno)); 209 return errno; 210 } 211 212 /* Write out a CTF archive. The entries in CTF_FILES are referenced by name: 213 the names are passed in the names array, which must have CTF_FILES entries. 214 215 If the filename is NULL, create a temporary file and return a pointer to it. 216 217 Returns 0 on success, or an errno, or an ECTF_* value. */ 218 int 219 ctf_arc_write (const char *file, ctf_file_t ** ctf_files, size_t ctf_file_cnt, 220 const char **names, size_t threshold) 221 { 222 int err; 223 int fd; 224 225 if ((fd = open (file, O_RDWR | O_CREAT | O_TRUNC | O_CLOEXEC, 0666)) < 0) 226 { 227 ctf_dprintf ("ctf_arc_write(): cannot create %s: %s\n", file, 228 strerror (errno)); 229 return errno; 230 } 231 232 err = ctf_arc_write_fd (fd, ctf_files, ctf_file_cnt, names, threshold); 233 if (err) 234 goto err; 235 236 if ((err = close (fd)) < 0) 237 { 238 ctf_dprintf ("ctf_arc_write(): Cannot close after writing to archive: " 239 "%s\n", strerror (errno)); 240 goto err_close; 241 } 242 243 err: 244 close (fd); 245 if (err < 0) 246 unlink (file); 247 248 return err; 249 250 err_close: 251 if (err < 0) 252 unlink (file); 253 254 return err; 255 } 256 257 /* Write one CTF file out. Return the file position of the written file (or 258 rather, of the file-size uint64_t that precedes it): negative return is a 259 negative errno or ctf_errno value. On error, the file position may no longer 260 be at the end of the file. */ 261 static off_t 262 arc_write_one_ctf (ctf_file_t * f, int fd, size_t threshold) 263 { 264 off_t off, end_off; 265 uint64_t ctfsz = 0; 266 char *ctfszp; 267 size_t ctfsz_len; 268 int (*writefn) (ctf_file_t * fp, int fd); 269 270 if (ctf_serialize (f) < 0) 271 return f->ctf_errno * -1; 272 273 if ((off = lseek (fd, 0, SEEK_CUR)) < 0) 274 return errno * -1; 275 276 if (f->ctf_size > threshold) 277 writefn = ctf_compress_write; 278 else 279 writefn = ctf_write; 280 281 /* This zero-write turns into the size in a moment. */ 282 ctfsz_len = sizeof (ctfsz); 283 ctfszp = (char *) &ctfsz; 284 while (ctfsz_len > 0) 285 { 286 ssize_t writelen = write (fd, ctfszp, ctfsz_len); 287 if (writelen < 0) 288 return errno * -1; 289 ctfsz_len -= writelen; 290 ctfszp += writelen; 291 } 292 293 if (writefn (f, fd) != 0) 294 return f->ctf_errno * -1; 295 296 if ((end_off = lseek (fd, 0, SEEK_CUR)) < 0) 297 return errno * -1; 298 ctfsz = htole64 (end_off - off); 299 300 if ((lseek (fd, off, SEEK_SET)) < 0) 301 return errno * -1; 302 303 /* ... here. */ 304 ctfsz_len = sizeof (ctfsz); 305 ctfszp = (char *) &ctfsz; 306 while (ctfsz_len > 0) 307 { 308 ssize_t writelen = write (fd, ctfszp, ctfsz_len); 309 if (writelen < 0) 310 return errno * -1; 311 ctfsz_len -= writelen; 312 ctfszp += writelen; 313 } 314 315 end_off = LCTF_ALIGN_OFFS (end_off, 8); 316 if ((lseek (fd, end_off, SEEK_SET)) < 0) 317 return errno * -1; 318 319 return off; 320 } 321 322 /* qsort() function to sort the array of struct ctf_archive_modents into 323 ascending name order. */ 324 static int 325 sort_modent_by_name (const void *one, const void *two, void *n) 326 { 327 const struct ctf_archive_modent *a = one; 328 const struct ctf_archive_modent *b = two; 329 char *nametbl = n; 330 331 return strcmp (&nametbl[le64toh (a->name_offset)], 332 &nametbl[le64toh (b->name_offset)]); 333 } 334 335 /* bsearch() function to search for a given name in the sorted array of struct 336 ctf_archive_modents. */ 337 static int 338 search_modent_by_name (const void *key, const void *ent) 339 { 340 const char *k = key; 341 const struct ctf_archive_modent *v = ent; 342 343 return strcmp (k, &search_nametbl[le64toh (v->name_offset)]); 344 } 345 346 /* A trivial wrapper: open a CTF archive, from data in a buffer (which the 347 caller must preserve until ctf_arc_close() time). Returns the archive, or 348 NULL and an error in *err (if not NULL). */ 349 struct ctf_archive * 350 ctf_arc_bufopen (const void *buf, size_t size _libctf_unused_, int *errp) 351 { 352 struct ctf_archive *arc = (struct ctf_archive *) buf; 353 354 if (le64toh (arc->ctfa_magic) != CTFA_MAGIC) 355 { 356 if (errp) 357 *errp = ECTF_FMT; 358 return NULL; 359 } 360 return arc; 361 } 362 363 /* Open a CTF archive. Returns the archive, or NULL and an error in *err (if 364 not NULL). */ 365 struct ctf_archive * 366 ctf_arc_open_internal (const char *filename, int *errp) 367 { 368 const char *errmsg; 369 int fd; 370 struct stat s; 371 struct ctf_archive *arc; /* (Actually the whole file.) */ 372 373 libctf_init_debug(); 374 if ((fd = open (filename, O_RDONLY)) < 0) 375 { 376 errmsg = "ctf_arc_open(): cannot open %s: %s\n"; 377 goto err; 378 } 379 if (fstat (fd, &s) < 0) 380 { 381 errmsg = "ctf_arc_open(): cannot stat %s: %s\n"; 382 goto err_close; 383 } 384 385 if ((arc = arc_mmap_file (fd, s.st_size)) == NULL) 386 { 387 errmsg = "ctf_arc_open(): Cannot read in %s: %s\n"; 388 goto err_close; 389 } 390 391 if (le64toh (arc->ctfa_magic) != CTFA_MAGIC) 392 { 393 errmsg = "ctf_arc_open(): Invalid magic number"; 394 errno = ECTF_FMT; 395 goto err_unmap; 396 } 397 398 /* This horrible hack lets us know how much to unmap when the file is 399 closed. (We no longer need the magic number, and the mapping 400 is private.) */ 401 arc->ctfa_magic = s.st_size; 402 close (fd); 403 return arc; 404 405 err_unmap: 406 arc_mmap_unmap (arc, s.st_size, NULL); 407 err_close: 408 close (fd); 409 err: 410 if (errp) 411 *errp = errno; 412 ctf_dprintf (errmsg, filename, errno < ECTF_BASE ? strerror (errno) : 413 ctf_errmsg (errno)); 414 return NULL; 415 } 416 417 /* Close an archive. */ 418 void 419 ctf_arc_close_internal (struct ctf_archive *arc) 420 { 421 if (arc == NULL) 422 return; 423 424 /* See the comment in ctf_arc_open(). */ 425 arc_mmap_unmap (arc, arc->ctfa_magic, NULL); 426 } 427 428 /* Public entry point: close an archive, or CTF file. */ 429 void 430 ctf_arc_close (ctf_archive_t *arc) 431 { 432 if (arc == NULL) 433 return; 434 435 if (arc->ctfi_is_archive) 436 ctf_arc_close_internal (arc->ctfi_archive); 437 else 438 ctf_file_close (arc->ctfi_file); 439 free ((void *) arc->ctfi_symsect.cts_data); 440 /* Do not free the ctfi_strsect: it is bound to the bfd. */ 441 free (arc->ctfi_data); 442 if (arc->ctfi_bfd_close) 443 arc->ctfi_bfd_close (arc); 444 free (arc); 445 } 446 447 /* Return the ctf_file_t with the given name, or NULL if none, setting 'err' if 448 non-NULL. A name of NULL means to open the default file. */ 449 static ctf_file_t * 450 ctf_arc_open_by_name_internal (const struct ctf_archive *arc, 451 const ctf_sect_t *symsect, 452 const ctf_sect_t *strsect, 453 const char *name, int *errp) 454 { 455 struct ctf_archive_modent *modent; 456 457 if (name == NULL) 458 name = _CTF_SECTION; /* The default name. */ 459 460 ctf_dprintf ("ctf_arc_open_by_name(%s): opening\n", name); 461 462 modent = (ctf_archive_modent_t *) ((char *) arc 463 + sizeof (struct ctf_archive)); 464 465 search_nametbl = (char *) arc + le64toh (arc->ctfa_names); 466 modent = bsearch (name, modent, le64toh (arc->ctfa_nfiles), 467 sizeof (struct ctf_archive_modent), 468 search_modent_by_name); 469 470 /* This is actually a common case and normal operation: no error 471 debug output. */ 472 if (modent == NULL) 473 { 474 if (errp) 475 *errp = ECTF_ARNNAME; 476 return NULL; 477 } 478 479 return ctf_arc_open_by_offset (arc, symsect, strsect, 480 le64toh (modent->ctf_offset), errp); 481 } 482 483 /* Return the ctf_file_t with the given name, or NULL if none, setting 'err' if 484 non-NULL. A name of NULL means to open the default file. 485 486 Use the specified string and symbol table sections. 487 488 Public entry point. */ 489 ctf_file_t * 490 ctf_arc_open_by_name_sections (const ctf_archive_t *arc, 491 const ctf_sect_t *symsect, 492 const ctf_sect_t *strsect, 493 const char *name, 494 int *errp) 495 { 496 if (arc->ctfi_is_archive) 497 { 498 ctf_file_t *ret; 499 ret = ctf_arc_open_by_name_internal (arc->ctfi_archive, symsect, strsect, 500 name, errp); 501 if (ret) 502 ret->ctf_archive = (ctf_archive_t *) arc; 503 return ret; 504 } 505 506 if ((name != NULL) && (strcmp (name, _CTF_SECTION) != 0)) 507 { 508 if (errp) 509 *errp = ECTF_ARNNAME; 510 return NULL; 511 } 512 arc->ctfi_file->ctf_archive = (ctf_archive_t *) arc; 513 514 /* Bump the refcount so that the user can ctf_file_close() it. */ 515 arc->ctfi_file->ctf_refcnt++; 516 return arc->ctfi_file; 517 } 518 519 /* Return the ctf_file_t with the given name, or NULL if none, setting 'err' if 520 non-NULL. A name of NULL means to open the default file. 521 522 Public entry point. */ 523 ctf_file_t * 524 ctf_arc_open_by_name (const ctf_archive_t *arc, const char *name, int *errp) 525 { 526 const ctf_sect_t *symsect = &arc->ctfi_symsect; 527 const ctf_sect_t *strsect = &arc->ctfi_strsect; 528 529 if (symsect->cts_name == NULL) 530 symsect = NULL; 531 if (strsect->cts_name == NULL) 532 strsect = NULL; 533 534 return ctf_arc_open_by_name_sections (arc, symsect, strsect, name, errp); 535 } 536 537 /* Return the ctf_file_t at the given ctfa_ctfs-relative offset, or NULL if 538 none, setting 'err' if non-NULL. */ 539 static ctf_file_t * 540 ctf_arc_open_by_offset (const struct ctf_archive *arc, 541 const ctf_sect_t *symsect, 542 const ctf_sect_t *strsect, size_t offset, 543 int *errp) 544 { 545 ctf_sect_t ctfsect; 546 ctf_file_t *fp; 547 548 ctf_dprintf ("ctf_arc_open_by_offset(%lu): opening\n", (unsigned long) offset); 549 550 memset (&ctfsect, 0, sizeof (ctf_sect_t)); 551 552 offset += le64toh (arc->ctfa_ctfs); 553 554 ctfsect.cts_name = _CTF_SECTION; 555 ctfsect.cts_size = le64toh (*((uint64_t *) ((char *) arc + offset))); 556 ctfsect.cts_entsize = 1; 557 ctfsect.cts_data = (void *) ((char *) arc + offset + sizeof (uint64_t)); 558 fp = ctf_bufopen (&ctfsect, symsect, strsect, errp); 559 if (fp) 560 ctf_setmodel (fp, le64toh (arc->ctfa_model)); 561 return fp; 562 } 563 564 /* Raw iteration over all CTF files in an archive. We pass the raw data for all 565 CTF files in turn to the specified callback function. */ 566 static int 567 ctf_archive_raw_iter_internal (const struct ctf_archive *arc, 568 ctf_archive_raw_member_f *func, void *data) 569 { 570 int rc; 571 size_t i; 572 struct ctf_archive_modent *modent; 573 const char *nametbl; 574 575 modent = (ctf_archive_modent_t *) ((char *) arc 576 + sizeof (struct ctf_archive)); 577 nametbl = (((const char *) arc) + le64toh (arc->ctfa_names)); 578 579 for (i = 0; i < le64toh (arc->ctfa_nfiles); i++) 580 { 581 const char *name; 582 char *fp; 583 584 name = &nametbl[le64toh (modent[i].name_offset)]; 585 fp = ((char *) arc + le64toh (arc->ctfa_ctfs) 586 + le64toh (modent[i].ctf_offset)); 587 588 if ((rc = func (name, (void *) (fp + sizeof (uint64_t)), 589 le64toh (*((uint64_t *) fp)), data)) != 0) 590 return rc; 591 } 592 return 0; 593 } 594 595 /* Raw iteration over all CTF files in an archive: public entry point. 596 597 Returns -EINVAL if not supported for this sort of archive. */ 598 int 599 ctf_archive_raw_iter (const ctf_archive_t *arc, 600 ctf_archive_raw_member_f * func, void *data) 601 { 602 if (arc->ctfi_is_archive) 603 return ctf_archive_raw_iter_internal (arc->ctfi_archive, func, data); 604 605 return -EINVAL; /* Not supported. */ 606 } 607 608 /* Iterate over all CTF files in an archive. We pass all CTF files in turn to 609 the specified callback function. */ 610 static int 611 ctf_archive_iter_internal (const ctf_archive_t *wrapper, 612 const struct ctf_archive *arc, 613 const ctf_sect_t *symsect, 614 const ctf_sect_t *strsect, 615 ctf_archive_member_f *func, void *data) 616 { 617 int rc; 618 size_t i; 619 ctf_file_t *f; 620 struct ctf_archive_modent *modent; 621 const char *nametbl; 622 623 modent = (ctf_archive_modent_t *) ((char *) arc 624 + sizeof (struct ctf_archive)); 625 nametbl = (((const char *) arc) + le64toh (arc->ctfa_names)); 626 627 for (i = 0; i < le64toh (arc->ctfa_nfiles); i++) 628 { 629 const char *name; 630 631 name = &nametbl[le64toh (modent[i].name_offset)]; 632 if ((f = ctf_arc_open_by_name_internal (arc, symsect, strsect, 633 name, &rc)) == NULL) 634 return rc; 635 636 f->ctf_archive = (ctf_archive_t *) wrapper; 637 if ((rc = func (f, name, data)) != 0) 638 { 639 ctf_file_close (f); 640 return rc; 641 } 642 643 ctf_file_close (f); 644 } 645 return 0; 646 } 647 648 /* Iterate over all CTF files in an archive: public entry point. We pass all 649 CTF files in turn to the specified callback function. */ 650 int 651 ctf_archive_iter (const ctf_archive_t *arc, ctf_archive_member_f *func, 652 void *data) 653 { 654 const ctf_sect_t *symsect = &arc->ctfi_symsect; 655 const ctf_sect_t *strsect = &arc->ctfi_strsect; 656 657 if (symsect->cts_name == NULL) 658 symsect = NULL; 659 if (strsect->cts_name == NULL) 660 strsect = NULL; 661 662 if (arc->ctfi_is_archive) 663 return ctf_archive_iter_internal (arc, arc->ctfi_archive, symsect, strsect, 664 func, data); 665 666 return func (arc->ctfi_file, _CTF_SECTION, data); 667 } 668 669 #ifdef HAVE_MMAP 670 /* Map the header in. Only used on new, empty files. */ 671 static void *arc_mmap_header (int fd, size_t headersz) 672 { 673 void *hdr; 674 if ((hdr = mmap (NULL, headersz, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 675 0)) == MAP_FAILED) 676 return NULL; 677 return hdr; 678 } 679 680 /* mmap() the whole file, for reading only. (Map it writably, but privately: we 681 need to modify the region, but don't need anyone else to see the 682 modifications.) */ 683 static void *arc_mmap_file (int fd, size_t size) 684 { 685 void *arc; 686 if ((arc = mmap (NULL, size, PROT_READ | PROT_WRITE, MAP_PRIVATE, 687 fd, 0)) == MAP_FAILED) 688 return NULL; 689 return arc; 690 } 691 692 /* Persist the header to disk. */ 693 static int arc_mmap_writeout (int fd _libctf_unused_, void *header, 694 size_t headersz, const char **errmsg) 695 { 696 if (msync (header, headersz, MS_ASYNC) < 0) 697 { 698 if (errmsg) 699 *errmsg = "arc_mmap_writeout(): Cannot sync after writing to %s: %s\n"; 700 return -1; 701 } 702 return 0; 703 } 704 705 /* Unmap the region. */ 706 static int arc_mmap_unmap (void *header, size_t headersz, const char **errmsg) 707 { 708 if (munmap (header, headersz) < 0) 709 { 710 if (errmsg) 711 *errmsg = "arc_mmap_munmap(): Cannot unmap after writing to %s: %s\n"; 712 return -1; 713 } 714 return 0; 715 } 716 #else 717 /* Map the header in. Only used on new, empty files. */ 718 static void *arc_mmap_header (int fd _libctf_unused_, size_t headersz) 719 { 720 void *hdr; 721 if ((hdr = malloc (headersz)) == NULL) 722 return NULL; 723 return hdr; 724 } 725 726 /* Pull in the whole file, for reading only. We assume the current file 727 position is at the start of the file. */ 728 static void *arc_mmap_file (int fd, size_t size) 729 { 730 char *data; 731 732 if ((data = malloc (size)) == NULL) 733 return NULL; 734 735 if (ctf_pread (fd, data, size, 0) < 0) 736 { 737 free (data); 738 return NULL; 739 } 740 return data; 741 } 742 743 /* Persist the header to disk. */ 744 static int arc_mmap_writeout (int fd, void *header, size_t headersz, 745 const char **errmsg) 746 { 747 ssize_t len; 748 size_t acc = 0; 749 char *data = (char *) header; 750 ssize_t count = headersz; 751 752 if ((lseek (fd, 0, SEEK_SET)) < 0) 753 { 754 if (errmsg) 755 *errmsg = "arc_mmap_writeout(): Cannot seek while writing header to " 756 "%s: %s\n"; 757 return -1; 758 } 759 760 while (headersz > 0) 761 { 762 if ((len = write (fd, data, count)) < 0) 763 { 764 if (errmsg) 765 *errmsg = "arc_mmap_writeout(): Cannot write header to %s: %s\n"; 766 return len; 767 } 768 if (len == EINTR) 769 continue; 770 771 acc += len; 772 if (len == 0) /* EOF. */ 773 break; 774 775 count -= len; 776 data += len; 777 } 778 return 0; 779 } 780 781 /* Unmap the region. */ 782 static int arc_mmap_unmap (void *header, size_t headersz _libctf_unused_, 783 const char **errmsg _libctf_unused_) 784 { 785 free (header); 786 return 0; 787 } 788 #endif 789