Re: zpool v28 and -current

Shawn Webb <lattera_at_gmail.com> writes:

> I'm having trouble building freebsd-current (sources as of 29 Jan 2011) with
> the latest zpool v28 patch. `make buildworld` fails. I'd attach a copy of
> the build log, but it's pretty big. I can put it online on my tech blog if
> needed. Has anyone else had the same problem? The `uname -a` output of the
> box in question:
>
> FreeBSD beastie 9.0-CURRENT FreeBSD 9.0-CURRENT #0 r218075: Sat Jan 29
> 15:14:44 MST 2011     shawn_at_beastie:/usr/obj/usr/src/sys/GENERIC  amd64

Try below diff-against-diff. I'm using it for weeks with a few p4 commits.

inb4 you're encouraged to wait after 7.4/8.2 are out

%%
--- zfs_20101212.patch		pjd's original
+++ zfs_20101212.patch		sync with r218058
_at__at_ -34850,12 +34851,14 _at__at_
  {
 --- sys/cddl/compat/opensolaris/sys/atomic.h.orig
 +++ sys/cddl/compat/opensolaris/sys/atomic.h
-_at__at_ -39,9 +39,10 _at__at_
- #ifndef __LP64__
+_at__at_ -39,11 +39,10 _at__at_
+ #if !defined(__LP64__) && !defined(__mips_n32)
  extern void atomic_add_64(volatile uint64_t *target, int64_t delta);
  extern void atomic_dec_64(volatile uint64_t *target);
--extern void *atomic_cas_ptr(volatile void *target, void *cmp,  void *newval);
  #endif
+-#ifndef __LP64__
+-extern void *atomic_cas_ptr(volatile void *target, void *cmp,  void *newval);
+-#endif
  #ifndef __sparc64__
 +extern uint32_t atomic_cas_32(volatile uint32_t *target, uint32_t cmp,
 +    uint32_t newval);
_at__at_ -38448,9 +38451,9 _at__at_
  TUNABLE_QUAD("vfs.zfs.arc_meta_limit", &zfs_arc_meta_limit);
 -TUNABLE_INT("vfs.zfs.mdcomp_disable", &zfs_mdcomp_disable);
  SYSCTL_DECL(_vfs_zfs);
- SYSCTL_QUAD(_vfs_zfs, OID_AUTO, arc_max, CTLFLAG_RDTUN, &zfs_arc_max, 0,
+ SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, arc_max, CTLFLAG_RDTUN, &zfs_arc_max, 0,
      "Maximum ARC size");
- SYSCTL_QUAD(_vfs_zfs, OID_AUTO, arc_min, CTLFLAG_RDTUN, &zfs_arc_min, 0,
+ SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, arc_min, CTLFLAG_RDTUN, &zfs_arc_min, 0,
      "Minimum ARC size");
 -SYSCTL_INT(_vfs_zfs, OID_AUTO, mdcomp_disable, CTLFLAG_RDTUN,
 -    &zfs_mdcomp_disable, 0, "Disable metadata compression");
_at__at_ -56065,16 +56068,16 _at__at_
 +    &zfs_txg_synctime_ms, 0, "Target milliseconds to sync a txg");
 +
 +TUNABLE_QUAD("vfs.zfs.write_limit_min", &zfs_write_limit_min);
-+SYSCTL_QUAD(_vfs_zfs, OID_AUTO, write_limit_min, CTLFLAG_RDTUN,
++SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, write_limit_min, CTLFLAG_RDTUN,
 +    &zfs_write_limit_min, 0, "Minimum write limit");
 +TUNABLE_QUAD("vfs.zfs.write_limit_max", &zfs_write_limit_max);
-+SYSCTL_QUAD(_vfs_zfs, OID_AUTO, write_limit_max, CTLFLAG_RDTUN,
++SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, write_limit_max, CTLFLAG_RDTUN,
 +    &zfs_write_limit_max, 0, "Maximum data payload per txg");
 +TUNABLE_QUAD("vfs.zfs.write_limit_inflated", &zfs_write_limit_inflated);
-+SYSCTL_QUAD(_vfs_zfs, OID_AUTO, write_limit_inflated, CTLFLAG_RDTUN,
++SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, write_limit_inflated, CTLFLAG_RDTUN,
 +    &zfs_write_limit_inflated, 0, "");
 +TUNABLE_QUAD("vfs.zfs.write_limit_override", &zfs_write_limit_override);
-+SYSCTL_QUAD(_vfs_zfs, OID_AUTO, write_limit_override, CTLFLAG_RDTUN,
++SYSCTL_UQUAD(_vfs_zfs, OID_AUTO, write_limit_override, CTLFLAG_RDTUN,
 +    &zfs_write_limit_override, 0, "");
 +
 +int
_at__at_ -75748,7 +75751,7 _at__at_
  	uint64_t	*io_stall;
  	zio_t		*io_gang_leader;
  	zio_gang_node_t	*io_gang_tree;
-_at__at_ -336,56 +416,64 _at__at_
+_at__at_ -336,57 +416,64 _at__at_
  	kcondvar_t	io_cv;
  
  	/* FMA state */
_at__at_ -75757,9 +75760,8 _at__at_
  
  #ifdef _KERNEL
  	/* FreeBSD only. */
--	struct ostask	io_task;
-+	struct ostask	io_task_issue;
-+	struct ostask	io_task_interrupt;
+ 	struct ostask	io_task_issue;
+ 	struct ostask	io_task_interrupt;
  #endif
  };
  
_at__at_ -76377,7 +76379,7 _at__at_
 -SYSCTL_INT(_vfs_zfs_txg, OID_AUTO, synctime, CTLFLAG_RDTUN, &zfs_txg_synctime,
 -    0, "Target seconds to sync a txg");
 -TUNABLE_QUAD("vfs.zfs.txg.write_limit_override", &zfs_write_limit_override);
--SYSCTL_QUAD(_vfs_zfs_txg, OID_AUTO, write_limit_override, CTLFLAG_RW,
+-SYSCTL_UQUAD(_vfs_zfs_txg, OID_AUTO, write_limit_override, CTLFLAG_RW,
 -    &zfs_write_limit_override, 0,
 -    "Override maximum size of a txg to this size in bytes, "
 -    "value of 0 means don't override");
_at__at_ -103163,7 +103165,7 _at__at_
  	}
  
  	return (ZIO_PIPELINE_CONTINUE);
-_at__at_ -943,10 +1063,23 _at__at_
+_at__at_ -943,10 +1063,11 _at__at_
   */
  
  static void
_at__at_ -103173,36 +103175,22 _at__at_
  	spa_t *spa = zio->io_spa;
  	zio_type_t t = zio->io_type;
 +	int flags = TQ_SLEEP | (cutinline ? TQ_FRONT : 0);
-+#ifdef _KERNEL
-+	struct ostask *task;
-+#endif
-+
-+	ASSERT(q == ZIO_TASKQ_ISSUE || q == ZIO_TASKQ_INTERRUPT);
-+
-+#ifdef _KERNEL
-+	if (q == ZIO_TASKQ_ISSUE)
-+		task = &zio->io_task_issue;
-+	else /* if (q == ZIO_TASKQ_INTERRUPT) */
-+		task = &zio->io_task_interrupt;
-+#endif
- 
- 	/*
- 	 * If we're a config writer or a probe, the normal issue and
-_at__at_ -970,8 +1103,13 _at__at_
- 		q++;
- 
+ #ifdef _KERNEL
+ 	struct ostask *task;
+ #endif
+_at__at_ -972,10 +1105,10 _at__at_
  	ASSERT3U(q, <, ZIO_TASKQ_TYPES);
-+#ifdef _KERNEL
+ #ifdef _KERNEL
  	(void) taskq_dispatch_safe(spa->spa_zio_taskq[t][q],
--	    (task_func_t *)zio_execute, zio, &zio->io_task);
+-	    (task_func_t *)zio_execute, zio, task);
 +	    (task_func_t *)zio_execute, zio, flags, task);
-+#else
-+	(void) taskq_dispatch(spa->spa_zio_taskq[t][q],
+ #else
+ 	(void) taskq_dispatch(spa->spa_zio_taskq[t][q],
+-	    (task_func_t *)zio_execute, zio, TQ_SLEEP);
 +	    (task_func_t *)zio_execute, zio, flags);
-+#endif
+ #endif
  }
  
- static boolean_t
 _at__at_ -990,7 +1128,7 _at__at_
  static int
  zio_issue_async(zio_t *zio)
_at__at_ -104217,22 +104205,16 _at__at_
  
  	zio_gang_tree_free(&zio->io_gang_tree);
  
-_at__at_ -2300,18 +2900,36 _at__at_
- 			 * Reexecution is potentially a huge amount of work.
- 			 * Hand it off to the otherwise-unused claim taskq.
- 			 */
-+#ifdef _KERNEL
+_at__at_ -2303,7 +2903,7 _at__at_
+ #ifdef _KERNEL
  			(void) taskq_dispatch_safe(
  			    spa->spa_zio_taskq[ZIO_TYPE_CLAIM][ZIO_TASKQ_ISSUE],
--			    (task_func_t *)zio_reexecute, zio, &zio->io_task);
+-			    (task_func_t *)zio_reexecute, zio,
 +			    (task_func_t *)zio_reexecute, zio, TQ_SLEEP,
-+			    &zio->io_task_issue);
-+#else
-+			(void) taskq_dispatch(
-+			    spa->spa_zio_taskq[ZIO_TYPE_CLAIM][ZIO_TASKQ_ISSUE],
-+			    (task_func_t *)zio_reexecute, zio, TQ_SLEEP);
-+#endif
- 		}
+ 				&zio->io_task_issue);
+ #else
+ 			(void) taskq_dispatch(
+_at__at_ -2314,11 +2914,22 _at__at_
  		return (ZIO_PIPELINE_STOP);
  	}
  
%%