---

yaml
---
r: 209621
b: refs/heads/master
c: 033a273
h: refs/heads/master
i:
  209619: 3120120
v: v3

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: 625fdcaa6d2a3db6a922bbd833450424e906111c
+refs/heads/master: 033a273f9836b592dd568abd0f655be469d66704

trunk/kernel/trace/ring_buffer.c

@@ -3846,9 +3846,6 @@ int ring_buffer_read_page(struct ring_buffer *buffer,
 			rpos = reader->read;
 			pos += size;
 
-			if (rpos >= commit)
-				break;
-
 			event = rb_reader_event(cpu_buffer);
 			size = rb_event_length(event);
 		} while (len > size);

trunk/kernel/trace/trace.c

@@ -3463,7 +3463,6 @@ tracing_mark_write(struct file *filp, const char __user *ubuf,
 					size_t cnt, loff_t *fpos)
 {
 	char *buf;
-	size_t written;
 
 	if (tracing_disabled)
 		return -EINVAL;
@@ -3485,15 +3484,11 @@ tracing_mark_write(struct file *filp, const char __user *ubuf,
 	} else
 		buf[cnt] = '\0';
 
-	written = mark_printk("%s", buf);
+	cnt = mark_printk("%s", buf);
 	kfree(buf);
-	*fpos += written;
-
-	/* don't tell userspace we wrote more - it might confuse them */
-	if (written > cnt)
-		written = cnt;
+	*fpos += cnt;
 
-	return written;
+	return cnt;
 }
 
 static int tracing_clock_show(struct seq_file *m, void *v)

trunk/kernel/trace/trace_events.c

@@ -598,165 +598,88 @@ system_enable_write(struct file *filp, const char __user *ubuf, size_t cnt,
 	return ret;
 }
 
-enum {
-	FORMAT_HEADER		= 1,
-	FORMAT_PRINTFMT		= 2,
-};
-
-static void *f_next(struct seq_file *m, void *v, loff_t *pos)
+static void print_event_fields(struct trace_seq *s, struct list_head *head)
 {
-	struct ftrace_event_call *call = m->private;
 	struct ftrace_event_field *field;
-	struct list_head *head;
-
-	(*pos)++;
-
-	switch ((unsigned long)v) {
-	case FORMAT_HEADER:
-		head = &ftrace_common_fields;
-
-		if (unlikely(list_empty(head)))
-			return NULL;
-
-		field = list_entry(head->prev, struct ftrace_event_field, link);
-		return field;
-
-	case FORMAT_PRINTFMT:
-		/* all done */
-		return NULL;
-	}
 
-	head = trace_get_fields(call);
+	list_for_each_entry_reverse(field, head, link) {
+		/*
+		 * Smartly shows the array type(except dynamic array).
+		 * Normal:
+		 *	field:TYPE VAR
+		 * If TYPE := TYPE[LEN], it is shown:
+		 *	field:TYPE VAR[LEN]
+		 */
+		const char *array_descriptor = strchr(field->type, '[');
 
-	/*
-	 * To separate common fields from event fields, the
-	 * LSB is set on the first event field. Clear it in case.
-	 */
-	v = (void *)((unsigned long)v & ~1L);
+		if (!strncmp(field->type, "__data_loc", 10))
+			array_descriptor = NULL;
 
-	field = v;
-	/*
-	 * If this is a common field, and at the end of the list, then
-	 * continue with main list.
-	 */
-	if (field->link.prev == &ftrace_common_fields) {
-		if (unlikely(list_empty(head)))
-			return NULL;
-		field = list_entry(head->prev, struct ftrace_event_field, link);
-		/* Set the LSB to notify f_show to print an extra newline */
-		field = (struct ftrace_event_field *)
-			((unsigned long)field | 1);
-		return field;
+		if (!array_descriptor) {
+			trace_seq_printf(s, "\tfield:%s %s;\toffset:%u;"
+					"\tsize:%u;\tsigned:%d;\n",
+					field->type, field->name, field->offset,
+					field->size, !!field->is_signed);
+		} else {
+			trace_seq_printf(s, "\tfield:%.*s %s%s;\toffset:%u;"
+					"\tsize:%u;\tsigned:%d;\n",
+					(int)(array_descriptor - field->type),
+					field->type, field->name,
+					array_descriptor, field->offset,
+					field->size, !!field->is_signed);
+		}
 	}
-
-	/* If we are done tell f_show to print the format */
-	if (field->link.prev == head)
-		return (void *)FORMAT_PRINTFMT;
-
-	field = list_entry(field->link.prev, struct ftrace_event_field, link);
-
-	return field;
-}
-
-static void *f_start(struct seq_file *m, loff_t *pos)
-{
-	loff_t l = 0;
-	void *p;
-
-	/* Start by showing the header */
-	if (!*pos)
-		return (void *)FORMAT_HEADER;
-
-	p = (void *)FORMAT_HEADER;
-	do {
-		p = f_next(m, p, &l);
-	} while (p && l < *pos);
-
-	return p;
 }
 
-static int f_show(struct seq_file *m, void *v)
+static ssize_t
+event_format_read(struct file *filp, char __user *ubuf, size_t cnt,
+		  loff_t *ppos)
 {
-	struct ftrace_event_call *call = m->private;
-	struct ftrace_event_field *field;
-	const char *array_descriptor;
-
-	switch ((unsigned long)v) {
-	case FORMAT_HEADER:
-		seq_printf(m, "name: %s\n", call->name);
-		seq_printf(m, "ID: %d\n", call->event.type);
-		seq_printf(m, "format:\n");
-		return 0;
+	struct ftrace_event_call *call = filp->private_data;
+	struct list_head *head;
+	struct trace_seq *s;
+	char *buf;
+	int r;
 
-	case FORMAT_PRINTFMT:
-		seq_printf(m, "\nprint fmt: %s\n",
-			   call->print_fmt);
+	if (*ppos)
 		return 0;
-	}
-
-	/*
-	 * To separate common fields from event fields, the
-	 * LSB is set on the first event field. Clear it and
-	 * print a newline if it is set.
-	 */
-	if ((unsigned long)v & 1) {
-		seq_putc(m, '\n');
-		v = (void *)((unsigned long)v & ~1L);
-	}
-
-	field = v;
-
-	/*
-	 * Smartly shows the array type(except dynamic array).
-	 * Normal:
-	 *	field:TYPE VAR
-	 * If TYPE := TYPE[LEN], it is shown:
-	 *	field:TYPE VAR[LEN]
-	 */
-	array_descriptor = strchr(field->type, '[');
 
-	if (!strncmp(field->type, "__data_loc", 10))
-		array_descriptor = NULL;
+	s = kmalloc(sizeof(*s), GFP_KERNEL);
+	if (!s)
+		return -ENOMEM;
 
-	if (!array_descriptor)
-		seq_printf(m, "\tfield:%s %s;\toffset:%u;\tsize:%u;\tsigned:%d;\n",
-			   field->type, field->name, field->offset,
-			   field->size, !!field->is_signed);
-	else
-		seq_printf(m, "\tfield:%.*s %s%s;\toffset:%u;\tsize:%u;\tsigned:%d;\n",
-			   (int)(array_descriptor - field->type),
-			   field->type, field->name,
-			   array_descriptor, field->offset,
-			   field->size, !!field->is_signed);
+	trace_seq_init(s);
 
-	return 0;
-}
+	trace_seq_printf(s, "name: %s\n", call->name);
+	trace_seq_printf(s, "ID: %d\n", call->event.type);
+	trace_seq_printf(s, "format:\n");
 
-static void f_stop(struct seq_file *m, void *p)
-{
-}
+	/* print common fields */
+	print_event_fields(s, &ftrace_common_fields);
 
-static const struct seq_operations trace_format_seq_ops = {
-	.start		= f_start,
-	.next		= f_next,
-	.stop		= f_stop,
-	.show		= f_show,
-};
+	trace_seq_putc(s, '\n');
 
-static int trace_format_open(struct inode *inode, struct file *file)
-{
-	struct ftrace_event_call *call = inode->i_private;
-	struct seq_file *m;
-	int ret;
+	/* print event specific fields */
+	head = trace_get_fields(call);
+	print_event_fields(s, head);
 
-	ret = seq_open(file, &trace_format_seq_ops);
-	if (ret < 0)
-		return ret;
+	r = trace_seq_printf(s, "\nprint fmt: %s\n", call->print_fmt);
 
-	m = file->private_data;
-	m->private = call;
+	if (!r) {
+		/*
+		 * ug!  The format output is bigger than a PAGE!!
+		 */
+		buf = "FORMAT TOO BIG\n";
+		r = simple_read_from_buffer(ubuf, cnt, ppos,
+					      buf, strlen(buf));
+		goto out;
+	}
 
-	return 0;
+	r = simple_read_from_buffer(ubuf, cnt, ppos,
+				    s->buffer, s->len);
+ out:
+	kfree(s);
+	return r;
 }
 
 static ssize_t
@@ -954,10 +877,8 @@ static const struct file_operations ftrace_enable_fops = {
 };
 
 static const struct file_operations ftrace_event_format_fops = {
-	.open = trace_format_open,
-	.read = seq_read,
-	.llseek = seq_lseek,
-	.release = seq_release,
+	.open = tracing_open_generic,
+	.read = event_format_read,
 };
 
 static const struct file_operations ftrace_event_id_fops = {

trunk/kernel/trace/trace_functions_graph.c

@@ -507,15 +507,7 @@ get_return_for_leaf(struct trace_iterator *iter,
 			 * if the output fails.
 			 */
 			data->ent = *curr;
-			/*
-			 * If the next event is not a return type, then
-			 * we only care about what type it is. Otherwise we can
-			 * safely copy the entire event.
-			 */
-			if (next->ent.type == TRACE_GRAPH_RET)
-				data->ret = *next;
-			else
-				data->ret.ent.type = next->ent.type;
+			data->ret = *next;
 		}
 	}
 

trunk/lib/Kconfig.debug

@@ -994,16 +994,13 @@ config FAULT_INJECTION_STACKTRACE_FILTER
 
 config LATENCYTOP
 	bool "Latency measuring infrastructure"
-	depends on HAVE_LATENCYTOP_SUPPORT
-	depends on DEBUG_KERNEL
-	depends on STACKTRACE_SUPPORT
-	depends on PROC_FS
 	select FRAME_POINTER if !MIPS && !PPC && !S390 && !MICROBLAZE
 	select KALLSYMS
 	select KALLSYMS_ALL
 	select STACKTRACE
 	select SCHEDSTATS
 	select SCHED_DEBUG
+	depends on HAVE_LATENCYTOP_SUPPORT
 	help
 	  Enable this option if you want to use the LatencyTOP tool
 	  to find out which userspace is blocking on what kernel operations.

trunk/scripts/recordmcount.pl

@@ -159,7 +159,6 @@
 my $function_regex;	# Find the name of a function
 			#    (return offset and func name)
 my $mcount_regex;	# Find the call site to mcount (return offset)
-my $mcount_adjust;	# Address adjustment to mcount offset
 my $alignment;		# The .align value to use for $mcount_section
 my $section_type;	# Section header plus possible alignment command
 my $can_use_local = 0; 	# If we can use local function references
@@ -214,7 +213,6 @@ sub check_objcopy
 $function_regex = "^([0-9a-fA-F]+)\\s+<(.*?)>:";
 $mcount_regex = "^\\s*([0-9a-fA-F]+):.*\\smcount\$";
 $section_type = '@progbits';
-$mcount_adjust = 0;
 $type = ".long";
 
 if ($arch eq "x86_64") {
@@ -353,9 +351,6 @@ sub check_objcopy
 } elsif ($arch eq "microblaze") {
     # Microblaze calls '_mcount' instead of plain 'mcount'.
     $mcount_regex = "^\\s*([0-9a-fA-F]+):.*\\s_mcount\$";
-} elsif ($arch eq "blackfin") {
-    $mcount_regex = "^\\s*([0-9a-fA-F]+):.*\\s__mcount\$";
-    $mcount_adjust = -4;
 } else {
     die "Arch $arch is not supported with CONFIG_FTRACE_MCOUNT_RECORD";
 }
@@ -516,7 +511,7 @@ sub update_funcs
     }
     # is this a call site to mcount? If so, record it to print later
     if ($text_found && /$mcount_regex/) {
-	push(@offsets, (hex $1) + $mcount_adjust);
+	push(@offsets, hex $1);
     }
 }