0002-prefetch-boot.diff - prefetch - Project Hosting on Google Code

‹r365

r381

Source path: svn/ tags/ soc2007-end/ trunk/ kernel-patches/ 2.6.22/ submitted/ 0002-prefetch-boot.diff

Boot tracing and prefetching support, uses prefetch core.

Signed-off-by: Krzysztof Lichota <krzysiek@lichota.net>


---

 init/Kconfig       |    8 +
 mm/Makefile        |    1 
 mm/prefetch_boot.c |  390 ++++++++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 399 insertions(+), 0 deletions(-)
 create mode 100644 mm/prefetch_boot.c

e11c0867f81dd458a8d178e999b184e1f79faa57
diff --git a/init/Kconfig b/init/Kconfig
index 9ba6032..0f7f777 100644
--- a/init/Kconfig
+++ b/init/Kconfig
@@ -114,6 +114,14 @@ config PREFETCH_CORE
 	 The core provides functions used by real prefetching modules,
 	 so you have to enable one of them also.
 
+config PREFETCH_BOOT
+	tristate "Boot prefetching support"
+	default n
+	depends on PREFETCH_CORE && PROC_FS
+	help
+	 This option enables facility for tracing and prefetching during system boot.
+	 In order to use it you have to install appropriate prefetch init scripts.
+
 config SYSVIPC
 	bool "System V IPC"
 	---help---
diff --git a/mm/Makefile b/mm/Makefile
index dee5c46..2c4e30c 100644
--- a/mm/Makefile
+++ b/mm/Makefile
@@ -32,4 +32,5 @@ obj-$(CONFIG_MIGRATION) += migrate.o
 obj-$(CONFIG_SMP) += allocpercpu.o
 obj-$(CONFIG_QUICKLIST) += quicklist.o
 obj-$(CONFIG_PREFETCH_CORE)	+= prefetch_core.o
+obj-$(CONFIG_PREFETCH_BOOT)	+= prefetch_boot.o
 
diff --git a/mm/prefetch_boot.c b/mm/prefetch_boot.c
new file mode 100644
index 0000000..94cf994
--- /dev/null
+++ b/mm/prefetch_boot.c
@@ -0,0 +1,390 @@
+/*
+ * linux/mm/prefetch_core.c
+ *
+ * Copyright (C) 2007 Krzysztof Lichota <lichota@mimuw.edu.pl>
+ *
+ * This is boot prefetch support implementation. 
+ * It consists mainly of proc interface, the rest is done by init scripts using proc interface.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+ 
+#include <linux/prefetch_core.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/limits.h>
+#include <asm/uaccess.h>
+#include <linux/proc_fs.h>
+#include <asm/current.h>
+
+
+/*************** Boot tracing **************/
+#define DEFAULT_BOOT_TRACE_FILENAME_TEMPLATE "/.prefetch-boot-trace.%s"
+char *filename_template =  DEFAULT_BOOT_TRACE_FILENAME_TEMPLATE;
+module_param(filename_template, charp, 0);
+MODULE_PARM_DESC(filename_template, "Template for boot trace name, where trace will be saved and read from. %s will be replaced with name of phase. The default is: " DEFAULT_BOOT_TRACE_FILENAME_TEMPLATE);
+
+///maximum size of phase name, not including trailing NULL
+#define PHASE_NAME_MAX 10
+///maximum size as string, keep in sync with PHASE_NAME_MAX
+#define PHASE_NAME_MAX_S "10"
+
+///maximum size of command name, not including trailing NULL
+#define CMD_NAME_MAX 10
+///maximum size as string, keep in sync with CMD_NAME_MAX
+#define CMD_NAME_MAX_S "10"
+
+///Enables/disables whole functionality of the module
+static int enabled = 1;
+module_param(enabled, bool, 0);
+MODULE_PARM_DESC(enabled, "Enables or disables whole boot prefetching module functionality (tracing and prefetching)");
+
+///Controls whether prefetching should be done along with tracing.
+static int prefetch_enabled = 1;
+module_param(prefetch_enabled, bool, 0);
+MODULE_PARM_DESC(prefetch_enabled, "Enables or disables prefetching during boot. If disabled, only tracing will be done");
+
+static struct mutex boot_prefetch_mutex;
+/** 
+ * 	Phase start marker, protected by boot_prefetch_mutex.
+*/
+static trace_marker_t boot_start_marker;
+static char boot_tracing_phase[PHASE_NAME_MAX + 1] = "init";
+static int boot_tracing_running = 0;
+
+/**
+	Saves boot trace fragment for phase @phase_name which 
+	starts at boot_start_marker and ends at @end_phase_marker.
+	
+	boot_prefetch_mutex must be held while calling this function.
+*/
+static int prefetch_save_boot_trace(
+	char *phase_name,
+	trace_marker_t end_phase_marker
+	)
+{
+	char *boot_trace_filename = NULL;
+	int ret = 0;
+	
+	boot_trace_filename = kasprintf(GFP_KERNEL, filename_template,
+		phase_name
+		);
+	
+	if (boot_trace_filename == NULL) {
+		printk(KERN_WARNING "Cannot allocate memory for trace filename in phase %s\n", phase_name);
+		ret = -ENOMEM;
+		goto out;
+	}
+	ret = prefetch_save_trace_fragment(
+		boot_start_marker,
+		end_phase_marker,
+		boot_trace_filename
+		);
+out:
+	if (boot_trace_filename != NULL)
+		kfree(boot_trace_filename);
+	return ret;
+}
+
+/**
+	Starts tracing for given boot phase.
+	boot_prefetch_mutex is taken by this function.
+*/
+int prefetch_start_boot_tracing_phase(char *phase_name)
+{
+	int r;
+	int ret = 0;
+	trace_marker_t marker;
+	
+	mutex_lock(&boot_prefetch_mutex);
+	
+	if (boot_tracing_running) {
+		//boot tracing was already running
+		ret = prefetch_continue_trace(&marker);
+		if (ret < 0) {
+			printk(KERN_WARNING "Cannot continue tracing, error=%d\n", ret);
+			goto out_unlock;
+		}
+		
+		r = prefetch_save_boot_trace(boot_tracing_phase, marker);
+		if (r < 0)
+			//NOTE: just warn and continue, prefetching might still succeed and phase has been started
+			printk(KERN_WARNING "Saving boot trace failed, phase %s, error=%d\n", boot_tracing_phase, r);
+		
+		boot_start_marker = marker;
+	} else {
+		//first phase of tracing
+		ret = prefetch_start_trace(&boot_start_marker);
+		if (ret < 0) {
+			printk(KERN_WARNING "Cannot start tracing, error=%d\n", ret);
+			goto out_unlock;
+		}
+	}
+	
+	strncpy(boot_tracing_phase, phase_name, PHASE_NAME_MAX);
+	boot_tracing_phase[PHASE_NAME_MAX] = 0;
+
+	boot_tracing_running = 1;
+	
+#ifdef PREFETCH_DEBUG
+	printk(KERN_INFO "Boot command %s, phase %s marker: ", cmd_name, phase_name);
+	print_marker("Marker: ", boot_start_marker);
+#endif
+out_unlock:
+	mutex_unlock(&boot_prefetch_mutex);
+	return ret;
+}
+
+int prefetch_start_boot_prefetching_phase(char *phase_name)
+{
+	char *boot_trace_filename = NULL;
+	int ret = 0;
+	if (!prefetch_enabled) {
+		printk(KERN_INFO "Prefetching disabled, not starting prefetching for boot phase: %s\n", phase_name);
+		return 0;
+	}
+	
+	boot_trace_filename = kasprintf(GFP_KERNEL, filename_template,
+		phase_name
+		);
+	
+	if (boot_trace_filename == NULL) {
+		printk(KERN_WARNING "Cannot allocate memory for trace filename\n");
+		ret = -ENOMEM;
+		goto out;
+	}
+	
+	printk(KERN_INFO "Starting prefetching for boot phase: %s\n", phase_name);
+	ret = do_prefetch_from_file(boot_trace_filename);
+	
+	if (ret < 0)
+		printk("Failed to prefetch trace from file %s, error=%d\n", boot_trace_filename, ret);
+	
+out:
+	if (boot_trace_filename != NULL)
+		kfree(boot_trace_filename);
+	
+	return ret;
+}
+	
+
+
+/**
+	Starts next phase of boot.
+	Starts tracing. Then, if trace is available, loads it and starts
+	prefetch.
+	@cmd_name is the name of action, if you want to keep its contents,
+	copy it somewhere, as it will be deallocated.
+	@phase_name is the name of new phase, if you want to keep its contents,
+	copy it somewhere, as it will be deallocated.
+*/
+static int prefetch_start_boot_phase(char *cmd_name, char *phase_name)
+{
+	int ret = 0;
+	int start_prefetching = 0;
+	int start_tracing = 0;
+	
+	if (strcmp(cmd_name, "prefetch") == 0)
+		start_prefetching = 1;
+	else if (strcmp(cmd_name, "trace") == 0)
+		start_tracing = 1;
+	else if (strcmp(cmd_name, "both") == 0) {
+		start_prefetching = 1;
+		start_tracing = 1;
+	} else {
+		printk(KERN_WARNING "Boot prefetch: unknown command: %s for phase %s\n", 
+			cmd_name, 
+			phase_name
+			);
+		return -EINVAL;
+	}
+	if (start_tracing)
+		prefetch_start_boot_tracing_phase(phase_name);
+	
+	if (start_prefetching)
+		ret = prefetch_start_boot_prefetching_phase(phase_name);
+	
+	return ret;
+}
+
+static int prefetch_stop_boot_tracing(void)
+{
+	trace_marker_t marker;
+	int ret = 0;
+	printk(KERN_INFO "Stopping boot tracing and prefetching\n");
+	
+	mutex_lock(&boot_prefetch_mutex);
+	
+	if (!boot_tracing_running) {
+		printk("Trying to stop boot tracing although tracing is not running\n");
+		ret = -EINVAL;
+		goto out_unlock;
+	}
+	
+	ret = prefetch_stop_trace(&marker);
+	if (ret < 0)
+		printk(KERN_WARNING "Stopping tracing for boot tracing returned error, error=%d\n", ret);
+	
+	boot_tracing_running = 0;
+	
+#ifdef PREFETCH_DEBUG
+	print_marker("Boot stop marker: ", marker);
+#endif
+	
+	ret = prefetch_save_boot_trace(boot_tracing_phase, marker);
+	if (ret < 0) {
+		printk(KERN_WARNING "Saving final boot trace failed, phase %s, error=%d\n", boot_tracing_phase, ret);
+		goto out_unlock_release;
+	}
+	
+out_unlock_release:
+	ret = prefetch_release_trace(marker);
+	if (ret < 0)
+		printk(KERN_WARNING "Releasing trace for boot tracing returned error, error=%d\n", ret);
+	
+out_unlock:
+	mutex_unlock(&boot_prefetch_mutex);
+	return ret;
+}
+
+int param_match_prefix(char *line, char *param_name)
+{
+	unsigned param_len = strlen(param_name);
+	if (strncmp(line, param_name, param_len) == 0)
+		return 1;
+	
+	return 0;
+}
+
+ssize_t boot_prefetch_proc_write(struct file *proc_file, const char __user * buffer,
+	size_t count, loff_t *ppos)
+{
+	char *name;
+	int e = 0;
+	int r;
+	char *phase_name;
+	char *cmd_name;
+
+	if (count >= PATH_MAX)
+		return -ENAMETOOLONG;
+
+	name = kmalloc(count+1, GFP_KERNEL);
+	if (!name)
+		return -ENOMEM;
+
+	if (copy_from_user(name, buffer, count)) {
+		e = -EFAULT;
+		goto out;
+	}
+
+	/* strip the optional newline */
+	if (count && name[count-1] == '\n')
+		name[count-1] = '\0';
+	else
+		name[count] = '\0';
+
+	if (param_match(name, "prefetch enable")) {
+		printk(KERN_INFO "Prefetching enabled\n");
+		prefetch_enabled = 1;
+		goto out;
+	}
+	
+	if (param_match(name, "prefetch disable")) {
+		printk(KERN_INFO "Prefetching disabled\n");
+		prefetch_enabled = 0;
+		goto out;
+	}
+	
+	if (param_match_prefix(name, "start ")) {
+		phase_name = kzalloc(PHASE_NAME_MAX + 1, GFP_KERNEL); //1 for terminating NULL
+		if (phase_name == NULL) {
+			printk(KERN_WARNING "Cannot allocate memory for phase name\n");
+			goto out;
+		}
+		cmd_name = kzalloc(CMD_NAME_MAX + 1, GFP_KERNEL); //1 for terminating NULL
+		if (cmd_name == NULL) {
+			printk(KERN_WARNING "Cannot allocate memory for command name\n");
+			goto out;
+		}
+		r = sscanf(name, 
+			"start %" CMD_NAME_MAX_S "s phase %" PHASE_NAME_MAX_S "s",
+			cmd_name,
+			phase_name
+			);
+		if (r != 2) {
+			e = -EINVAL;
+			printk(KERN_WARNING "Wrong parameter to start command, command was: %s\n",
+				name
+				);
+			kfree(phase_name);
+			kfree(cmd_name);
+			goto out;
+		}
+		e = prefetch_start_boot_phase(cmd_name, phase_name);
+		kfree(phase_name);
+		kfree(cmd_name);
+		goto out;
+	}
+	
+	if (param_match(name, "boot tracing stop")) {
+		e = prefetch_stop_boot_tracing();
+		goto out;
+	}
+out:
+	kfree(name);
+
+	return e ? e : count;
+}
+
+static int boot_prefetch_proc_open(struct inode *inode, struct file *proc_file)
+{
+	return 0;
+}
+
+static int boot_prefetch_proc_release(struct inode *inode, struct file *proc_file)
+{
+	return 0;
+}
+
+static struct file_operations proc_boot_prefetch_fops = {

+	.owner		= THIS_MODULE,
+	.open		= boot_prefetch_proc_open,
+	.release		= boot_prefetch_proc_release,
+	.write		= boot_prefetch_proc_write,
+};
+
+static __init int boot_prefetch_init(void)
+{
+	struct proc_dir_entry *entry;
+	
+	mutex_init(&boot_prefetch_mutex);
+
+	if (prefetch_proc_dir == NULL) {
+		printk(KERN_WARNING "Prefetch proc directory not present, proc interface for boot prefetching will not be available\n");
+	} else {
+		//create proc entry
+		entry = create_proc_entry("boot", 0600, prefetch_proc_dir);
+		if (entry)
+			entry->proc_fops = &proc_boot_prefetch_fops;
+	}
+	printk(KERN_INFO "Boot prefetching module started, enabled=%d, prefetching=%d\n",
+		enabled,
+		prefetch_enabled
+		);
+
+	return 0;
+}
+
+static void boot_prefetch_exit(void)
+{
+	remove_proc_entry("boot", prefetch_proc_dir);
+}
+
+MODULE_AUTHOR("Krzysztof Lichota <lichota@mimuw.edu.pl>");
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("Boot prefetching - support for tracing and prefetching during system boot");
+
+module_init(boot_prefetch_init);
+module_exit(boot_prefetch_exit);
-- 
1.1.3

Show details Hide details

Change log

r366 by krzysztof.lichota on Aug 20, 2007 Diff

Added end of Summer of Code tag contents.

Go to:

Project members, sign in to write a code review

Older revisions

r269 by krzysztof.lichota on Aug 10, 2007 Diff

Patches submitted to Ubuntu kernel
team for review.

All revisions of this file

File info

Size: 12151 bytes, 441 lines

View raw file