X-Git-Url: https://git.sesse.net/?p=plocate;a=blobdiff_plain;f=plocate.cpp;h=9606d2f49db1892be4a145e752262bffaac77e0b;hp=b63fefa4e8cdd1dd7e6e0753b0af51e3bf9954d8;hb=6dd0338abec6c820f75d21d441b0a60e3427539f;hpb=15235ad9419e1db22838f6e228404baa3d78de14 diff --git a/plocate.cpp b/plocate.cpp index b63fefa..9606d2f 100644 --- a/plocate.cpp +++ b/plocate.cpp @@ -1,24 +1,29 @@ +#include "access_rx_cache.h" +#include "complete_pread.h" #include "db.h" #include "dprintf.h" #include "io_uring_engine.h" +#include "needle.h" #include "parse_trigrams.h" +#include "serializer.h" #include "turbopfor.h" #include "unique_sort.h" #include #include +#include #include +#include +#include #include -#include #include #include #include -#include #include #include -#include +#include #include -#include +#include #include #include #include @@ -26,6 +31,10 @@ #include #include #include +#include +#include +#include +#include #include #include #include @@ -36,192 +45,22 @@ using namespace std; using namespace std::chrono; -#define DEFAULT_DBPATH "/var/lib/mlocate/plocate.db" - -const char *dbpath = DEFAULT_DBPATH; bool ignore_case = false; bool only_count = false; bool print_nul = false; bool use_debug = false; +bool flush_cache = false; bool patterns_are_regex = false; bool use_extended_regex = false; +bool match_basename = false; int64_t limit_matches = numeric_limits::max(); int64_t limit_left = numeric_limits::max(); +bool stdout_is_tty = false; +static bool in_forked_child = false; steady_clock::time_point start; ZSTD_DDict *ddict = nullptr; -void apply_limit() -{ - if (--limit_left > 0) { - return; - } - dprintf("Done in %.1f ms, found %" PRId64 " matches.\n", - 1e3 * duration(steady_clock::now() - start).count(), limit_matches); - if (only_count) { - printf("%" PRId64 "\n", limit_matches); - } - exit(0); -} - -class Serializer { -public: - ~Serializer() { assert(limit_left <= 0 || pending.empty()); } - void print(uint64_t seq, uint64_t skip, const string msg); - -private: - uint64_t next_seq = 0; - struct Element { - uint64_t seq, skip; - string msg; - - bool operator<(const Element &other) const - { - return seq > other.seq; - } - }; - priority_queue pending; -}; - -void Serializer::print(uint64_t seq, uint64_t skip, const string msg) -{ - if (only_count) { - if (!msg.empty()) { - apply_limit(); - } - return; - } - - if (next_seq != seq) { - pending.push(Element{ seq, skip, move(msg) }); - return; - } - - if (!msg.empty()) { - if (print_nul) { - printf("%s%c", msg.c_str(), 0); - } else { - printf("%s\n", msg.c_str()); - } - apply_limit(); - } - next_seq += skip; - - // See if any delayed prints can now be dealt with. - while (!pending.empty() && pending.top().seq == next_seq) { - if (!pending.top().msg.empty()) { - if (print_nul) { - printf("%s%c", pending.top().msg.c_str(), 0); - } else { - printf("%s\n", pending.top().msg.c_str()); - } - apply_limit(); - } - next_seq += pending.top().skip; - pending.pop(); - } -} - -struct Needle { - enum { STRSTR, - REGEX, - GLOB } type; - string str; // Filled in no matter what. - regex_t re; // For REGEX. -}; - -bool matches(const Needle &needle, const char *haystack) -{ - if (needle.type == Needle::STRSTR) { - return strstr(haystack, needle.str.c_str()) != nullptr; - } else if (needle.type == Needle::GLOB) { - int flags = ignore_case ? FNM_CASEFOLD : 0; - return fnmatch(needle.str.c_str(), haystack, flags) == 0; - } else { - assert(needle.type == Needle::REGEX); - return regexec(&needle.re, haystack, /*nmatch=*/0, /*pmatch=*/nullptr, /*flags=*/0) == 0; - } -} - -class AccessRXCache { -public: - AccessRXCache(IOUringEngine *engine) - : engine(engine) {} - void check_access(const char *filename, bool allow_async, function cb); - -private: - unordered_map cache; - struct PendingStat { - string filename; - function cb; - }; - map> pending_stats; - IOUringEngine *engine; -}; - -void AccessRXCache::check_access(const char *filename, bool allow_async, function cb) -{ - if (engine == nullptr || !engine->get_supports_stat()) { - allow_async = false; - } - - for (const char *end = strchr(filename + 1, '/'); end != nullptr; end = strchr(end + 1, '/')) { - string parent_path(filename, end - filename); // string_view from C++20. - auto cache_it = cache.find(parent_path); - if (cache_it != cache.end()) { - // Found in the cache. - if (!cache_it->second) { - cb(false); - return; - } - continue; - } - - if (!allow_async) { - bool ok = access(parent_path.c_str(), R_OK | X_OK) == 0; - cache.emplace(parent_path, ok); - if (!ok) { - cb(false); - return; - } - continue; - } - - // We want to call access(), but it could block on I/O. io_uring doesn't support - // access(), but we can do a dummy asynchonous statx() to populate the kernel's cache, - // which nearly always makes the next access() instantaneous. - - // See if there's already a pending stat that matches this, - // or is a subdirectory. - auto it = pending_stats.lower_bound(parent_path); - if (it != pending_stats.end() && it->first.size() >= parent_path.size() && - it->first.compare(0, parent_path.size(), parent_path) == 0) { - it->second.emplace_back(PendingStat{ filename, move(cb) }); - } else { - it = pending_stats.emplace(filename, vector{}).first; - engine->submit_stat(filename, [this, it, filename{ strdup(filename) }, cb{ move(cb) }] { - // The stat returned, so now do the actual access() calls. - // All of them should be in cache, so don't fire off new statx() - // calls during that check. - check_access(filename, /*allow_async=*/false, move(cb)); - free(filename); - - // Call all others that waited for the same stat() to finish. - // They may fire off new stat() calls if needed. - vector pending = move(it->second); - pending_stats.erase(it); - for (PendingStat &ps : pending) { - check_access(ps.filename.c_str(), /*allow_async=*/true, move(ps.cb)); - } - }); - } - return; // The rest will happen in async context. - } - - // Passed all checks. - cb(true); -} - class Corpus { public: Corpus(int fd, IOUringEngine *engine); @@ -245,8 +84,7 @@ public: Corpus::Corpus(int fd, IOUringEngine *engine) : fd(fd), engine(engine) { - // Enable to test cold-cache behavior (except for access()). - if (true) { + if (flush_cache) { off_t len = lseek(fd, 0, SEEK_END); if (len == -1) { perror("lseek"); @@ -269,6 +107,10 @@ Corpus::Corpus(int fd, IOUringEngine *engine) hdr.zstd_dictionary_offset_bytes = 0; hdr.zstd_dictionary_length_bytes = 0; } + if (hdr.max_version < 2) { + // This too. (We ignore the other max_version 2 fields.) + hdr.check_visibility = true; + } } Corpus::~Corpus() @@ -311,8 +153,8 @@ size_t Corpus::get_num_filename_blocks() const } void scan_file_block(const vector &needles, string_view compressed, - AccessRXCache *access_rx_cache, uint64_t seq, Serializer *serializer, - uint64_t *matched) + AccessRXCache *access_rx_cache, uint64_t seq, ResultReceiver *serializer, + atomic *matched) { unsigned long long uncompressed_len = ZSTD_getFrameContentSize(compressed.data(), compressed.size()); if (uncompressed_len == ZSTD_CONTENTSIZE_UNKNOWN || uncompressed_len == ZSTD_CONTENTSIZE_ERROR) { @@ -323,7 +165,7 @@ void scan_file_block(const vector &needles, string_view compressed, string block; block.resize(uncompressed_len + 1); - static ZSTD_DCtx *ctx = ZSTD_createDCtx(); // Reused across calls. + static thread_local ZSTD_DCtx *ctx = ZSTD_createDCtx(); // Reused across calls. size_t err; if (ddict != nullptr) { @@ -359,9 +201,19 @@ void scan_file_block(const vector &needles, string_view compressed, for (const char *filename = block.data(); filename != block.data() + block.size(); filename += strlen(filename) + 1) { + const char *haystack = filename; + if (match_basename) { + haystack = strrchr(filename, '/'); + if (haystack == nullptr) { + haystack = filename; + } else { + ++haystack; + } + } + bool found = true; for (const Needle &needle : needles) { - if (!matches(needle, filename)) { + if (!matches(needle, haystack)) { found = false; break; } @@ -384,8 +236,8 @@ void scan_file_block(const vector &needles, string_view compressed, size_t scan_docids(const vector &needles, const vector &docids, const Corpus &corpus, IOUringEngine *engine) { Serializer docids_in_order; - AccessRXCache access_rx_cache(engine); - uint64_t matched = 0; + AccessRXCache access_rx_cache(engine, corpus.get_hdr().check_visibility); + atomic matched{ 0 }; for (size_t i = 0; i < docids.size(); ++i) { uint32_t docid = docids[i]; corpus.get_compressed_filename_block(docid, [i, &matched, &needles, &access_rx_cache, &docids_in_order](string_view compressed) { @@ -396,9 +248,58 @@ size_t scan_docids(const vector &needles, const vector &docids return matched; } +struct WorkerThread { + thread t; + + // We use a result queue instead of synchronizing Serializer, + // since a lock on it becomes a huge choke point if there are + // lots of threads. + mutex result_mu; + struct Result { + uint64_t seq; + uint64_t skip; + string msg; + }; + vector results; +}; + +class WorkerThreadReceiver : public ResultReceiver { +public: + WorkerThreadReceiver(WorkerThread *wt) + : wt(wt) {} + + void print(uint64_t seq, uint64_t skip, const string msg) override + { + lock_guard lock(wt->result_mu); + if (msg.empty() && !wt->results.empty() && wt->results.back().seq + wt->results.back().skip == seq) { + wt->results.back().skip += skip; + } else { + wt->results.emplace_back(WorkerThread::Result{ seq, skip, move(msg) }); + } + } + +private: + WorkerThread *wt; +}; + +void deliver_results(WorkerThread *wt, Serializer *serializer) +{ + vector results; + { + lock_guard lock(wt->result_mu); + results = move(wt->results); + } + for (const WorkerThread::Result &result : results) { + serializer->print(result.seq, result.skip, move(result.msg)); + } +} + // We do this sequentially, as it's faster than scattering // a lot of I/O through io_uring and hoping the kernel will -// coalesce it plus readahead for us. +// coalesce it plus readahead for us. Since we assume that +// we will primarily be CPU-bound, we'll be firing up one +// worker thread for each spare core (the last one will +// only be doing I/O). access() is still synchronous. uint64_t scan_all_docids(const vector &needles, int fd, const Corpus &corpus) { { @@ -411,13 +312,60 @@ uint64_t scan_all_docids(const vector &needles, int fd, const Corpus &co } } - AccessRXCache access_rx_cache(nullptr); - Serializer serializer; // Mostly dummy; handles only the limit. + AccessRXCache access_rx_cache(nullptr, corpus.get_hdr().check_visibility); + Serializer serializer; uint32_t num_blocks = corpus.get_num_filename_blocks(); unique_ptr offsets(new uint64_t[num_blocks + 1]); complete_pread(fd, offsets.get(), (num_blocks + 1) * sizeof(uint64_t), corpus.offset_for_block(0)); + atomic matched{ 0 }; + + mutex mu; + condition_variable queue_added, queue_removed; + deque> work_queue; // Under mu. + bool done = false; // Under mu. + + unsigned num_threads = max(sysconf(_SC_NPROCESSORS_ONLN) - 1, 1); + dprintf("Using %u worker threads for linear scan.\n", num_threads); + unique_ptr threads(new WorkerThread[num_threads]); + for (unsigned i = 0; i < num_threads; ++i) { + threads[i].t = thread([&threads, &mu, &queue_added, &queue_removed, &work_queue, &done, &offsets, &needles, &access_rx_cache, &matched, i] { + // regcomp() takes a lock on the regex, so each thread will need its own. + const vector *use_needles = &needles; + vector recompiled_needles; + if (i != 0 && patterns_are_regex) { + recompiled_needles = needles; + for (Needle &needle : recompiled_needles) { + needle.re = compile_regex(needle.str); + } + use_needles = &recompiled_needles; + } + + WorkerThreadReceiver receiver(&threads[i]); + for (;;) { + uint32_t io_docid, last_docid; + string compressed; + + { + unique_lock lock(mu); + queue_added.wait(lock, [&work_queue, &done] { return !work_queue.empty() || done; }); + if (done && work_queue.empty()) { + return; + } + tie(io_docid, last_docid, compressed) = move(work_queue.front()); + work_queue.pop_front(); + queue_removed.notify_all(); + } + + for (uint32_t docid = io_docid; docid < last_docid; ++docid) { + size_t relative_offset = offsets[docid] - offsets[io_docid]; + size_t len = offsets[docid + 1] - offsets[docid]; + scan_file_block(*use_needles, { &compressed[relative_offset], len }, &access_rx_cache, docid, &receiver, &matched); + } + } + }); + } + string compressed; - uint64_t matched = 0; for (uint32_t io_docid = 0; io_docid < num_blocks; io_docid += 32) { uint32_t last_docid = std::min(io_docid + 32, num_blocks); size_t io_len = offsets[last_docid] - offsets[io_docid]; @@ -426,11 +374,27 @@ uint64_t scan_all_docids(const vector &needles, int fd, const Corpus &co } complete_pread(fd, &compressed[0], io_len, offsets[io_docid]); - for (uint32_t docid = io_docid; docid < last_docid; ++docid) { - size_t relative_offset = offsets[docid] - offsets[io_docid]; - size_t len = offsets[docid + 1] - offsets[docid]; - scan_file_block(needles, { &compressed[relative_offset], len }, &access_rx_cache, docid, &serializer, &matched); + { + unique_lock lock(mu); + queue_removed.wait(lock, [&work_queue] { return work_queue.size() < 256; }); // Allow ~2MB of data queued up. + work_queue.emplace_back(io_docid, last_docid, move(compressed)); + queue_added.notify_one(); // Avoid the thundering herd. } + + // Pick up some results, so that we are sure that we won't just overload. + // (Seemingly, going through all of these causes slowness with many threads, + // but taking only one is OK.) + unsigned i = io_docid / 32; + deliver_results(&threads[i % num_threads], &serializer); + } + { + lock_guard lock(mu); + done = true; + queue_added.notify_all(); + } + for (unsigned i = 0; i < num_threads; ++i) { + threads[i].t.join(); + deliver_results(&threads[i], &serializer); } return matched; } @@ -482,11 +446,11 @@ bool new_posting_list_read(TrigramDisjunction *td, vector decoded, vec return false; } -void do_search_file(const vector &needles, const char *filename) +uint64_t do_search_file(const vector &needles, const std::string &filename) { - int fd = open(filename, O_RDONLY); + int fd = open(filename.c_str(), O_RDONLY); if (fd == -1) { - perror(filename); + perror(filename.c_str()); exit(1); } @@ -499,7 +463,7 @@ void do_search_file(const vector &needles, const char *filename) start = steady_clock::now(); if (access("/", R_OK | X_OK)) { // We can't find anything, no need to bother... - return; + return 0; } IOUringEngine engine(/*slop_bytes=*/16); // 16 slop bytes as described in turbopfor.h. @@ -542,10 +506,9 @@ void do_search_file(const vector &needles, const char *filename) // the pattern and done a union of them, but that's a lot of // work for fairly unclear gain.) uint64_t matched = scan_all_docids(needles, fd, corpus); - if (only_count) { - printf("%" PRId64 "\n", matched); - } - return; + dprintf("Done in %.1f ms, found %" PRId64 " matches.\n", + 1e3 * duration(steady_clock::now() - start).count(), matched); + return matched; } // Sneak in fetching the dictionary, if present. It's not necessarily clear @@ -564,18 +527,30 @@ void do_search_file(const vector &needles, const char *filename) } // Look them all up on disk. + bool should_early_exit = false; for (auto &[trgm, trigram_groups] : trigrams_to_lookup) { - corpus.find_trigram(trgm, [trgm{ trgm }, trigram_groups{ &trigram_groups }](const Trigram *trgmptr, size_t len) { + corpus.find_trigram(trgm, [trgm{ trgm }, trigram_groups{ &trigram_groups }, &should_early_exit](const Trigram *trgmptr, size_t len) { if (trgmptr == nullptr) { dprintf("trigram %s isn't found\n", print_trigram(trgm).c_str()); for (TrigramDisjunction *td : *trigram_groups) { --td->remaining_trigrams_to_read; + + // If we now know this trigram group doesn't match anything at all, + // we can do early exit; however, if we're in a forked child, + // that would confuse the parent process (since we don't write + // our count to the pipe), so we wait until we're back in to the + // regular (non-async) context. This is a fairly rare case anyway, + // and the gains from dropping the remaining trigram reads are limited. if (td->remaining_trigrams_to_read == 0 && td->read_trigrams.empty()) { - dprintf("zero matches in %s, so we are done\n", print_td(*td).c_str()); - if (only_count) { - printf("0\n"); + if (in_forked_child) { + should_early_exit = true; + } else { + dprintf("zero matches in %s, so we are done\n", print_td(*td).c_str()); + if (only_count) { + printf("0\n"); + } + exit(0); } - exit(0); } } return; @@ -590,6 +565,10 @@ void do_search_file(const vector &needles, const char *filename) engine.finish(); dprintf("Hashtable lookups done after %.1f ms.\n", 1e3 * duration(steady_clock::now() - start).count()); + if (should_early_exit) { + return 0; + } + for (TrigramDisjunction &td : trigram_groups) { // Reset for reads. td.remaining_trigrams_to_read = td.read_trigrams.size(); @@ -641,7 +620,7 @@ void do_search_file(const vector &needles, const char *filename) if (done) return; - uint32_t trgm __attribute__((unused)) = trgmptr.trgm; + uint32_t trgm = trgmptr.trgm; const unsigned char *pldata = reinterpret_cast(s.data()); size_t num = trgmptr.num_docids; decoded.resize(num); @@ -672,7 +651,7 @@ void do_search_file(const vector &needles, const char *filename) } engine.finish(); if (done) { - return; + return 0; } dprintf("Intersection done after %.1f ms. Doing final verification and printing:\n", 1e3 * duration(steady_clock::now() - start).count()); @@ -680,45 +659,120 @@ void do_search_file(const vector &needles, const char *filename) uint64_t matched = scan_docids(needles, cur_candidates, corpus, &engine); dprintf("Done in %.1f ms, found %" PRId64 " matches.\n", 1e3 * duration(steady_clock::now() - start).count(), matched); - - if (only_count) { - printf("%" PRId64 "\n", matched); - } + return matched; } -string unescape_glob_to_plain_string(const string &needle) +// Run do_search_file() in a child process. +// +// The reason for this is that we're not robust against malicious input, so we need +// to drop privileges after opening the file. (Otherwise, we could fall prey to an attack +// where a user does locate -d badfile.db:/var/lib/plocate/plocate.db, badfile.db contains +// a buffer overflow that takes over the process, and then uses the elevated privileges +// to print out otherwise inaccessible paths.) We solve this by forking and treating the +// child process as untrusted after it has dropped its privileges (which it does before +// reading any data from the file); it returns a single 64-bit number over a pipe, +// and that's it. The parent keeps its privileges, and can then fork out new children +// without fear of being taken over. (The child keeps stdout for outputting results.) +// +// The count is returned over the pipe, because it's needed both for --limit and --count. +uint64_t do_search_file_in_child(const vector &needles, const std::string &filename) { - string unescaped; - for (size_t i = 0; i < needle.size(); i += read_unigram(needle, i).second) { - uint32_t ch = read_unigram(needle, i).first; - assert(ch != WILDCARD_UNIGRAM); - if (ch == PREMATURE_END_UNIGRAM) { - fprintf(stderr, "Pattern '%s' ended prematurely\n", needle.c_str()); - exit(1); + int pipefd[2]; + if (pipe(pipefd) == -1) { + perror("pipe"); + exit(EXIT_FAILURE); + } + + pid_t child_pid = fork(); + switch (child_pid) { + case 0: { + // Child. + close(pipefd[0]); + in_forked_child = true; + uint64_t matched = do_search_file(needles, filename); + int ret; + do { + ret = write(pipefd[1], &matched, sizeof(matched)); + } while (ret == -1 && errno == EINTR); + if (ret != sizeof(matched)) { + perror("write"); + _exit(EXIT_FAILURE); } - unescaped.push_back(ch); + _exit(EXIT_SUCCESS); } - return unescaped; + case -1: + // Error. + perror("fork"); + exit(EXIT_FAILURE); + default: + // Parent. + close(pipefd[1]); + break; + } + + // Wait for the child to finish. + int wstatus; + pid_t err; + do { + err = waitpid(child_pid, &wstatus, 0); + } while (err == -1 && errno == EINTR); + if (err == -1) { + perror("waitpid"); + exit(EXIT_FAILURE); + } + if (WIFEXITED(wstatus)) { + if (WEXITSTATUS(wstatus) != 0) { + // The child has probably already printed out its error, so just propagate the exit status. + exit(WEXITSTATUS(wstatus)); + } + // Success! + } else if (!WIFEXITED(wstatus)) { + fprintf(stderr, "FATAL: Child died unexpectedly while processing %s\n", filename.c_str()); + exit(1); + } + + // Now get the number of matches from the child. + uint64_t matched; + int ret; + do { + ret = read(pipefd[0], &matched, sizeof(matched)); + } while (ret == -1 && errno == EINTR); + if (ret == -1) { + perror("read"); + exit(EXIT_FAILURE); + } else if (ret != sizeof(matched)) { + fprintf(stderr, "FATAL: Short read through pipe (got %d bytes)\n", ret); + exit(EXIT_FAILURE); + } + close(pipefd[0]); + return matched; } -regex_t compile_regex(const string &needle) +// Parses a colon-separated list of strings and appends them onto the given vector. +// Backslash escapes whatever comes after it. +void parse_dbpaths(const char *ptr, vector *output) { - regex_t re; - int flags = REG_NOSUB; - if (ignore_case) { - flags |= REG_ICASE; - } - if (use_extended_regex) { - flags |= REG_EXTENDED; - } - int err = regcomp(&re, needle.c_str(), flags); - if (err != 0) { - char errbuf[256]; - regerror(err, &re, errbuf, sizeof(errbuf)); - fprintf(stderr, "Error when compiling regex '%s': %s\n", needle.c_str(), errbuf); - exit(1); + string str; + while (*ptr != '\0') { + if (*ptr == '\\') { + if (ptr[1] == '\0') { + fprintf(stderr, "ERROR: Escape character at the end of string\n"); + exit(EXIT_FAILURE); + } + // Escape. + str.push_back(ptr[1]); + ptr += 2; + continue; + } + if (*ptr == ':') { + // Separator. + output->push_back(move(str)); + ++ptr; + continue; + } + str.push_back(*ptr++); } - return re; + output->push_back(move(str)); } void usage() @@ -726,21 +780,23 @@ void usage() printf( "Usage: plocate [OPTION]... PATTERN...\n" "\n" + " -b, --basename search only the file name portion of path names\n" " -c, --count print number of matches instead of the matches\n" " -d, --database DBPATH search for files in DBPATH\n" - " (default is " DEFAULT_DBPATH ")\n" + " (default is " DBFILE ")\n" " -i, --ignore-case search case-insensitively\n" " -l, --limit LIMIT stop after LIMIT matches\n" " -0, --null delimit matches by NUL instead of newline\n" " -r, --regexp interpret patterns as basic regexps (slow)\n" " --regex interpret patterns as extended regexps (slow)\n" + " -w, --wholename search the entire path name (default; see -b)\n" " --help print this help\n" " --version print version information\n"); } void version() { - printf("plocate %s\n", PLOCATE_VERSION); + printf("%s %s\n", PACKAGE_NAME, PACKAGE_VERSION); printf("Copyright 2020 Steinar H. Gunderson\n"); printf("License GPLv2+: GNU GPL version 2 or later .\n"); printf("This is free software: you are free to change and redistribute it.\n"); @@ -750,10 +806,14 @@ void version() int main(int argc, char **argv) { + vector dbpaths; + constexpr int EXTENDED_REGEX = 1000; + constexpr int FLUSH_CACHE = 1001; static const struct option long_options[] = { { "help", no_argument, 0, 'h' }, { "count", no_argument, 0, 'c' }, + { "basename", no_argument, 0, 'b' }, { "database", required_argument, 0, 'd' }, { "ignore-case", no_argument, 0, 'i' }, { "limit", required_argument, 0, 'l' }, @@ -761,23 +821,29 @@ int main(int argc, char **argv) { "version", no_argument, 0, 'V' }, { "regexp", no_argument, 0, 'r' }, { "regex", no_argument, 0, EXTENDED_REGEX }, + { "wholename", no_argument, 0, 'w' }, { "debug", no_argument, 0, 'D' }, // Not documented. + // Enable to test cold-cache behavior (except for access()). Not documented. + { "flush-cache", no_argument, 0, FLUSH_CACHE }, { 0, 0, 0, 0 } }; setlocale(LC_ALL, ""); for (;;) { int option_index = 0; - int c = getopt_long(argc, argv, "cd:hil:n:0VD", long_options, &option_index); + int c = getopt_long(argc, argv, "bcd:hil:n:0rwVD", long_options, &option_index); if (c == -1) { break; } switch (c) { + case 'b': + match_basename = true; + break; case 'c': only_count = true; break; case 'd': - dbpath = strdup(optarg); + parse_dbpaths(optarg, &dbpaths); break; case 'h': usage(); @@ -803,9 +869,15 @@ int main(int argc, char **argv) patterns_are_regex = true; use_extended_regex = true; break; + case 'w': + match_basename = false; // No-op unless -b is given first. + break; case 'D': use_debug = true; break; + case FLUSH_CACHE: + flush_cache = true; + break; case 'V': version(); break; @@ -814,16 +886,22 @@ int main(int argc, char **argv) } } - if (use_debug) { + if (use_debug || flush_cache) { // Debug information would leak information about which files exist, // so drop setgid before we open the file; one would either need to run - // as root, or use a locally-built file. + // as root, or use a locally-built file. Doing the same thing for + // flush_cache is mostly paranoia, in an attempt to prevent random users + // from making plocate slow for everyone else. if (setgid(getgid()) != 0) { perror("setgid"); exit(EXIT_FAILURE); } } + if (!print_nul) { + stdout_is_tty = isatty(1); + } + vector needles; for (int i = optind; i < argc; ++i) { Needle needle; @@ -860,5 +938,30 @@ int main(int argc, char **argv) fprintf(stderr, "plocate: no pattern to search for specified\n"); exit(0); } - do_search_file(needles, dbpath); + + if (dbpaths.empty()) { + // No -d given, so use our default. Note that this happens + // even if LOCATE_PATH exists, to match mlocate behavior. + dbpaths.push_back(DBFILE); + } + + const char *locate_path = getenv("LOCATE_PATH"); + if (locate_path != nullptr) { + parse_dbpaths(locate_path, &dbpaths); + } + + uint64_t matched = 0; + for (size_t i = 0; i < dbpaths.size(); ++i) { + uint64_t this_matched; + if (i != dbpaths.size() - 1) { + this_matched = do_search_file_in_child(needles, dbpaths[i]); + } else { + this_matched = do_search_file(needles, dbpaths[i]); + } + matched += this_matched; + limit_left -= this_matched; + } + if (only_count) { + printf("%" PRId64 "\n", matched); + } }