Use sys_clone under Linux to share I/O contexts between dump processes.

[dump.git] / dump / tape.c

diff --git a/dump/tape.c b/dump/tape.c
index bd1e2f90c0bde55892a4e4365b1ad0dc1c230984..edcf5d691925a6532dd71e8b30f75514d8190109 100644 (file)
--- a/dump/tape.c
+++ b/dump/tape.c
@@ -37,7 +37,7 @@
 
 #ifndef lint
 static const char rcsid[] =
-       "$Id: tape.c,v 1.84 2004/05/25 10:39:29 stelian Exp $";
+       "$Id: tape.c,v 1.91 2009/06/18 09:50:54 stelian Exp $";
 #endif /* not lint */
 
 #include <config.h>
@@ -60,7 +60,11 @@ int    write(), read();
 #ifdef __linux__
 #include <sys/types.h>
 #include <sys/time.h>
-#include <linux/fs.h>  /* for definition of BLKFLSBUF */
+#include <sys/ioctl.h>
+#include <sys/mount.h> /* for definition of BLKFLSBUF */
+#ifndef BLKFLSBUF      /* last resort... */
+#define BLKFLSBUF _IO(0x12, 97) /* Flush buffer cache.  */
+#endif
 #include <time.h>
 #endif
 #include <sys/param.h>
@@ -142,7 +146,7 @@ static int MkTapeString __P((struct s_spcl *, long long));
  * The following structure defines the instruction packets sent to slaves.
  */
 struct req {
-       daddr_t dblk;
+       ext2_loff_t dblk;
        int count;
 };
 int reqsiz;
@@ -183,6 +187,41 @@ static sigjmp_buf jmpbuf;  /* where to jump to if we are ready when the */
 static int gtperr = 0;
 #endif
 
+/*
+ * Determine if we can use Linux' clone system call.  If so, call it
+ * with the CLONE_IO flag so that all processes will share the same I/O
+ * context, allowing the I/O schedulers to make better scheduling decisions.
+ */
+#ifdef __linux__
+/* first, pull in the header files that define sys_clone and CLONE_IO */
+#include <syscall.h>
+#define _GNU_SOURCE
+#include <sched.h>
+#include <unistd.h>
+#undef _GNU_SOURCE
+
+/* If either is not present, fall back on the fork behaviour */
+#if ! defined(SYS_clone) || ! defined (CLONE_IO)
+#define fork_clone_io fork
+#else /* SYS_clone */
+/* CLONE_IO is available, determine which version of sys_clone to use */
+#include <linux/version.h>
+/*
+ * Kernel 2.5.49 introduced two extra parameters to the clone system call.
+ * Neither is useful in our case, so this is easy to handle.
+ */
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,49)
+/* clone_flags, child_stack, parent_tidptr, child_tidptr */
+#define CLONE_ARGS SIGCHLD|CLONE_IO, 0, NULL, NULL
+#else
+#define CLONE_ARGS SIGCHLD|CLONE_IO, 0
+#endif /* LINUX_VERSION_CODE */
+pid_t fork_clone_io(void);
+#endif /* SYS_clone */
+#else /* __linux__ not defined */
+#define fork_clone_io fork
+#endif /* __linux__ */
+
 int
 alloctape(void)
 {
@@ -234,7 +273,7 @@ void
 writerec(const void *dp, int isspcl)
 {
 
-       slp->req[trecno].dblk = (daddr_t)0;
+       slp->req[trecno].dblk = (ext2_loff_t)0;
        slp->req[trecno].count = 1;
        /* XXX post increment triggers an egcs-1.1.2-12 bug on alpha/sparc */
        *(union u_spcl *)(*(nextblock)) = *(union u_spcl *)dp;
@@ -242,7 +281,7 @@ writerec(const void *dp, int isspcl)
        /* Need to write it to the archive file */
        if (! AfileActive && isspcl && (spcl.c_type == TS_END))
                AfileActive = 1;
-       if (AfileActive && Afile >= 0) {
+       if (AfileActive && Afile >= 0 && !(spcl.c_flags & DR_EXTATTRIBUTES)) {
                /* When we dump an inode which is not a directory,
                 * it means we ended the archive contents */
                if (isspcl && (spcl.c_type == TS_INODE) &&
@@ -272,9 +311,10 @@ writerec(const void *dp, int isspcl)
 }
 
 void
-dumpblock(daddr_t blkno, int size)
+dumpblock(blk_t blkno, int size)
 {
-       int avail, tpblks, dblkno;
+       int avail, tpblks;
+       ext2_loff_t dblkno;
 
        dblkno = fsbtodb(sblock, blkno);
        tpblks = size >> tp_bshift;
@@ -415,6 +455,10 @@ flushtape(void)
 
        int siz = (char *)nextblock - (char *)slp->req;
 
+       /* make sure returned has sane values in case we don't read 
+        * them from the slave in this pass */
+       returned.unclen = returned.clen = writesize;
+
        slp->req[trecno].count = 0;                     /* Sentinel */
 
        if (dump_atomic_write( slp->fd, (char *)slp->req, siz) != siz)
@@ -470,10 +514,14 @@ flushtape(void)
        }
 
        blks = 0;
-       if (spcl.c_type != TS_END) {
-               for (i = 0; i < spcl.c_count; i++)
-                       if (spcl.c_addr[i] != 0)
-                               blks++;
+       if (spcl.c_type == TS_CLRI || spcl.c_type == TS_BITS)
+               blks = spcl.c_count;
+       else {
+               if (spcl.c_type != TS_END) {
+                       for (i = 0; i < spcl.c_count; i++)
+                               if (spcl.c_addr[i] != 0)
+                                       blks++;
+               }
        }
        slp->count = lastspclrec + blks + 1 - spcl.c_tapea;
        slp->tapea = spcl.c_tapea;
@@ -611,6 +659,10 @@ rollforward(void)
        tslp = &slaves[SLAVES];
        ntb = (union u_spcl *)tslp->tblock[1];
 
+       /* make sure returned has sane values in case we don't read 
+        * them from the slave in this pass */
+       returned.unclen = returned.clen = writesize;
+
        /*
         * Each of the N slaves should have requests that need to
         * be replayed on the next tape.  Use the extra slave buffers
@@ -738,6 +790,16 @@ rollforward(void)
 #endif
 }
 
+#ifdef __linux__
+#if defined(SYS_clone) && defined(CLONE_IO)
+pid_t
+fork_clone_io(void)
+{
+       return syscall(SYS_clone, CLONE_ARGS);
+}
+#endif
+#endif
+
 /*
  * We implement taking and restoring checkpoints on the tape level.
  * When each tape is opened, a new process is created by forking; this
@@ -784,7 +846,7 @@ restore_check_point:
        /*
         *      All signals are inherited...
         */
-       childpid = fork();
+       childpid = fork_clone_io();
        if (childpid < 0) {
                msg("Context save fork fails in parent %d\n", parentpid);
                Exit(X_ABORT);
@@ -1000,7 +1062,7 @@ enslave(void)
                }
 
                if (socketpair(AF_UNIX, SOCK_STREAM, 0, cmd) < 0 ||
-                   (slaves[i].pid = fork()) < 0)
+                   (slaves[i].pid = fork_clone_io()) < 0)
                        quit("too many slaves, %d (recompile smaller): %s\n",
                            i, strerror(errno));
 
@@ -1293,7 +1355,8 @@ doslave(int cmd,
                                if ((spclptr->c_magic == NFS_MAGIC) && 
                                                        (spclptr->c_type == TS_INODE) &&
                                                        (spclptr->c_date == gThisDumpDate) &&
-                                                       !(spclptr->c_dinode.di_mode & S_IFDIR)
+                                                       !(spclptr->c_dinode.di_mode & S_IFDIR) &&
+                                                       !(spclptr->c_flags & DR_EXTATTRIBUTES)
                                                ) {
                                        foundone = 1;
                                        /* if (cntntrecs >= maxntrecs) {         only write every maxntrecs amount of data */