Skip to contentSkip to conversation

getrusage() : Fill ru_inblock and ru_oublock fields if possible

PATCH In review Eric Dumazet 3 participants 4 messages Mar 19, 2007

Subsystems (3)
lore
Share & tools
lore
#0 lore raw

PATCH 1/1 getrusage() : Fill ru_inblock and ru_oublock fields if possible

Hi Andrew

Here is the third version of this patch. Could you please update mm with it ?

As noticed by Oleg, previous versions were wrong, reporting three times SELF values, and no support for RUSAGE_CHILDREN.

RUSAGE_CHILDREN support imply we add four fields in signal_struct, to be able to accumulate inblock/oublock of terminated and waited-for children, and terminated threads.

Thank you

[PATCH, take3] getrusage() : Fill ru_inblock and ru_oublock fields if possible

If CONFIG_TASK_IO_ACCOUNTING is defined, we update io accounting counters for each task.

This patch permits reporting of these values using the well known getrusage() syscall, filling ru_inblock and ru_oublock instead of null values.

For RUSAGE_CHILDREN support, we must add two new fields in struct signal_struct, named cinblock and coublock, where we sum the inblock/oublock values of terminated and waited-for children. Two other fields, inblock and oublock are added too to sum the data for terminated sibling threads.

As TASK_IO_ACCOUNTING currently counts bytes, we approximate blocks count doing : nr_blocks = nr_bytes / 512

Example of use :
----------------------
After patch is applied, /usr/bin/time command can now give a good approximation of IO that the process (and its children) had to do.

$ /usr/bin/time dd if=/dev/zero of=/tmp/testfile count=1000
1000+0 records in
1000+0 records out
512000 bytes (512 kB) copied, 0.0033976 seconds, 151 MB/s
0.00user 0.00system 0:00.00elapsed 100%CPU (0avgtext+0avgdata 0maxresident)k
0inputs+1000outputs (0major+235minor)pagefaults 0swaps
# /usr/bin/time updatedb
1.58user 6.20system 4:26.06elapsed 2%CPU (0avgtext+0avgdata 0maxresident)k
881088inputs+22464outputs (2major+1163minor)pagefaults 0swaps
---
 include/linux/sched.h                  |    1 
 include/linux/task_io_accounting_ops.h |   28 +++++++++++++++++++++++
 kernel/exit.c                          |    9 +++++++
 kernel/fork.c                          |    1 
 kernel/sys.c                           |    7 +++++
 5 files changed, 46 insertions(+)
include/linux/sched.h +1 -0
@@ -457,6 +457,7 @@ struct signal_struct {
 	cputime_t utime, stime, cutime, cstime;
 	unsigned long nvcsw, nivcsw, cnvcsw, cnivcsw;
 	unsigned long min_flt, maj_flt, cmin_flt, cmaj_flt;
+	unsigned long inblock, oublock, cinblock, coublock;
 
 	/*
 	 * Cumulative ns of scheduled CPU time for dead threads in the
include/linux/task_io_accounting_ops.h +28 -0
@@ -10,11 +10,29 @@ static inline void task_io_account_read(
 	current->ioac.read_bytes += bytes;
 }
 
+/*
+ * We approximate number of blocks, because we account bytes only.
+ * A 'block' is 512 bytes
+ */
+static inline unsigned long task_io_get_inblock(const struct task_struct *p)
+{
+	return p->ioac.read_bytes >> 9;
+}
+
 static inline void task_io_account_write(size_t bytes)
 {
 	current->ioac.write_bytes += bytes;
 }
 
+/*
+ * We approximate number of blocks, because we account bytes only.
+ * A 'block' is 512 bytes
+ */
+static inline unsigned long task_io_get_oublock(const struct task_struct *p)
+{
+	return p->ioac.write_bytes >> 9;
+}
+
 static inline void task_io_account_cancelled_write(size_t bytes)
 {
 	current->ioac.cancelled_write_bytes += bytes;
@@ -31,10 +49,20 @@ static inline void task_io_account_read(
 {
 }
 
+static inline unsigned long task_io_get_inblock(const struct task_struct *p)
+{
+	return 0;
+}
+
 static inline void task_io_account_write(size_t bytes)
 {
 }
 
+static inline unsigned long task_io_get_oublock(const struct task_struct *p)
+{
+	return 0;
+}
+
 static inline void task_io_account_cancelled_write(size_t bytes)
 {
 }
kernel/sys.c +7 -0
@@ -29,6 +29,7 @@
 #include <linux/signal.h>
 #include <linux/cn_proc.h>
 #include <linux/getcpu.h>
+#include <linux/task_io_accounting_ops.h>
 
 #include <linux/compat.h>
 #include <linux/syscalls.h>
@@ -2021,6 +2022,8 @@ static void k_getrusage(struct task_stru
 			r->ru_nivcsw = p->signal->cnivcsw;
 			r->ru_minflt = p->signal->cmin_flt;
 			r->ru_majflt = p->signal->cmaj_flt;
+			r->ru_inblock = p->signal->cinblock;
+			r->ru_oublock = p->signal->coublock;
 
 			if (who == RUSAGE_CHILDREN)
 				break;
@@ -2032,6 +2035,8 @@ static void k_getrusage(struct task_stru
 			r->ru_nivcsw += p->signal->nivcsw;
 			r->ru_minflt += p->signal->min_flt;
 			r->ru_majflt += p->signal->maj_flt;
+			r->ru_inblock += p->signal->inblock;
+			r->ru_oublock += p->signal->oublock;
 			t = p;
 			do {
 				utime = cputime_add(utime, t->utime);
@@ -2040,6 +2045,8 @@ static void k_getrusage(struct task_stru
 				r->ru_nivcsw += t->nivcsw;
 				r->ru_minflt += t->min_flt;
 				r->ru_majflt += t->maj_flt;
+				r->ru_inblock += task_io_get_inblock(t);
+				r->ru_oublock += task_io_get_oublock(t);
 				t = next_thread(t);
 			} while (t != p);
 			break;
kernel/fork.c +1 -0
@@ -874,6 +874,7 @@ static inline int copy_signal(unsigned l
 	sig->utime = sig->stime = sig->cutime = sig->cstime = cputime_zero;
 	sig->nvcsw = sig->nivcsw = sig->cnvcsw = sig->cnivcsw = 0;
 	sig->min_flt = sig->maj_flt = sig->cmin_flt = sig->cmaj_flt = 0;
+	sig->inblock = sig->oublock = sig->cinblock = sig->coublock = 0;
 	sig->sched_time = 0;
 	INIT_LIST_HEAD(&sig->cpu_timers[0]);
 	INIT_LIST_HEAD(&sig->cpu_timers[1]);
kernel/exit.c +9 -0
@@ -42,6 +42,7 @@
 #include <linux/audit.h> /* for audit_free() */
 #include <linux/resource.h>
 #include <linux/blkdev.h>
+#include <linux/task_io_accounting_ops.h>
 
 #include <asm/uaccess.h>
 #include <asm/unistd.h>
@@ -113,6 +114,8 @@ static void __exit_signal(struct task_st
 		sig->nvcsw += tsk->nvcsw;
 		sig->nivcsw += tsk->nivcsw;
 		sig->sched_time += tsk->sched_time;
+		sig->inblock += task_io_get_inblock(tsk);
+		sig->oublock += task_io_get_oublock(tsk);
 		sig = NULL; /* Marker for below. */
 	}
 
@@ -1191,6 +1194,12 @@ static int wait_task_zombie(struct task_
 			p->nvcsw + sig->nvcsw + sig->cnvcsw;
 		psig->cnivcsw +=
 			p->nivcsw + sig->nivcsw + sig->cnivcsw;
+		psig->cinblock +=
+			task_io_get_inblock(p) +
+			sig->inblock + sig->cinblock;
+		psig->coublock +=
+			task_io_get_oublock(p) +
+			sig->oublock + sig->coublock;
 		spin_unlock_irq(&p->parent->sighand->siglock);
 	}
 
#1 lore raw

kernel/sys.c static void k_getrusage(struct task_stru · line 2051

Quoted 12 lines · Eric Dumazet

[...snip...]

kernel/sys.c +2 -0
 			do {
 				utime = cputime_add(utime, t->utime);
@@ -2040,6 +2045,8 @@ static void k_getrusage(struct task_stru
 				r->ru_nivcsw += t->nivcsw;
 				r->ru_minflt += t->min_flt;
 				r->ru_majflt += t->maj_flt;
+				r->ru_inblock += task_io_get_inblock(t);
+				r->ru_oublock += task_io_get_oublock(t);
 				t = next_thread(t);
 			} while (t != p);

(offtopic)

We are reading u64 read_bytes/write_bytes which could be updated asynchronously. /proc/pid/io does the same.

Of course, I don't blame this patch, just a stupid question: can we do something? I guess not.

Oleg.

#2 lore raw
Quoted 1 line · On Mon, 19 Mar 2007 17:37:23 +0300 Oleg Nesterov <[email protected]> wrote:

(offtopic)

Well..., it *is* ontopic I'm afraid...

Quoted 6 lines

We are reading u64 read_bytes/write_bytes which could be updated asynchronously. /proc/pid/io does the same.

Of course, I don't blame this patch, just a stupid question: can we do something? I guess not.

We could do a proper thing with a seqlock (only needed on 32bit arches) See for example what is done for i_size in struct inode, with i_size_seqcount

Eric

maintainer
#3 lore raw
In reply to Oleg Nesterov
Quoted 16 lines · On Mon, 19 Mar 2007 17:37:23 +0300 Oleg Nesterov <[email protected]> wrote:

kernel/sys.c static void k_getrusage(struct task_stru · line 2051

Quoted 12 lines · Eric Dumazet

[...snip...]

kernel/sys.c +2 -0
 			do {
 				utime = cputime_add(utime, t->utime);
@@ -2040,6 +2045,8 @@ static void k_getrusage(struct task_stru
 				r->ru_nivcsw += t->nivcsw;
 				r->ru_minflt += t->min_flt;
 				r->ru_majflt += t->maj_flt;
+				r->ru_inblock += task_io_get_inblock(t);
+				r->ru_oublock += task_io_get_oublock(t);
 				t = next_thread(t);
 			} while (t != p);

(offtopic)

Quoted 2 lines

We are reading u64 read_bytes/write_bytes which could be updated asynchronously. /proc/pid/io does the same.

Yup, as noted in the Documentation/filesystems/proc.txt documentation ;)

Quoted 2 lines

Of course, I don't blame this patch, just a stupid question: can we do something? I guess not.

Yes, I find it hard to justify the additional expense which fixing this would cause.

Which probably means that someone will find it terribly terribly important and we have to go and do something horrid anyway. Sigh.