/* * trace-event-scripting. Scripting engine common and initialization code. * * Copyright (C) 2009-2010 Tom Zanussi * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA * */ #include #include #include #include #include "../perf.h" #include "debug.h" #include "util.h" #include "trace-event.h" struct scripting_context *scripting_context; static int flush_script_unsupported(void) { return 0; } static int stop_script_unsupported(void) { return 0; } static void process_event_unsupported(union perf_event *event __maybe_unused, struct perf_sample *sample __maybe_unused, struct perf_evsel *evsel __maybe_unused, struct addr_location *al __maybe_unused) { } static void print_python_unsupported_msg(void) { fprintf(stderr, "Python scripting not supported." " Install libpython and rebuild perf to enable it.\n" "For example:\n # apt-get install python-dev (ubuntu)" "\n # yum install python-devel (Fedora)" "\n etc.\n"); } static int python_start_script_unsupported(const char *script __maybe_unused, int argc __maybe_unused, const char **argv __maybe_unused) { print_python_unsupported_msg(); return -1; } static int python_generate_script_unsupported(struct pevent *pevent __maybe_unused, const char *outfile __maybe_unused) { print_python_unsupported_msg(); return -1; } struct scripting_ops python_scripting_unsupported_ops = { .name = "Python", .start_script = python_start_script_unsupported, .flush_script = flush_script_unsupported, .stop_script = stop_script_unsupported, .process_event = process_event_unsupported, .generate_script = python_generate_script_unsupported, }; static void register_python_scripting(struct scripting_ops *scripting_ops) { if (scripting_context == NULL) scripting_context = malloc(sizeof(*scripting_context)); if (scripting_context == NULL || script_spec_register("Python", scripting_ops) || script_spec_register("py", scripting_ops)) { pr_err("Error registering Python script extension: disabling it\n"); zfree(&scripting_context); } } #ifdef NO_LIBPYTHON void setup_python_scripting(void) { register_python_scripting(&python_scripting_unsupported_ops); } #else extern struct scripting_ops python_scripting_ops; void setup_python_scripting(void) { register_python_scripting(&python_scripting_ops); } #endif static void print_perl_unsupported_msg(void) { fprintf(stderr, "Perl scripting not supported." " Install libperl and rebuild perf to enable it.\n" "For example:\n # apt-get install libperl-dev (ubuntu)" "\n # yum install 'perl(ExtUtils::Embed)' (Fedora)" "\n etc.\n"); } static int perl_start_script_unsupported(const char *script __maybe_unused, int argc __maybe_unused, const char **argv __maybe_unused) { print_perl_unsupported_msg(); return -1; } static int perl_generate_script_unsupported(struct pevent *pevent __maybe_unused, const char *outfile __maybe_unused) { print_perl_unsupported_msg(); return -1; } struct scripting_ops perl_scripting_unsupported_ops = { .name = "Perl", .start_script = perl_start_script_unsupported, .flush_script = flush_script_unsupported, .stop_script = stop_script_unsupported, .process_event = process_event_unsupported, .generate_script = perl_generate_script_unsupported, }; static void register_perl_scripting(struct scripting_ops *scripting_ops) { if (scripting_context == NULL) scripting_context = malloc(sizeof(*scripting_context)); if (scripting_context == NULL || script_spec_register("Perl", scripting_ops) || script_spec_register("pl", scripting_ops)) { pr_err("Error registering Perl script extension: disabling it\n"); zfree(&scripting_context); } } #ifdef NO_LIBPERL void setup_perl_scripting(void) { register_perl_scripting(&perl_scripting_unsupported_ops); } #else extern struct scripting_ops perl_scripting_ops; void setup_perl_scripting(void) { register_perl_scripting(&perl_scripting_ops); } #endif td>2016-08-10 17:22:44 +0200 committerDan Williams <dan.j.williams@intel.com>2016-12-26 20:29:24 -0800 commitc6dcf52c23d2d3fb5235cec42d7dd3f786b87d55 (patch) tree7e63a6c0225a769e679b194f54b5723e4cfba385 /kernel/locking parente568df6b84ff05a22467503afc11bee7a6ba0700 (diff)
mm: Invalidate DAX radix tree entries only if appropriate
Currently invalidate_inode_pages2_range() and invalidate_mapping_pages() just delete all exceptional radix tree entries they find. For DAX this is not desirable as we track cache dirtiness in these entries and when they are evicted, we may not flush caches although it is necessary. This can for example manifest when we write to the same block both via mmap and via write(2) (to different offsets) and fsync(2) then does not properly flush CPU caches when modification via write(2) was the last one. Create appropriate DAX functions to handle invalidation of DAX entries for invalidate_inode_pages2_range() and invalidate_mapping_pages() and wire them up into the corresponding mm functions. Acked-by: Johannes Weiner <hannes@cmpxchg.org> Reviewed-by: Ross Zwisler <ross.zwisler@linux.intel.com> Signed-off-by: Jan Kara <jack@suse.cz> Signed-off-by: Dan Williams <dan.j.williams@intel.com>
Diffstat (limited to 'kernel/locking')