X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gold%2Ffileread.cc;h=c4ab6b7d04e9d3d3c3971466c424f6029c681913;hb=c1b5c1ebc938b6dc0277363b8c47d75b0b5a621f;hp=4e8157f7957c33cfb786ca9b693319e6eaa74774;hpb=114dfbe13efea1a1405dbcf5d9254e59d309382f;p=deliverable%2Fbinutils-gdb.git diff --git a/gold/fileread.cc b/gold/fileread.cc index 4e8157f795..c4ab6b7d04 100644 --- a/gold/fileread.cc +++ b/gold/fileread.cc @@ -1,6 +1,6 @@ // fileread.cc -- read files for gold -// Copyright 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc. +// Copyright (C) 2006-2019 Free Software Foundation, Inc. // Written by Ian Lance Taylor . // This file is part of gold. @@ -24,10 +24,18 @@ #include #include +#include #include #include + +#ifdef HAVE_SYS_MMAN_H #include +#endif + +#ifdef HAVE_READV #include +#endif + #include #include "filenames.h" @@ -41,8 +49,42 @@ #include "gold-threads.h" #include "fileread.h" +// For systems without mmap support. +#ifndef HAVE_MMAP +# define mmap gold_mmap +# define munmap gold_munmap +# ifndef MAP_FAILED +# define MAP_FAILED (reinterpret_cast(-1)) +# endif +# ifndef PROT_READ +# define PROT_READ 0 +# endif +# ifndef MAP_PRIVATE +# define MAP_PRIVATE 0 +# endif + +# ifndef ENOSYS +# define ENOSYS EINVAL +# endif + +static void * +gold_mmap(void *, size_t, int, int, int, off_t) +{ + errno = ENOSYS; + return MAP_FAILED; +} + +static int +gold_munmap(void *, size_t) +{ + errno = ENOSYS; + return -1; +} + +#endif + #ifndef HAVE_READV -struct iovec { void* iov_base; size_t iov_len }; +struct iovec { void* iov_base; size_t iov_len; }; ssize_t readv(int, const iovec*, int) { @@ -53,6 +95,36 @@ readv(int, const iovec*, int) namespace gold { +// Get the last modified time of an unopened file. + +bool +get_mtime(const char* filename, Timespec* mtime) +{ + struct stat file_stat; + + if (stat(filename, &file_stat) < 0) + return false; +#ifdef HAVE_STAT_ST_MTIM + mtime->seconds = file_stat.st_mtim.tv_sec; + mtime->nanoseconds = file_stat.st_mtim.tv_nsec; +#else + mtime->seconds = file_stat.st_mtime; + mtime->nanoseconds = 0; +#endif + return true; +} + +// Class File_read. + +// A lock for the File_read static variables. +static Lock* file_counts_lock = NULL; +static Initialize_lock file_counts_initialize_lock(&file_counts_lock); + +// The File_read static variables. +unsigned long long File_read::total_mapped_bytes; +unsigned long long File_read::current_mapped_bytes; +unsigned long long File_read::maximum_mapped_bytes; + // Class File_read::View. File_read::View::~View() @@ -61,12 +133,17 @@ File_read::View::~View() switch (this->data_ownership_) { case DATA_ALLOCATED_ARRAY: - delete[] this->data_; + free(const_cast(this->data_)); break; case DATA_MMAPPED: if (::munmap(const_cast(this->data_), this->size_) != 0) - gold_warning(_("munmap failed: %s"), strerror(errno)); - File_read::current_mapped_bytes -= this->size_; + gold_warning(_("munmap failed: %s"), strerror(errno)); + if (!parameters->options_valid() || parameters->options().stats()) + { + file_counts_initialize_lock.initialize(); + Hold_optional_lock hl(file_counts_lock); + File_read::current_mapped_bytes -= this->size_; + } break; case DATA_NOT_OWNED: break; @@ -96,15 +173,6 @@ File_read::View::is_locked() // Class File_read. -// A lock for the File_read static variables. -static Lock* file_counts_lock = NULL; -static Initialize_lock file_counts_initialize_lock(&file_counts_lock); - -// The File_read static variables. -unsigned long long File_read::total_mapped_bytes; -unsigned long long File_read::current_mapped_bytes; -unsigned long long File_read::maximum_mapped_bytes; - File_read::~File_read() { gold_assert(this->token_.is_writable()); @@ -115,9 +183,7 @@ File_read::~File_read() this->is_descriptor_opened_ = false; } this->name_.clear(); - this->clear_views(true); - if (this->whole_file_view_) - delete this->whole_file_view_; + this->clear_views(CLEAR_VIEWS_ALL); } // Open the file. @@ -143,24 +209,7 @@ File_read::open(const Task* task, const std::string& name) this->name_.c_str(), strerror(errno)); this->size_ = s.st_size; gold_debug(DEBUG_FILES, "Attempt to open %s succeeded", - this->name_.c_str()); - - // Options may not yet be ready e.g. when reading a version - // script. We then default to --no-keep-files-mapped. - if (parameters->options_valid() - && parameters->options().keep_files_mapped()) - { - const unsigned char* contents = static_cast( - ::mmap(NULL, this->size_, PROT_READ, MAP_PRIVATE, - this->descriptor_, 0)); - if (contents == MAP_FAILED) - gold_fatal(_("%s: mmap failed: %s"), this->filename().c_str(), - strerror(errno)); - this->whole_file_view_ = new View(0, this->size_, contents, 0, false, - View::DATA_MMAPPED); - this->mapped_bytes_ += this->size_; - } - + this->name_.c_str()); this->token_.add_writer(task); } @@ -179,7 +228,8 @@ File_read::open(const Task* task, const std::string& name, && this->name_.empty()); this->name_ = name; this->whole_file_view_ = new View(0, size, contents, 0, false, - View::DATA_NOT_OWNED); + View::DATA_NOT_OWNED); + this->add_view(this->whole_file_view_); this->size_ = size; this->token_.add_writer(task); return true; @@ -226,7 +276,7 @@ File_read::release() // for releasing the descriptor. if (this->object_count_ <= 1) { - this->clear_views(false); + this->clear_views(CLEAR_VIEWS_NORMAL); if (this->is_descriptor_opened_) { release_descriptor(this->descriptor_, false); @@ -243,6 +293,7 @@ void File_read::lock(const Task* task) { gold_assert(this->released_); + gold_debug(DEBUG_FILES, "Locking file \"%s\"", this->name_.c_str()); this->token_.add_writer(task); this->released_ = false; } @@ -252,6 +303,7 @@ File_read::lock(const Task* task) void File_read::unlock(const Task* task) { + gold_debug(DEBUG_FILES, "Unlocking file \"%s\"", this->name_.c_str()); this->release(); this->token_.remove_writer(task); } @@ -279,6 +331,10 @@ inline File_read::View* File_read::find_view(off_t start, section_size_type size, unsigned int byteshift, File_read::View** vshifted) const { + gold_assert(start <= this->size_ + && (static_cast(size) + <= static_cast(this->size_ - start))); + if (vshifted != NULL) *vshifted = NULL; @@ -335,16 +391,26 @@ File_read::do_read(off_t start, section_size_type size, void* p) else { this->reopen_descriptor(); - bytes = ::pread(this->descriptor_, p, size, start); - if (static_cast(bytes) == size) - return; - if (bytes < 0) + char *read_ptr = static_cast(p); + off_t read_pos = start; + size_t to_read = size; + do { - gold_fatal(_("%s: pread failed: %s"), - this->filename().c_str(), strerror(errno)); - return; + bytes = ::pread(this->descriptor_, read_ptr, to_read, read_pos); + if (bytes < 0) + gold_fatal(_("%s: pread failed: %s"), + this->filename().c_str(), strerror(errno)); + + read_pos += bytes; + read_ptr += bytes; + to_read -= bytes; + if (to_read == 0) + return; } + while (bytes > 0); + + bytes = size - to_read; } gold_fatal(_("%s: file too short: read only %lld of %lld bytes at %lld"), @@ -406,16 +472,9 @@ File_read::make_view(off_t start, section_size_type size, unsigned int byteshift, bool cache) { gold_assert(size > 0); - - // Check that start and end of the view are within the file. - if (start > this->size_ - || (static_cast(size) - > static_cast(this->size_ - start))) - gold_fatal(_("%s: attempt to map %lld bytes at offset %lld exceeds " - "size of file; the file may be corrupt"), - this->filename().c_str(), - static_cast(size), - static_cast(start)); + gold_assert(start <= this->size_ + && (static_cast(size) + <= static_cast(this->size_ - start))); off_t poff = File_read::page_offset(start); @@ -427,34 +486,40 @@ File_read::make_view(off_t start, section_size_type size, gold_assert(psize >= size); } - File_read::View* v; - if (this->whole_file_view_ != NULL || byteshift != 0) + void* p; + View::Data_ownership ownership; + if (byteshift != 0) { - unsigned char* p = new unsigned char[psize + byteshift]; + p = malloc(psize + byteshift); + if (p == NULL) + gold_nomem(); memset(p, 0, byteshift); - this->do_read(poff, psize, p + byteshift); - v = new File_read::View(poff, psize, p, byteshift, cache, - View::DATA_ALLOCATED_ARRAY); + this->do_read(poff, psize, static_cast(p) + byteshift); + ownership = View::DATA_ALLOCATED_ARRAY; } else { this->reopen_descriptor(); - void* p = ::mmap(NULL, psize, PROT_READ, MAP_PRIVATE, - this->descriptor_, poff); - if (p == MAP_FAILED) - gold_fatal(_("%s: mmap offset %lld size %lld failed: %s"), - this->filename().c_str(), - static_cast(poff), - static_cast(psize), - strerror(errno)); - - this->mapped_bytes_ += psize; - - const unsigned char* pbytes = static_cast(p); - v = new File_read::View(poff, psize, pbytes, 0, cache, - View::DATA_MMAPPED); + p = ::mmap(NULL, psize, PROT_READ, MAP_PRIVATE, this->descriptor_, poff); + if (p != MAP_FAILED) + { + ownership = View::DATA_MMAPPED; + this->mapped_bytes_ += psize; + } + else + { + p = malloc(psize); + if (p == NULL) + gold_nomem(); + this->do_read(poff, psize, p); + ownership = View::DATA_ALLOCATED_ARRAY; + } } + const unsigned char* pbytes = static_cast(p); + File_read::View* v = new File_read::View(poff, psize, pbytes, byteshift, + cache, ownership); + this->add_view(v); return v; @@ -467,6 +532,16 @@ File_read::View* File_read::find_or_make_view(off_t offset, off_t start, section_size_type size, bool aligned, bool cache) { + // Check that start and end of the view are within the file. + if (start > this->size_ + || (static_cast(size) + > static_cast(this->size_ - start))) + gold_fatal(_("%s: attempt to map %lld bytes at offset %lld exceeds " + "size of file; the file may be corrupt"), + this->filename().c_str(), + static_cast(size), + static_cast(start)); + unsigned int byteshift; if (offset == 0) byteshift = 0; @@ -484,6 +559,15 @@ File_read::find_or_make_view(off_t offset, off_t start, byteshift = (target_size / 8) - byteshift; } + // If --map-whole-files is set, make sure we have a + // whole file view. Options may not yet be ready, e.g., + // when reading a version script. We then default to + // --no-map-whole-files. + if (this->whole_file_view_ == NULL + && parameters->options_valid() + && parameters->options().map_whole_files()) + this->whole_file_view_ = this->make_view(0, this->size_, 0, cache); + // Try to find a View with the required BYTESHIFT. File_read::View* vshifted; File_read::View* v = this->find_view(offset + start, size, @@ -503,12 +587,15 @@ File_read::find_or_make_view(off_t offset, off_t start, { gold_assert(aligned); - unsigned char* pbytes = new unsigned char[v->size() + byteshift]; + unsigned char* pbytes; + pbytes = static_cast(malloc(v->size() + byteshift)); + if (pbytes == NULL) + gold_nomem(); memset(pbytes, 0, byteshift); memcpy(pbytes + byteshift, v->data() + v->byteshift(), v->size()); File_read::View* shifted_view = - new File_read::View(v->start(), v->size(), pbytes, byteshift, + new File_read::View(v->start(), v->size(), pbytes, byteshift, cache, View::DATA_ALLOCATED_ARRAY); this->add_view(shifted_view); @@ -603,11 +690,22 @@ File_read::do_readv(off_t base, const Read_multiple& rm, size_t start, got, want, static_cast(base + first_offset)); } +// Portable IOV_MAX. + +#if !defined(HAVE_READV) +#define GOLD_IOV_MAX 1 +#elif defined(IOV_MAX) +#define GOLD_IOV_MAX IOV_MAX +#else +#define GOLD_IOV_MAX (File_read::max_readv_entries * 2) +#endif + // Read several pieces of data from the file. void File_read::read_multiple(off_t base, const Read_multiple& rm) { + static size_t iov_max = GOLD_IOV_MAX; size_t count = rm.size(); size_t i = 0; while (i < count) @@ -620,7 +718,7 @@ File_read::read_multiple(off_t base, const Read_multiple& rm) size_t j; for (j = i + 1; j < count; ++j) { - if (j - i >= File_read::max_readv_entries) + if (j - i >= File_read::max_readv_entries || j - i >= iov_max / 2) break; const Read_multiple_entry& j_entry(rm[j]); off_t j_off = j_entry.file_offset; @@ -649,10 +747,10 @@ File_read::read_multiple(off_t base, const Read_multiple& rm) { const Read_multiple_entry& k_entry(rm[k]); gold_assert((convert_to_section_size_type(k_entry.file_offset - - i_off) - + k_entry.size) + - i_off) + + k_entry.size) <= convert_to_section_size_type(end_off - - i_off)); + - i_off)); memcpy(k_entry.buffer, v + (k_entry.file_offset - i_off), k_entry.size); @@ -691,25 +789,33 @@ File_read::clear_view_cache_marks() // the next object. void -File_read::clear_views(bool destroying) +File_read::clear_views(Clear_views_mode mode) { + bool keep_files_mapped = (parameters->options_valid() + && parameters->options().keep_files_mapped()); Views::iterator p = this->views_.begin(); while (p != this->views_.end()) { bool should_delete; - if (p->second->is_locked()) + if (p->second->is_locked() || p->second->is_permanent_view()) should_delete = false; - else if (destroying) + else if (mode == CLEAR_VIEWS_ALL) should_delete = true; - else if (p->second->should_cache()) + else if ((p->second->should_cache() + || p->second == this->whole_file_view_) + && keep_files_mapped) should_delete = false; - else if (this->object_count_ > 1 && p->second->accessed()) + else if (this->object_count_ > 1 + && p->second->accessed() + && mode != CLEAR_VIEWS_ARCHIVE) should_delete = false; else should_delete = true; if (should_delete) { + if (p->second == this->whole_file_view_) + this->whole_file_view_ = NULL; delete p->second; // map::erase invalidates only the iterator to the deleted @@ -720,7 +826,6 @@ File_read::clear_views(bool destroying) } else { - gold_assert(!destroying); p->second->clear_accessed(); ++p; } @@ -736,7 +841,7 @@ File_read::clear_views(bool destroying) } else { - gold_assert(!destroying); + gold_assert(mode != CLEAR_VIEWS_ALL); ++q; } } @@ -763,6 +868,16 @@ File_view::~File_view() // Class Input_file. +// Create a file given just the filename. + +Input_file::Input_file(const char* name) + : found_name_(), file_(), is_in_sysroot_(false), format_(FORMAT_NONE) +{ + this->input_argument_ = + new Input_file_argument(name, Input_file_argument::INPUT_FILE_TYPE_FILE, + "", false, Position_dependent_options()); +} + // Create a file for testing. Input_file::Input_file(const Task* task, const char* name, @@ -771,7 +886,7 @@ Input_file::Input_file(const Task* task, const char* name, { this->input_argument_ = new Input_file_argument(name, Input_file_argument::INPUT_FILE_TYPE_FILE, - "", false, Position_dependent_options()); + "", false, Position_dependent_options()); bool ok = this->file_.open(task, name, contents, size); gold_assert(ok); } @@ -830,7 +945,7 @@ File_read::get_mtime() { struct stat file_stat; this->reopen_descriptor(); - + if (fstat(this->descriptor_, &file_stat) < 0) gold_fatal(_("%s: stat failed: %s"), this->name_.c_str(), strerror(errno)); @@ -841,8 +956,32 @@ File_read::get_mtime() #endif } -// Open the file. +// Try to find a file in the extra search dirs. Returns true on success. + +bool +Input_file::try_extra_search_path(int* pindex, + const Input_file_argument* input_argument, + std::string filename, std::string* found_name, + std::string* namep) +{ + if (input_argument->extra_search_path() == NULL) + return false; + std::string name = input_argument->extra_search_path(); + if (!IS_DIR_SEPARATOR(name[name.length() - 1])) + name += '/'; + name += filename; + + struct stat dummy_stat; + if (*pindex > 0 || ::stat(name.c_str(), &dummy_stat) < 0) + return false; + + *found_name = filename; + *namep = name; + return true; +} + +// Find the actual file. // If the filename is not absolute, we assume it is in the current // directory *except* when: // A) input_argument_->is_lib() is true; @@ -852,85 +991,103 @@ File_read::get_mtime() // the file location, rather than the current directory. bool -Input_file::open(const Dirsearch& dirpath, const Task* task, int *pindex) +Input_file::find_file(const Dirsearch& dirpath, int* pindex, + const Input_file_argument* input_argument, + bool* is_in_sysroot, + std::string* found_name, std::string* namep) { std::string name; // Case 1: name is an absolute file, just try to open it // Case 2: name is relative but is_lib is false, is_searched_file is false, // and extra_search_path is empty - if (IS_ABSOLUTE_PATH(this->input_argument_->name()) - || (!this->input_argument_->is_lib() - && !this->input_argument_->is_searched_file() - && this->input_argument_->extra_search_path() == NULL)) + if (IS_ABSOLUTE_PATH(input_argument->name()) + || (!input_argument->is_lib() + && !input_argument->is_searched_file() + && input_argument->extra_search_path() == NULL)) { - name = this->input_argument_->name(); - this->found_name_ = name; + name = input_argument->name(); + *found_name = name; + *namep = name; + return true; } // Case 3: is_lib is true or is_searched_file is true - else if (this->input_argument_->is_lib() - || this->input_argument_->is_searched_file()) + else if (input_argument->is_lib() + || input_argument->is_searched_file()) { - // We don't yet support extra_search_path with -l. - gold_assert(this->input_argument_->extra_search_path() == NULL); - std::string n1, n2; - if (this->input_argument_->is_lib()) + std::vector names; + names.reserve(2); + if (input_argument->is_lib()) { - n1 = "lib"; - n1 += this->input_argument_->name(); + std::string prefix = "lib"; + prefix += input_argument->name(); if (parameters->options().is_static() - || !this->input_argument_->options().Bdynamic()) - n1 += ".a"; + || !input_argument->options().Bdynamic()) + names.push_back(prefix + ".a"); else { - n2 = n1 + ".a"; - n1 += ".so"; + names.push_back(prefix + ".so"); + names.push_back(prefix + ".a"); } } else - n1 = this->input_argument_->name(); - name = dirpath.find(n1, n2, &this->is_in_sysroot_, pindex); + names.push_back(input_argument->name()); + + for (std::vector::const_iterator n = names.begin(); + n != names.end(); + ++n) + if (Input_file::try_extra_search_path(pindex, input_argument, *n, + found_name, namep)) + return true; + + // It is not in the extra_search_path. + name = dirpath.find(names, is_in_sysroot, pindex, found_name); if (name.empty()) { gold_error(_("cannot find %s%s"), - this->input_argument_->is_lib() ? "-l" : "", - this->input_argument_->name()); + input_argument->is_lib() ? "-l" : "", + input_argument->name()); return false; } - if (n2.empty() || name[name.length() - 1] == 'o') - this->found_name_ = n1; - else - this->found_name_ = n2; + *namep = name; + return true; } // Case 4: extra_search_path is not empty else { - gold_assert(this->input_argument_->extra_search_path() != NULL); - - // First, check extra_search_path. - name = this->input_argument_->extra_search_path(); - if (!IS_DIR_SEPARATOR (name[name.length() - 1])) - name += '/'; - name += this->input_argument_->name(); - struct stat dummy_stat; - if (*pindex > 0 || ::stat(name.c_str(), &dummy_stat) < 0) - { - // extra_search_path failed, so check the normal search-path. - int index = *pindex; - if (index > 0) - --index; - name = dirpath.find(this->input_argument_->name(), "", - &this->is_in_sysroot_, &index); - if (name.empty()) - { - gold_error(_("cannot find %s"), - this->input_argument_->name()); - return false; - } - *pindex = index + 1; - } - this->found_name_ = this->input_argument_->name(); + gold_assert(input_argument->extra_search_path() != NULL); + + if (try_extra_search_path(pindex, input_argument, input_argument->name(), + found_name, namep)) + return true; + + // extra_search_path failed, so check the normal search-path. + int index = *pindex; + if (index > 0) + --index; + name = dirpath.find(std::vector(1, input_argument->name()), + is_in_sysroot, &index, found_name); + if (name.empty()) + { + gold_error(_("cannot find %s"), + input_argument->name()); + return false; + } + *namep = name; + *pindex = index + 1; + return true; } +} + +// Open the file. + +bool +Input_file::open(const Dirsearch& dirpath, const Task* task, int* pindex) +{ + std::string name; + if (!Input_file::find_file(dirpath, pindex, this->input_argument_, + &this->is_in_sysroot_, &this->found_name_, &name)) + return false; // Now that we've figured out where the file lives, try to open it. @@ -938,17 +1095,22 @@ Input_file::open(const Dirsearch& dirpath, const Task* task, int *pindex) this->input_argument_->options().format_enum(); bool ok; if (format == General_options::OBJECT_FORMAT_ELF) - ok = this->file_.open(task, name); + { + ok = this->file_.open(task, name); + this->format_ = FORMAT_ELF; + } else { gold_assert(format == General_options::OBJECT_FORMAT_BINARY); ok = this->open_binary(task, name); + this->format_ = FORMAT_BINARY; } if (!ok) { gold_error(_("cannot open %s: %s"), name.c_str(), strerror(errno)); + this->format_ = FORMAT_NONE; return false; }