Attachment #147915 for bug #193803




dsl_dataset_rename_snapshot_sync_impl(dsl_pool_t *dp,
    dsl_dataset_t *hds, void *arg)
{
#if defined(__FreeBSD__) && defined(_KERNEL)
#ifdef _KERNEL
	char *oldname, *newname;
#endif
#endif
	dsl_dataset_rename_snapshot_arg_t *ddrsa = arg;
	dsl_dataset_t *ds;
	uint64_t val;

	VERIFY0(zap_add(dp->dp_meta_objset, hds->ds_phys->ds_snapnames_zapobj,
	    ds->ds_snapname, 8, 1, &ds->ds_object, tx));

#if defined(__FreeBSD__) && defined (_KERNEL)
#ifdef _KERNEL
	oldname = kmem_alloc(MAXPATHLEN, KM_SLEEP);
	newname = kmem_alloc(MAXPATHLEN, KM_SLEEP);
	snprintf(oldname, MAXPATHLEN, "%s@%s", ddrsa->ddrsa_fsname,

	kmem_free(newname, MAXPATHLEN);
	kmem_free(oldname, MAXPATHLEN);
#endif
#endif
	dsl_dataset_rele(ds, FTAG);

	return (0);

	dsl_dir_t *odd = NULL;
	uint64_t oldnext_obj;
	int64_t delta;
#if defined(__FreeBSD__) && defined(_KERNEL)
	char *oldname, *newname;
#endif

	VERIFY0(promote_hold(ddpa, dp, FTAG));
	hds = ddpa->ddpa_clone;

		    dd->dd_phys->dd_clones, origin_head->ds_object, tx));
	}

#if defined(__FreeBSD__) && defined(_KERNEL)
	/* Take the spa_namespace_lock so zvol renames don't livelock */
	mutex_enter(&spa_namespace_lock);

	oldname = kmem_alloc(MAXPATHLEN, KM_SLEEP);
	newname = kmem_alloc(MAXPATHLEN, KM_SLEEP);
#endif

	/* move snapshots to this dir */
	for (snap = list_head(&ddpa->shared_snaps); snap;
	    snap = list_next(&ddpa->shared_snaps, snap)) {

		VERIFY0(dsl_dir_hold_obj(dp, dd->dd_object,
		    NULL, ds, &ds->ds_dir));

#if defined(__FreeBSD__) && defined(_KERNEL)
		dsl_dataset_name(ds, newname);
		zfsvfs_update_fromname(oldname, newname);
		zvol_rename_minors(oldname, newname);
#endif

		/* move any clone references */
		if (ds->ds_phys->ds_next_clones_obj &&
		    spa_version(dp->dp_spa) >= SPA_VERSION_DIR_CLONES) {

		ASSERT(!dsl_prop_hascb(ds));
	}

#if defined(__FreeBSD__) && defined(_KERNEL)
	mutex_exit(&spa_namespace_lock);

	kmem_free(newname, MAXPATHLEN);
	kmem_free(oldname, MAXPATHLEN);
#endif
	/*
	 * Change space accounting.
	 * Note, pa->*usedsnap and dd_used_breakdown[SNAP] will either

Lines 41-48 extern int zvol_check_volblocksize(uint6 Link Here

(-)sys/cddl/contrib/opensolaris/uts/common/fs/zfs/sys/zvol.h (-2 / +1 lines)
41	extern int zvol_get_stats(objset_t os, nvlist_t nv);	41	extern int zvol_get_stats(objset_t os, nvlist_t nv);
42	extern void zvol_create_cb(objset_t os, void arg, cred_t cr, dmu_tx_t tx);	42	extern void zvol_create_cb(objset_t os, void arg, cred_t cr, dmu_tx_t tx);
43	extern int zvol_create_minor(const char *);	43	extern int zvol_create_minor(const char *);
44	extern int zvol_remove_minor(const char *);	44	extern int zvol_remove_minors(const char *);
45	extern void zvol_remove_minors(const char *);
46	extern int zvol_set_volsize(const char *, major_t, uint64_t);	45	extern int zvol_set_volsize(const char *, major_t, uint64_t);
47		46
48	#ifdef sun	47	#ifdef sun




		error = zfs_unmount_snap(name);
		if (error != 0)
			return (error);
		(void) zvol_remove_minors(name);
	}

	return (dsl_destroy_snapshots_nvl(snaps, defer, outnvl));

	else
		err = dsl_destroy_head(zc->zc_name);
	if (zc->zc_objset_type == DMU_OST_ZVOL && err == 0)
		(void) zvol_remove_minors(zc->zc_name);
	return (err);
}


	} else {
#ifdef illumos
		if (zc->zc_objset_type == DMU_OST_ZVOL)
			(void) zvol_remove_minors(zc->zc_name);
#endif
		return (dsl_dir_rename(zc->zc_name, zc->zc_value));
	}




}

int
zvol_remove_minor(const char *name)
{
	zvol_state_t *zv;
	int rc;

	mutex_enter(&spa_namespace_lock);
	if ((zv = zvol_minor_lookup(name)) == NULL) {
		mutex_exit(&spa_namespace_lock);
		return (SET_ERROR(ENXIO));
	}
	g_topology_lock();
	rc = zvol_remove_zv(zv);
	g_topology_unlock();
	mutex_exit(&spa_namespace_lock);
	return (rc);
}

int
zvol_first_open(zvol_state_t *zv)
{
	objset_t *os;

	return (error);
}

int
zvol_remove_minors(const char *name)
{
	struct g_geom *gp, *gptmp;
	struct g_provider *pp;
	zvol_state_t *zv;
	size_t namelen;
	int rc;

	namelen = strlen(name);
	rc = ENXIO;

	DROP_GIANT();
	mutex_enter(&spa_namespace_lock);

			continue;
		if (strcmp(zv->zv_name, name) == 0 ||
		    (strncmp(zv->zv_name, name, namelen) == 0 &&
		    strlen(zv->zv_name) > namelen && (zv->zv_name[namelen] == '/' ||
		    zv->zv_name[namelen] == '@'))) {
			if ((rc = zvol_remove_zv(zv)) != 0)
				break;
		}
	}

	g_topology_unlock();
	mutex_exit(&spa_namespace_lock);
	PICKUP_GIANT();

	return (rc);
}

int

	if (dmu_objset_type(os) == DMU_OST_ZVOL) {
		dsl_dataset_long_hold(os->os_dsl_dataset, FTAG);
		dsl_pool_rele(dmu_objset_pool(os), FTAG);
		error = zvol_create_minor(name);
		if (error == 0 || error == EEXIST) {
			error = zvol_create_snapshots(os, name);
		} else {
			printf("ZFS WARNING: Unable to create ZVOL %s (error=%d).\n",
			    name, error);
		}

	size_t oldnamelen, newnamelen;
	zvol_state_t *zv;
	char *namebuf;
	boolean_t locked = B_FALSE;

	oldnamelen = strlen(oldname);
	newnamelen = strlen(newname);

	DROP_GIANT();
	if (!MUTEX_HELD(&spa_namespace_lock)) {
		mutex_enter(&spa_namespace_lock);
		locked = B_TRUE;
	}
	g_topology_lock();

	LIST_FOREACH(gp, &zfs_zvol_class.geom, geom) {

	}

	g_topology_unlock();
	if (locked)
		mutex_exit(&spa_namespace_lock);
	PICKUP_GIANT();
}

Return to bug 193803

Lines 1655-1665 static int Link Here

(-)sys/cddl/contrib/opensolaris/uts/common/fs/zfs/dsl_dataset.c (-6 / +25 lines)
1655	dsl_dataset_rename_snapshot_sync_impl(dsl_pool_t *dp,	1655	dsl_dataset_rename_snapshot_sync_impl(dsl_pool_t *dp,
1656	dsl_dataset_t hds, void arg)	1656	dsl_dataset_t hds, void arg)
1657	{	1657	{
1658	#ifdef __FreeBSD__	1658	#if defined(__FreeBSD__) && defined(_KERNEL)
1659	#ifdef _KERNEL
1660	char oldname, newname;	1659	char oldname, newname;
1661	#endif	1660	#endif
1662	#endif
1663	dsl_dataset_rename_snapshot_arg_t *ddrsa = arg;	1661	dsl_dataset_rename_snapshot_arg_t *ddrsa = arg;
1664	dsl_dataset_t *ds;	1662	dsl_dataset_t *ds;
1665	uint64_t val;	1663	uint64_t val;
Lines 1686-1693 dsl_dataset_rename_snapshot_sync_impl(ds Link Here
1686	VERIFY0(zap_add(dp->dp_meta_objset, hds->ds_phys->ds_snapnames_zapobj,	1684	VERIFY0(zap_add(dp->dp_meta_objset, hds->ds_phys->ds_snapnames_zapobj,
1687	ds->ds_snapname, 8, 1, &ds->ds_object, tx));	1685	ds->ds_snapname, 8, 1, &ds->ds_object, tx));
1688		1686
1689	#ifdef __FreeBSD__	1687	#if defined(__FreeBSD__) && defined (_KERNEL)
1690	#ifdef _KERNEL
1691	oldname = kmem_alloc(MAXPATHLEN, KM_SLEEP);	1688	oldname = kmem_alloc(MAXPATHLEN, KM_SLEEP);
1692	newname = kmem_alloc(MAXPATHLEN, KM_SLEEP);	1689	newname = kmem_alloc(MAXPATHLEN, KM_SLEEP);
1693	snprintf(oldname, MAXPATHLEN, "%s@%s", ddrsa->ddrsa_fsname,	1690	snprintf(oldname, MAXPATHLEN, "%s@%s", ddrsa->ddrsa_fsname,
Lines 1699-1705 dsl_dataset_rename_snapshot_sync_impl(ds Link Here
1699	kmem_free(newname, MAXPATHLEN);	1696	kmem_free(newname, MAXPATHLEN);
1700	kmem_free(oldname, MAXPATHLEN);	1697	kmem_free(oldname, MAXPATHLEN);
1701	#endif	1698	#endif
1702	#endif
1703	dsl_dataset_rele(ds, FTAG);	1699	dsl_dataset_rele(ds, FTAG);
1704		1700
1705	return (0);	1701	return (0);
Lines 2076-2081 dsl_dataset_promote_sync(void *arg, dmu_ Link Here
2076	dsl_dir_t *odd = NULL;	2072	dsl_dir_t *odd = NULL;
2077	uint64_t oldnext_obj;	2073	uint64_t oldnext_obj;
2078	int64_t delta;	2074	int64_t delta;
		2075	#if defined(__FreeBSD__) && defined(_KERNEL)
		2076	char oldname, newname;
		2077	#endif
2079		2078
2080	VERIFY0(promote_hold(ddpa, dp, FTAG));	2079	VERIFY0(promote_hold(ddpa, dp, FTAG));
2081	hds = ddpa->ddpa_clone;	2080	hds = ddpa->ddpa_clone;
Lines 2141-2146 dsl_dataset_promote_sync(void *arg, dmu_ Link Here
2141	dd->dd_phys->dd_clones, origin_head->ds_object, tx));	2140	dd->dd_phys->dd_clones, origin_head->ds_object, tx));
2142	}	2141	}
2143		2142
		2143	#if defined(__FreeBSD__) && defined(_KERNEL)
		2144	/* Take the spa_namespace_lock so zvol renames don't livelock */
		2145	mutex_enter(&spa_namespace_lock);
		2146
		2147	oldname = kmem_alloc(MAXPATHLEN, KM_SLEEP);
		2148	newname = kmem_alloc(MAXPATHLEN, KM_SLEEP);
		2149	#endif
		2150
2144	/* move snapshots to this dir */	2151	/* move snapshots to this dir */
2145	for (snap = list_head(&ddpa->shared_snaps); snap;	2152	for (snap = list_head(&ddpa->shared_snaps); snap;
2146	snap = list_next(&ddpa->shared_snaps, snap)) {	2153	snap = list_next(&ddpa->shared_snaps, snap)) {
Lines 2173-2178 dsl_dataset_promote_sync(void *arg, dmu_ Link Here
2173	VERIFY0(dsl_dir_hold_obj(dp, dd->dd_object,	2180	VERIFY0(dsl_dir_hold_obj(dp, dd->dd_object,
2174	NULL, ds, &ds->ds_dir));	2181	NULL, ds, &ds->ds_dir));
2175		2182
		2183	#if defined(__FreeBSD__) && defined(_KERNEL)
		2184	dsl_dataset_name(ds, newname);
		2185	zfsvfs_update_fromname(oldname, newname);
		2186	zvol_rename_minors(oldname, newname);
		2187	#endif
		2188
2176	/* move any clone references */	2189	/* move any clone references */
2177	if (ds->ds_phys->ds_next_clones_obj &&	2190	if (ds->ds_phys->ds_next_clones_obj &&
2178	spa_version(dp->dp_spa) >= SPA_VERSION_DIR_CLONES) {	2191	spa_version(dp->dp_spa) >= SPA_VERSION_DIR_CLONES) {
Lines 2210-2215 dsl_dataset_promote_sync(void *arg, dmu_ Link Here
2210	ASSERT(!dsl_prop_hascb(ds));	2223	ASSERT(!dsl_prop_hascb(ds));
2211	}	2224	}
2212		2225
		2226	#if defined(__FreeBSD__) && defined(_KERNEL)
		2227	mutex_exit(&spa_namespace_lock);
		2228
		2229	kmem_free(newname, MAXPATHLEN);
		2230	kmem_free(oldname, MAXPATHLEN);
		2231	#endif
2213	/*	2232	/*
2214	* Change space accounting.	2233	* Change space accounting.
2215	* Note, pa->*usedsnap and dd_used_breakdown[SNAP] will either	2234	* Note, pa->*usedsnap and dd_used_breakdown[SNAP] will either

Lines 3517-3523 zfs_ioc_destroy_snaps(const char *poolna Link Here

(-)sys/cddl/contrib/opensolaris/uts/common/fs/zfs/zfs_ioctl.c (-3 / +3 lines)
3517	error = zfs_unmount_snap(name);	3517	error = zfs_unmount_snap(name);
3518	if (error != 0)	3518	if (error != 0)
3519	return (error);	3519	return (error);
3520	(void) zvol_remove_minor(name);	3520	(void) zvol_remove_minors(name);
3521	}	3521	}
3522		3522
3523	return (dsl_destroy_snapshots_nvl(snaps, defer, outnvl));	3523	return (dsl_destroy_snapshots_nvl(snaps, defer, outnvl));
Lines 3547-3553 zfs_ioc_destroy(zfs_cmd_t *zc) Link Here
3547	else	3547	else
3548	err = dsl_destroy_head(zc->zc_name);	3548	err = dsl_destroy_head(zc->zc_name);
3549	if (zc->zc_objset_type == DMU_OST_ZVOL && err == 0)	3549	if (zc->zc_objset_type == DMU_OST_ZVOL && err == 0)
3550	(void) zvol_remove_minor(zc->zc_name);	3550	(void) zvol_remove_minors(zc->zc_name);
3551	return (err);	3551	return (err);
3552	}	3552	}
3553		3553
Lines 3643-3649 zfs_ioc_rename(zfs_cmd_t *zc) Link Here
3643	} else {	3643	} else {
3644	#ifdef illumos	3644	#ifdef illumos
3645	if (zc->zc_objset_type == DMU_OST_ZVOL)	3645	if (zc->zc_objset_type == DMU_OST_ZVOL)
3646	(void) zvol_remove_minor(zc->zc_name);	3646	(void) zvol_remove_minors(zc->zc_name);
3647	#endif	3647	#endif
3648	return (dsl_dir_rename(zc->zc_name, zc->zc_value));	3648	return (dsl_dir_rename(zc->zc_name, zc->zc_value));
3649	}	3649	}

Lines 630-653 zvol_remove_zv(zvol_state_t *zv) Link Here

(-)sys/cddl/contrib/opensolaris/uts/common/fs/zfs/zvol.c (-25 / +19 lines)
630	}	630	}
631		631
632	int	632	int
633	zvol_remove_minor(const char *name)
634	{
635	zvol_state_t *zv;
636	int rc;
637
638	mutex_enter(&spa_namespace_lock);
639	if ((zv = zvol_minor_lookup(name)) == NULL) {
640	mutex_exit(&spa_namespace_lock);
641	return (SET_ERROR(ENXIO));
642	}
643	g_topology_lock();
644	rc = zvol_remove_zv(zv);
645	g_topology_unlock();
646	mutex_exit(&spa_namespace_lock);
647	return (rc);
648	}
649
650	int
651	zvol_first_open(zvol_state_t *zv)	633	zvol_first_open(zvol_state_t *zv)
652	{	634	{
653	objset_t *os;	635	objset_t *os;
Lines 775-789 zvol_update_volsize(objset_t *os, uint64 Link Here
775	return (error);	757	return (error);
776	}	758	}
777		759
778	void	760	int
779	zvol_remove_minors(const char *name)	761	zvol_remove_minors(const char *name)
780	{	762	{
781	struct g_geom gp, gptmp;	763	struct g_geom gp, gptmp;
782	struct g_provider *pp;	764	struct g_provider *pp;
783	zvol_state_t *zv;	765	zvol_state_t *zv;
784	size_t namelen;	766	size_t namelen;
		767	int rc;
785		768
786	namelen = strlen(name);	769	namelen = strlen(name);
		770	rc = ENXIO;
787		771
788	DROP_GIANT();	772	DROP_GIANT();
789	mutex_enter(&spa_namespace_lock);	773	mutex_enter(&spa_namespace_lock);
Lines 798-811 zvol_remove_minors(const char *name) Link Here
798	continue;	782	continue;
799	if (strcmp(zv->zv_name, name) == 0 \|\|	783	if (strcmp(zv->zv_name, name) == 0 \|\|
800	(strncmp(zv->zv_name, name, namelen) == 0 &&	784	(strncmp(zv->zv_name, name, namelen) == 0 &&
801	zv->zv_name[namelen] == '/')) {	785	strlen(zv->zv_name) > namelen && (zv->zv_name[namelen] == '/' \|\|
802	(void) zvol_remove_zv(zv);	786	zv->zv_name[namelen] == '@'))) {
		787	if ((rc = zvol_remove_zv(zv)) != 0)
		788	break;
803	}	789	}
804	}	790	}
805		791
806	g_topology_unlock();	792	g_topology_unlock();
807	mutex_exit(&spa_namespace_lock);	793	mutex_exit(&spa_namespace_lock);
808	PICKUP_GIANT();	794	PICKUP_GIANT();
		795
		796	return (rc);
809	}	797	}
810		798
811	int	799	int
Lines 2393-2401 zvol_create_minors(const char *name) Link Here
2393	if (dmu_objset_type(os) == DMU_OST_ZVOL) {	2381	if (dmu_objset_type(os) == DMU_OST_ZVOL) {
2394	dsl_dataset_long_hold(os->os_dsl_dataset, FTAG);	2382	dsl_dataset_long_hold(os->os_dsl_dataset, FTAG);
2395	dsl_pool_rele(dmu_objset_pool(os), FTAG);	2383	dsl_pool_rele(dmu_objset_pool(os), FTAG);
2396	if ((error = zvol_create_minor(name)) == 0)	2384	error = zvol_create_minor(name);
		2385	if (error == 0 \|\| error == EEXIST) {
2397	error = zvol_create_snapshots(os, name);	2386	error = zvol_create_snapshots(os, name);
2398	else {	2387	} else {
2399	printf("ZFS WARNING: Unable to create ZVOL %s (error=%d).\n",	2388	printf("ZFS WARNING: Unable to create ZVOL %s (error=%d).\n",
2400	name, error);	2389	name, error);
2401	}	2390	}
Lines 2479-2490 zvol_rename_minors(const char *oldname, Link Here
2479	size_t oldnamelen, newnamelen;	2468	size_t oldnamelen, newnamelen;
2480	zvol_state_t *zv;	2469	zvol_state_t *zv;
2481	char *namebuf;	2470	char *namebuf;
		2471	boolean_t locked = B_FALSE;
2482		2472
2483	oldnamelen = strlen(oldname);	2473	oldnamelen = strlen(oldname);
2484	newnamelen = strlen(newname);	2474	newnamelen = strlen(newname);
2485		2475
2486	DROP_GIANT();	2476	DROP_GIANT();
2487	mutex_enter(&spa_namespace_lock);	2477	if (!MUTEX_HELD(&spa_namespace_lock)) {
		2478	mutex_enter(&spa_namespace_lock);
		2479	locked = B_TRUE;
		2480	}
2488	g_topology_lock();	2481	g_topology_lock();
2489		2482
2490	LIST_FOREACH(gp, &zfs_zvol_class.geom, geom) {	2483	LIST_FOREACH(gp, &zfs_zvol_class.geom, geom) {
Lines 2507-2512 zvol_rename_minors(const char *oldname, Link Here
2507	}	2500	}
2508		2501
2509	g_topology_unlock();	2502	g_topology_unlock();
2510	mutex_exit(&spa_namespace_lock);	2503	if (locked)
		2504	mutex_exit(&spa_namespace_lock);
2511	PICKUP_GIANT();	2505	PICKUP_GIANT();
2512	}	2506	}