c/mirror_zfs
1
0
Fork 0
mirror of https://git.proxmox.com/git/mirror_zfs.git synced 2024-12-25 10:49:34 +03:00
Code Issues Packages Projects Releases Wiki Activity

Support for longnames for files/directories (Linux part)

Browse Source 
This patch adds the ability for zfs to support file/dir name up to 1023
bytes. This number is chosen so we can support up to 255 4-byte
characters. This new feature is represented by the new feature flag
feature@longname.

A new dataset property "longname" is also introduced to toggle longname
support for each dataset individually. This property can be disabled,
even if it contains longname files. In such case, new file cannot be
created with longname but existing longname files can still be looked
up.

Note that, to my knowledge native Linux filesystems don't support name
longer than 255 bytes. So there might be programs not able to work with
longname.

Note that NFS server may needs to use exportfs_get_name to reconnect
dentries, and the buffer being passed is limit to NAME_MAX+1 (256). So
NFS may not work when longname is enabled.

Note, FreeBSD vfs layer imposes a limit of 255 name lengh, so even
though we add code to support it here, it won't actually work.

Reviewed-by: Tony Hutter <hutter2@llnl.gov>
Reviewed-by: Brian Behlendorf <behlendorf1@llnl.gov>
Reviewed-by: Alexander Motin <mav@FreeBSD.org>
Signed-off-by: Chunwei Chen <david.chen@nutanix.com>
Closes #15921
This commit is contained in:
Sanjeev Bagewadi 2021-06-18 08:55:01 +00:00 committed by Brian Behlendorf
parent 3cf2bfa570
commit 20232ecfaa
41 changed files with 1239 additions and 406 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
cmd/zdb/zdb.c
View File

@ -1117,7 +1117,7 @@ dump_zap(objset_t *os, uint64_t object, void *data, size_t size)
{
(void) data, (void) size;
zap_cursor_t zc;
zap_attribute_t *attrp = zap_attribute_alloc();
zap_attribute_t *attrp = zap_attribute_long_alloc();
void *prop;
unsigned i;
@ -1365,7 +1365,7 @@ dump_zpldir(objset_t *os, uint64_t object, void *data, size_t size)
{
(void) data, (void) size;
zap_cursor_t zc;
zap_attribute_t *attrp = zap_attribute_alloc();
zap_attribute_t *attrp = zap_attribute_long_alloc();
const char *typenames[] = {
/* 0 */ "not specified",
/* 1 */ "FIFO",

2
cmd/zhack.c
View File

@ -203,7 +203,7 @@ static void
dump_obj(objset_t *os, uint64_t obj, const char *name)
{
zap_cursor_t zc;
zap_attribute_t *za = zap_attribute_alloc();
zap_attribute_t *za = zap_attribute_long_alloc();
(void) printf("%s_obj:\n", name);

1
include/os/freebsd/zfs/sys/zfs_vfsops_os.h
View File

@ -83,6 +83,7 @@ struct zfsvfs {
boolean_t z_use_sa; /* version allow system attributes */
boolean_t z_xattr_sa; /* allow xattrs to be stores as SA */
boolean_t z_use_namecache; /* make use of FreeBSD name cache */
boolean_t z_longname; /* Dataset supports long names */
uint8_t z_xattr; /* xattr type in use */
uint64_t z_version; /* ZPL version */
uint64_t z_shares_dir; /* hidden shares dir */

2
include/os/freebsd/zfs/sys/zfs_znode_impl.h
View File

@ -179,7 +179,7 @@ extern void zfs_znode_free(struct znode *);
extern zil_replay_func_t *const zfs_replay_vector[TX_MAX_TYPE];
extern int zfs_znode_parent_and_name(struct znode *zp, struct znode **dzpp,
char *buf);
char *buf, uint64_t buflen);
extern int zfs_rlimit_fsize(off_t fsize);
#ifdef __cplusplus

1
include/os/linux/zfs/sys/zfs_vfsops_os.h
View File

@ -118,6 +118,7 @@ struct zfsvfs {
boolean_t z_xattr_sa; /* allow xattrs to be stores as SA */
boolean_t z_draining; /* is true when drain is active */
boolean_t z_drain_cancel; /* signal the unlinked drain to stop */
boolean_t z_longname; /* Dataset supports long names */
uint64_t z_version; /* ZPL version */
uint64_t z_shares_dir; /* hidden shares dir */
dataset_kstats_t z_kstat; /* fs kstats */

1
include/os/linux/zfs/sys/zfs_vnops_os.h
View File

@ -44,6 +44,7 @@ extern int zfs_write_simple(znode_t *zp, const void *data, size_t len,
loff_t pos, size_t *resid);
extern int zfs_lookup(znode_t *dzp, char *nm, znode_t **zpp, int flags,
cred_t *cr, int *direntflags, pathname_t *realpnp);
extern int zfs_get_name(znode_t *dzp, char *name, znode_t *zp);
extern int zfs_create(znode_t *dzp, char *name, vattr_t *vap, int excl,
int mode, znode_t **zpp, cred_t *cr, int flag, vsecattr_t *vsecp,
zidmap_t *mnt_ns);

2
include/sys/fs/zfs.h
View File

@ -81,6 +81,7 @@ typedef enum dmu_objset_type {
* All of these include the terminating NUL byte.
*/
#define ZAP_MAXNAMELEN 256
#define ZAP_MAXNAMELEN_NEW 1024
#define ZAP_MAXVALUELEN (1024 * 8)
#define ZAP_OLDMAXVALUELEN 1024
#define ZFS_MAX_DATASET_NAME_LEN 256
@ -194,6 +195,7 @@ typedef enum {
ZFS_PROP_PREFETCH,
ZFS_PROP_VOLTHREADING,
ZFS_PROP_DIRECT,
ZFS_PROP_LONGNAME,
ZFS_NUM_PROPS
} zfs_prop_t;

3
include/sys/zap.h
View File

@ -315,7 +315,7 @@ int zap_count(objset_t *ds, uint64_t zapobj, uint64_t *count);
* match must be exact (ie, same as mask=-1ULL).
*/
int zap_value_search(objset_t *os, uint64_t zapobj,
uint64_t value, uint64_t mask, char *name);
uint64_t value, uint64_t mask, char *name, uint64_t namelen);
/*
* Transfer all the entries from fromobj into intoobj. Only works on
@ -387,6 +387,7 @@ void zap_fini(void);
* Alloc and free zap_attribute_t.
*/
zap_attribute_t *zap_attribute_alloc(void);
zap_attribute_t *zap_attribute_long_alloc(void);
void zap_attribute_free(zap_attribute_t *attrp);
/*

4
include/sys/zfs_ioctl.h
View File

@ -143,7 +143,7 @@ typedef enum drr_headertype {
* default use of "zfs send" won't encounter the bug mentioned above.
*/
#define DMU_BACKUP_FEATURE_SWITCH_TO_LARGE_BLOCKS (1 << 27)
/* flag #28 is reserved for a Nutanix feature */
#define DMU_BACKUP_FEATURE_LONGNAME (1 << 28)
/*
* Mask of all supported backup features
@ -154,7 +154,7 @@ typedef enum drr_headertype {
DMU_BACKUP_FEATURE_COMPRESSED | DMU_BACKUP_FEATURE_LARGE_DNODE | \
DMU_BACKUP_FEATURE_RAW | DMU_BACKUP_FEATURE_HOLDS | \
DMU_BACKUP_FEATURE_REDACTED | DMU_BACKUP_FEATURE_SWITCH_TO_LARGE_BLOCKS | \
DMU_BACKUP_FEATURE_ZSTD)
DMU_BACKUP_FEATURE_ZSTD | DMU_BACKUP_FEATURE_LONGNAME)
/* Are all features in the given flag word currently supported? */
#define DMU_STREAM_SUPPORTED(x) (!((x) & ~DMU_BACKUP_FEATURE_MASK))

1
include/zfeature_common.h
View File

@ -83,6 +83,7 @@ typedef enum spa_feature {
SPA_FEATURE_REDACTION_LIST_SPILL,
SPA_FEATURE_RAIDZ_EXPANSION,
SPA_FEATURE_FAST_DEDUP,
SPA_FEATURE_LONGNAME,
SPA_FEATURES
} spa_feature_t;

651
lib/libzfs/libzfs.abi
View File

File diff suppressed because it is too large Load Diff

17
man/man7/zpool-features.7
View File

@ -723,6 +723,23 @@ instead of scattering multiple writes to all the metaslab spacemaps.
.Pp
\*[instant-never]
.
.feature org.zfsonlinux longname no extensible_dataset
This feature allows creating files and directories with name up to 1023 bytes
in length.
A new dataset property
.Sy longname
is also introduced to toggle longname support for each dataset individually.
This property can be disabled even if it contains longname files.
In such case, new file cannot be created with longname but existing longname
files can still be looked up.
.Pp
This feature becomes
.Sy active
when a file name greater than 255 is created in a dataset, and returns to
being
.Sy enabled
when all such datasets are destroyed.
.
.feature org.illumos lz4_compress no
.Sy lz4
is a high-performance real-time compression algorithm that

9
module/os/freebsd/zfs/zfs_dir.c
View File

@ -627,6 +627,15 @@ zfs_link_create(znode_t *dzp, const char *name, znode_t *zp, dmu_tx_t *tx,
return (error);
}
/*
* If we added a longname activate the SPA_FEATURE_LONGNAME.
*/
if (strlen(name) >= ZAP_MAXNAMELEN) {
dsl_dataset_t *ds = dmu_objset_ds(zfsvfs->z_os);
ds->ds_feature_activation[SPA_FEATURE_LONGNAME] =
(void *)B_TRUE;
}
SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_PARENT(zfsvfs), NULL,
&dzp->z_id, sizeof (dzp->z_id));
SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_FLAGS(zfsvfs), NULL,

13
module/os/freebsd/zfs/zfs_vfsops.c
View File

@ -614,6 +614,14 @@ acl_type_changed_cb(void *arg, uint64_t newval)
zfsvfs->z_acl_type = newval;
}
static void
longname_changed_cb(void *arg, uint64_t newval)
{
zfsvfs_t *zfsvfs = arg;
zfsvfs->z_longname = newval;
}
static int
zfs_register_callbacks(vfs_t *vfsp)
{
@ -751,6 +759,8 @@ zfs_register_callbacks(vfs_t *vfsp)
error = error ? error : dsl_prop_register(ds,
zfs_prop_to_name(ZFS_PROP_ACLINHERIT), acl_inherit_changed_cb,
zfsvfs);
error = error ? error : dsl_prop_register(ds,
zfs_prop_to_name(ZFS_PROP_LONGNAME), longname_changed_cb, zfsvfs);
dsl_pool_config_exit(dmu_objset_pool(os), FTAG);
if (error)
goto unregister;
@ -1489,7 +1499,8 @@ zfs_statfs(vfs_t *vfsp, struct statfs *statp)
strlcpy(statp->f_mntonname, vfsp->mnt_stat.f_mntonname,
sizeof (statp->f_mntonname));
statp->f_namemax = MAXNAMELEN - 1;
statp->f_namemax =
zfsvfs->z_longname ? (ZAP_MAXNAMELEN_NEW - 1) : (MAXNAMELEN - 1);
zfs_exit(zfsvfs, FTAG);
return (0);

28
module/os/freebsd/zfs/zfs_vnops_os.c
View File

@ -892,6 +892,14 @@ zfs_lookup(vnode_t *dvp, const char *nm, vnode_t **vpp,
return (error);
}
static inline bool
is_nametoolong(zfsvfs_t *zfsvfs, const char *name)
{
size_t dlen = strlen(name);
return ((!zfsvfs->z_longname && dlen >= ZAP_MAXNAMELEN) ||
dlen >= ZAP_MAXNAMELEN_NEW);
}
/*
* Attempt to create a new entry in a directory. If the entry
* already exists, truncate the file if permissible, else return
@ -937,6 +945,9 @@ zfs_create(znode_t *dzp, const char *name, vattr_t *vap, int excl, int mode,
vnode_t *dvp = ZTOV(dzp);
#endif
if (is_nametoolong(zfsvfs, name))
return (SET_ERROR(ENAMETOOLONG));
/*
* If we have an ephemeral id, ACL, or XVATTR then
* make sure file system is at proper version
@ -1301,6 +1312,9 @@ zfs_mkdir(znode_t *dzp, const char *dirname, vattr_t *vap, znode_t **zpp,
ASSERT3U(vap->va_type, ==, VDIR);
if (is_nametoolong(zfsvfs, dirname))
return (SET_ERROR(ENAMETOOLONG));
/*
* If we have an ephemeral id, ACL, or XVATTR then
* make sure file system is at proper version
@ -1616,7 +1630,7 @@ zfs_readdir(vnode_t *vp, zfs_uio_t *uio, cred_t *cr, int *eofp,
os = zfsvfs->z_os;
offset = zfs_uio_offset(uio);
prefetch = zp->z_zn_prefetch;
zap = zap_attribute_alloc();
zap = zap_attribute_long_alloc();
/*
* Initialize the iterator cursor.
@ -3294,6 +3308,9 @@ zfs_rename(znode_t *sdzp, const char *sname, znode_t *tdzp, const char *tname,
int error;
svp = tvp = NULL;
if (is_nametoolong(tdzp->z_zfsvfs, tname))
return (SET_ERROR(ENAMETOOLONG));
if (rflags != 0 || wo_vap != NULL)
return (SET_ERROR(EINVAL));
@ -3358,6 +3375,9 @@ zfs_symlink(znode_t *dzp, const char *name, vattr_t *vap,
ASSERT3S(vap->va_type, ==, VLNK);
if (is_nametoolong(zfsvfs, name))
return (SET_ERROR(ENAMETOOLONG));
if ((error = zfs_enter_verify_zp(zfsvfs, dzp, FTAG)) != 0)
return (error);
zilog = zfsvfs->z_log;
@ -3540,6 +3560,9 @@ zfs_link(znode_t *tdzp, znode_t *szp, const char *name, cred_t *cr,
ASSERT3S(ZTOV(tdzp)->v_type, ==, VDIR);
if (is_nametoolong(zfsvfs, name))
return (SET_ERROR(ENAMETOOLONG));
if ((error = zfs_enter_verify_zp(zfsvfs, tdzp, FTAG)) != 0)
return (error);
zilog = zfsvfs->z_log;
@ -5996,7 +6019,8 @@ zfs_vptocnp(struct vop_vptocnp_args *ap)
znode_t *dzp;
size_t len;
error = zfs_znode_parent_and_name(zp, &dzp, name);
error = zfs_znode_parent_and_name(zp, &dzp, name,
sizeof (name));
if (error == 0) {
len = strlen(name);
if (*ap->a_buflen < len)

5
module/os/freebsd/zfs/zfs_znode_os.c
View File

@ -1792,7 +1792,8 @@ zfs_znode_update_vfs(znode_t *zp)
}
int
zfs_znode_parent_and_name(znode_t *zp, znode_t **dzpp, char *buf)
zfs_znode_parent_and_name(znode_t *zp, znode_t **dzpp, char *buf,
uint64_t buflen)
{
zfsvfs_t *zfsvfs = zp->z_zfsvfs;
uint64_t parent;
@ -1814,7 +1815,7 @@ zfs_znode_parent_and_name(znode_t *zp, znode_t **dzpp, char *buf)
return (SET_ERROR(EINVAL));
err = zap_value_search(zfsvfs->z_os, parent, zp->z_id,
ZFS_DIRENT_OBJ(-1ULL), buf);
ZFS_DIRENT_OBJ(-1ULL), buf, buflen);
if (err != 0)
return (err);
err = zfs_zget(zfsvfs, parent, dzpp);

9
module/os/linux/zfs/zfs_dir.c
View File

@ -847,6 +847,15 @@ zfs_link_create(zfs_dirlock_t *dl, znode_t *zp, dmu_tx_t *tx, int flag)
return (error);
}
/*
* If we added a longname activate the SPA_FEATURE_LONGNAME.
*/
if (strlen(dl->dl_name) >= ZAP_MAXNAMELEN) {
dsl_dataset_t *ds = dmu_objset_ds(zfsvfs->z_os);
ds->ds_feature_activation[SPA_FEATURE_LONGNAME] =
(void *)B_TRUE;
}
SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_PARENT(zfsvfs), NULL,
&dzp->z_id, sizeof (dzp->z_id));
SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_FLAGS(zfsvfs), NULL,

12
module/os/linux/zfs/zfs_vfsops.c
View File

@ -57,6 +57,7 @@
#include <sys/dmu_objset.h>
#include <sys/dsl_dir.h>
#include <sys/objlist.h>
#include <sys/zfeature.h>
#include <sys/zpl.h>
#include <linux/vfs_compat.h>
#include <linux/fs.h>
@ -449,6 +450,12 @@ acl_inherit_changed_cb(void *arg, uint64_t newval)
((zfsvfs_t *)arg)->z_acl_inherit = newval;
}
static void
longname_changed_cb(void *arg, uint64_t newval)
{
((zfsvfs_t *)arg)->z_longname = newval;
}
static int
zfs_register_callbacks(vfs_t *vfsp)
{
@ -509,6 +516,8 @@ zfs_register_callbacks(vfs_t *vfsp)
zfsvfs);
error = error ? error : dsl_prop_register(ds,
zfs_prop_to_name(ZFS_PROP_NBMAND), nbmand_changed_cb, zfsvfs);
error = error ? error : dsl_prop_register(ds,
zfs_prop_to_name(ZFS_PROP_LONGNAME), longname_changed_cb, zfsvfs);
dsl_pool_config_exit(dmu_objset_pool(os), FTAG);
if (error)
goto unregister;
@ -1140,7 +1149,8 @@ zfs_statvfs(struct inode *ip, struct kstatfs *statp)
statp->f_fsid.val[0] = (uint32_t)fsid;
statp->f_fsid.val[1] = (uint32_t)(fsid >> 32);
statp->f_type = ZFS_SUPER_MAGIC;
statp->f_namelen = MAXNAMELEN - 1;
statp->f_namelen =
zfsvfs->z_longname ? (ZAP_MAXNAMELEN_NEW - 1) : (MAXNAMELEN - 1);
/*
* We have all of 40 characters to stuff a string here.

42
module/os/linux/zfs/zfs_vnops_os.c
View File

@ -542,6 +542,46 @@ zfs_lookup(znode_t *zdp, char *nm, znode_t **zpp, int flags, cred_t *cr,
return (error);
}
/*
* Perform a linear search in directory for the name of specific inode.
* Note we don't pass in the buffer size of name because it's hardcoded to
* NAME_MAX+1(256) in Linux.
*
* IN: dzp - znode of directory to search.
* zp - znode of the target
*
* OUT: name - dentry name of the target
*
* RETURN: 0 on success, error code on failure.
*/
int
zfs_get_name(znode_t *dzp, char *name, znode_t *zp)
{
zfsvfs_t *zfsvfs = ZTOZSB(dzp);
int error = 0;
if ((error = zfs_enter_verify_zp(zfsvfs, dzp, FTAG)) != 0)
return (error);
if ((error = zfs_verify_zp(zp)) != 0) {
zfs_exit(zfsvfs, FTAG);
return (error);
}
/* ctldir should have got their name in zfs_vget */
if (dzp->z_is_ctldir || zp->z_is_ctldir) {
zfs_exit(zfsvfs, FTAG);
return (ENOENT);
}
/* buffer len is hardcoded to 256 in Linux kernel */
error = zap_value_search(zfsvfs->z_os, dzp->z_id, zp->z_id,
ZFS_DIRENT_OBJ(-1ULL), name, ZAP_MAXNAMELEN);
zfs_exit(zfsvfs, FTAG);
return (error);
}
/*
* Attempt to create a new entry in a directory. If the entry
* already exists, truncate the file if permissible, else return
@ -1548,7 +1588,7 @@ zfs_readdir(struct inode *ip, struct dir_context *ctx, cred_t *cr)
os = zfsvfs->z_os;
offset = ctx->pos;
prefetch = zp->z_zn_prefetch;
zap = zap_attribute_alloc();
zap = zap_attribute_long_alloc();
/*
* Initialize the iterator cursor.

31
module/os/linux/zfs/zpl_export.c
View File

@ -24,6 +24,7 @@
*/
#include <sys/file.h>
#include <sys/zfs_znode.h>
#include <sys/zfs_vnops.h>
#include <sys/zfs_ctldir.h>
@ -102,6 +103,35 @@ zpl_fh_to_dentry(struct super_block *sb, struct fid *fh,
return (d_obtain_alias(ip));
}
/*
* In case the filesystem contains name longer than 255, we need to override
* the default get_name so we don't get buffer overflow. Unfortunately, since
* the buffer size is hardcoded in Linux, we will get ESTALE error in this
* case.
*/
static int
zpl_get_name(struct dentry *parent, char *name, struct dentry *child)
{
cred_t *cr = CRED();
fstrans_cookie_t cookie;
struct inode *dir = parent->d_inode;
struct inode *ip = child->d_inode;
int error;
if (!dir || !S_ISDIR(dir->i_mode))
return (-ENOTDIR);
crhold(cr);
cookie = spl_fstrans_mark();
spl_inode_lock_shared(dir);
error = -zfs_get_name(ITOZ(dir), name, ITOZ(ip));
spl_inode_unlock_shared(dir);
spl_fstrans_unmark(cookie);
crfree(cr);
return (error);
}
static struct dentry *
zpl_get_parent(struct dentry *child)
{
@ -146,6 +176,7 @@ zpl_commit_metadata(struct inode *inode)
const struct export_operations zpl_export_operations = {
.encode_fh = zpl_encode_fh,
.fh_to_dentry = zpl_fh_to_dentry,
.get_name = zpl_get_name,
.get_parent = zpl_get_parent,
.commit_metadata = zpl_commit_metadata,
};

56
module/os/linux/zfs/zpl_inode.c
View File

@ -46,9 +46,29 @@ zpl_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
pathname_t pn;
int zfs_flags = 0;
zfsvfs_t *zfsvfs = dentry->d_sb->s_fs_info;
dsl_dataset_t *ds = dmu_objset_ds(zfsvfs->z_os);
size_t dlen = dlen(dentry);
if (dlen(dentry) >= ZAP_MAXNAMELEN)
/*
* If z_longname is disabled, disallow create or rename of names
* longer than ZAP_MAXNAMELEN.
*
* This is needed in cases where longname was enabled first and some
* files/dirs with names > ZAP_MAXNAMELEN were created. And later
* longname was disabled. In such a case allow access to existing
* longnames. But disallow creation newer longnamed entities.
*/
if (!zfsvfs->z_longname && (dlen >= ZAP_MAXNAMELEN)) {
/*
* If this is for create or rename fail it.
*/
if (!dsl_dataset_feature_is_active(ds, SPA_FEATURE_LONGNAME) ||
(flags & (LOOKUP_CREATE | LOOKUP_RENAME_TARGET)))
return (ERR_PTR(-ENAMETOOLONG));
}
if (dlen >= ZAP_MAXNAMELEN_NEW) {
return (ERR_PTR(-ENAMETOOLONG));
}
crhold(cr);
cookie = spl_fstrans_mark();
@ -131,6 +151,16 @@ zpl_vap_init(vattr_t *vap, struct inode *dir, umode_t mode, cred_t *cr,
}
}
static inline bool
is_nametoolong(struct dentry *dentry)
{
zfsvfs_t *zfsvfs = dentry->d_sb->s_fs_info;
size_t dlen = dlen(dentry);
return ((!zfsvfs->z_longname && dlen >= ZAP_MAXNAMELEN) ||
dlen >= ZAP_MAXNAMELEN_NEW);
}
static int
#ifdef HAVE_IOPS_CREATE_USERNS
zpl_create(struct user_namespace *user_ns, struct inode *dir,
@ -151,6 +181,10 @@ zpl_create(struct inode *dir, struct dentry *dentry, umode_t mode, bool flag)
zidmap_t *user_ns = kcred->user_ns;
#endif
if (is_nametoolong(dentry)) {
return (-ENAMETOOLONG);
}
crhold(cr);
vap = kmem_zalloc(sizeof (vattr_t), KM_SLEEP);
zpl_vap_init(vap, dir, mode, cr, user_ns);
@ -201,6 +235,10 @@ zpl_mknod(struct inode *dir, struct dentry *dentry, umode_t mode,
zidmap_t *user_ns = kcred->user_ns;
#endif
if (is_nametoolong(dentry)) {
return (-ENAMETOOLONG);
}
/*
* We currently expect Linux to supply rdev=0 for all sockets
* and fifos, but we want to know if this behavior ever changes.
@ -353,6 +391,10 @@ zpl_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
zidmap_t *user_ns = kcred->user_ns;
#endif
if (is_nametoolong(dentry)) {
return (-ENAMETOOLONG);
}
crhold(cr);
vap = kmem_zalloc(sizeof (vattr_t), KM_SLEEP);
zpl_vap_init(vap, dir, mode | S_IFDIR, cr, user_ns);
@ -568,6 +610,10 @@ zpl_rename2(struct inode *sdip, struct dentry *sdentry,
zidmap_t *user_ns = kcred->user_ns;
#endif
if (is_nametoolong(tdentry)) {
return (-ENAMETOOLONG);
}
crhold(cr);
if (rflags & RENAME_WHITEOUT) {
wo_vap = kmem_zalloc(sizeof (vattr_t), KM_SLEEP);
@ -618,6 +664,10 @@ zpl_symlink(struct inode *dir, struct dentry *dentry, const char *name)
zidmap_t *user_ns = kcred->user_ns;
#endif
if (is_nametoolong(dentry)) {
return (-ENAMETOOLONG);
}
crhold(cr);
vap = kmem_zalloc(sizeof (vattr_t), KM_SLEEP);
zpl_vap_init(vap, dir, S_IFLNK | S_IRWXUGO, cr, user_ns);
@ -707,6 +757,10 @@ zpl_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry)
int error;
fstrans_cookie_t cookie;
if (is_nametoolong(dentry)) {
return (-ENAMETOOLONG);
}
if (ip->i_nlink >= ZFS_LINK_MAX)
return (-EMLINK);

12
module/zcommon/zfeature_common.c
View File

@ -760,6 +760,18 @@ zpool_feature_init(void)
ZFEATURE_FLAG_READONLY_COMPAT, ZFEATURE_TYPE_BOOLEAN, NULL,
sfeatures);
{
static const spa_feature_t longname_deps[] = {
SPA_FEATURE_EXTENSIBLE_DATASET,
SPA_FEATURE_NONE
};
zfeature_register(SPA_FEATURE_LONGNAME,
"org.zfsonlinux:longname", "longname",
"support filename up to 1024 bytes",
ZFEATURE_FLAG_PER_DATASET, ZFEATURE_TYPE_BOOLEAN,
longname_deps, sfeatures);
}
zfs_mod_list_supported_free(sfeatures);
}

4
module/zcommon/zfs_prop.c
View File

@ -772,6 +772,10 @@ zfs_prop_init(void)
ZFS_TYPE_VOLUME, "<date>", "SNAPSHOTS_CHANGED", B_FALSE, B_TRUE,
B_TRUE, NULL, sfeatures);
zprop_register_index(ZFS_PROP_LONGNAME, "longname", 0, PROP_INHERIT,
ZFS_TYPE_FILESYSTEM, "on | off", "LONGNAME", boolean_table,
sfeatures);
zfs_mod_list_supported_free(sfeatures);
}

17
module/zfs/dmu_recv.c
View File

@ -602,6 +602,13 @@ recv_begin_check_feature_flags_impl(uint64_t featureflags, spa_t *spa)
!spa_feature_is_enabled(spa, SPA_FEATURE_REDACTED_DATASETS))
return (SET_ERROR(ENOTSUP));
/*
* If the LONGNAME is not enabled on the target, fail that request.
*/
if ((featureflags & DMU_BACKUP_FEATURE_LONGNAME) &&
!spa_feature_is_enabled(spa, SPA_FEATURE_LONGNAME))
return (SET_ERROR(ENOTSUP));
return (0);
}
@ -990,6 +997,16 @@ dmu_recv_begin_sync(void *arg, dmu_tx_t *tx)
dmu_buf_will_dirty(newds->ds_dbuf, tx);
dsl_dataset_phys(newds)->ds_flags |= DS_FLAG_INCONSISTENT;
/*
* Activate longname feature if received
*/
if (featureflags & DMU_BACKUP_FEATURE_LONGNAME &&
!dsl_dataset_feature_is_active(newds, SPA_FEATURE_LONGNAME)) {
dsl_dataset_activate_feature(newds->ds_object,
SPA_FEATURE_LONGNAME, (void *)B_TRUE, tx);
newds->ds_feature[SPA_FEATURE_LONGNAME] = (void *)B_TRUE;
}
/*
* If we actually created a non-clone, we need to create the objset
* in our new dataset. If this is a raw send we postpone this until

4
module/zfs/dmu_send.c
View File

@ -2011,6 +2011,10 @@ setup_featureflags(struct dmu_send_params *dspp, objset_t *os,
if (dsl_dataset_feature_is_active(to_ds, SPA_FEATURE_LARGE_DNODE)) {
*featureflags |= DMU_BACKUP_FEATURE_LARGE_DNODE;
}
if (dsl_dataset_feature_is_active(to_ds, SPA_FEATURE_LONGNAME)) {
*featureflags |= DMU_BACKUP_FEATURE_LONGNAME;
}
return (0);
}

3
module/zfs/dsl_dataset.c
View File

@ -494,7 +494,8 @@ dsl_dataset_get_snapname(dsl_dataset_t *ds)
return (err);
headphys = headdbuf->db_data;
err = zap_value_search(dp->dp_meta_objset,
headphys->ds_snapnames_zapobj, ds->ds_object, 0, ds->ds_snapname);
headphys->ds_snapnames_zapobj, ds->ds_object, 0, ds->ds_snapname,
sizeof (ds->ds_snapname));
if (err != 0 && zfs_recover == B_TRUE) {
err = 0;
(void) snprintf(ds->ds_snapname, sizeof (ds->ds_snapname),

3
module/zfs/dsl_dir.c
View File

@ -239,7 +239,8 @@ dsl_dir_hold_obj(dsl_pool_t *dp, uint64_t ddobj,
err = zap_value_search(dp->dp_meta_objset,
dsl_dir_phys(dd->dd_parent)->
dd_child_dir_zapobj,
ddobj, 0, dd->dd_myname);
ddobj, 0, dd->dd_myname,
sizeof (dd->dd_myname));
}
if (err != 0)
goto errout;

20
module/zfs/zap.c
View File

@ -832,7 +832,12 @@ zap_put_leaf_maybe_grow_ptrtbl(zap_name_t *zn, zap_leaf_t *l,
static int
fzap_checkname(zap_name_t *zn)
{
if (zn->zn_key_orig_numints * zn->zn_key_intlen > ZAP_MAXNAMELEN)
uint32_t maxnamelen = zn->zn_normbuf_len;
uint64_t len = (uint64_t)zn->zn_key_orig_numints * zn->zn_key_intlen;
/* Only allow directory zap to have longname */
if (len > maxnamelen ||
(len > ZAP_MAXNAMELEN &&
zn->zn_zap->zap_dnode->dn_type != DMU_OT_DIRECTORY_CONTENTS))
return (SET_ERROR(ENAMETOOLONG));
return (0);
}
@ -1102,7 +1107,7 @@ zap_create_link_dnsize(objset_t *os, dmu_object_type_t ot, uint64_t parent_obj,
int
zap_value_search(objset_t *os, uint64_t zapobj, uint64_t value, uint64_t mask,
char *name)
char *name, uint64_t namelen)
{
zap_cursor_t zc;
int err;
@ -1110,12 +1115,13 @@ zap_value_search(objset_t *os, uint64_t zapobj, uint64_t value, uint64_t mask,
if (mask == 0)
mask = -1ULL;
zap_attribute_t *za = zap_attribute_alloc();
zap_attribute_t *za = zap_attribute_long_alloc();
for (zap_cursor_init(&zc, os, zapobj);
(err = zap_cursor_retrieve(&zc, za)) == 0;
zap_cursor_advance(&zc)) {
if ((za->za_first_integer & mask) == (value & mask)) {
(void) strlcpy(name, za->za_name, MAXNAMELEN);
if (strlcpy(name, za->za_name, namelen) >= namelen)
err = SET_ERROR(ENAMETOOLONG);
break;
}
}
@ -1130,7 +1136,7 @@ zap_join(objset_t *os, uint64_t fromobj, uint64_t intoobj, dmu_tx_t *tx)
zap_cursor_t zc;
int err = 0;
zap_attribute_t *za = zap_attribute_alloc();
zap_attribute_t *za = zap_attribute_long_alloc();
for (zap_cursor_init(&zc, os, fromobj);
zap_cursor_retrieve(&zc, za) == 0;
(void) zap_cursor_advance(&zc)) {
@ -1155,7 +1161,7 @@ zap_join_key(objset_t *os, uint64_t fromobj, uint64_t intoobj,
zap_cursor_t zc;
int err = 0;
zap_attribute_t *za = zap_attribute_alloc();
zap_attribute_t *za = zap_attribute_long_alloc();
for (zap_cursor_init(&zc, os, fromobj);
zap_cursor_retrieve(&zc, za) == 0;
(void) zap_cursor_advance(&zc)) {
@ -1180,7 +1186,7 @@ zap_join_increment(objset_t *os, uint64_t fromobj, uint64_t intoobj,
zap_cursor_t zc;
int err = 0;
zap_attribute_t *za = zap_attribute_alloc();
zap_attribute_t *za = zap_attribute_long_alloc();
for (zap_cursor_init(&zc, os, fromobj);
zap_cursor_retrieve(&zc, za) == 0;
(void) zap_cursor_advance(&zc)) {

104
module/zfs/zap_micro.c
View File

@ -131,12 +131,12 @@ zap_hash(zap_name_t *zn)
}
static int
zap_normalize(zap_t *zap, const char *name, char *namenorm, int normflags)
zap_normalize(zap_t *zap, const char *name, char *namenorm, int normflags,
size_t outlen)
{
ASSERT(!(zap_getflags(zap) & ZAP_FLAG_UINT64_KEY));
size_t inlen = strlen(name) + 1;
size_t outlen = ZAP_MAXNAMELEN;
int err = 0;
(void) u8_textprep_str((char *)name, &inlen, namenorm, &outlen,
@ -149,23 +149,39 @@ zap_normalize(zap_t *zap, const char *name, char *namenorm, int normflags)
boolean_t
zap_match(zap_name_t *zn, const char *matchname)
{
boolean_t res = B_FALSE;
ASSERT(!(zap_getflags(zn->zn_zap) & ZAP_FLAG_UINT64_KEY));
if (zn->zn_matchtype & MT_NORMALIZE) {
char norm[ZAP_MAXNAMELEN];
size_t namelen = zn->zn_normbuf_len;
char normbuf[ZAP_MAXNAMELEN];
char *norm = normbuf;
/*
* Cannot allocate this on-stack as it exceed the stack-limit of
* 1024.
*/
if (namelen > ZAP_MAXNAMELEN)
norm = kmem_alloc(namelen, KM_SLEEP);
if (zap_normalize(zn->zn_zap, matchname, norm,
zn->zn_normflags) != 0)
return (B_FALSE);
return (strcmp(zn->zn_key_norm, norm) == 0);
zn->zn_normflags, namelen) != 0) {
res = B_FALSE;
} else {
res = (strcmp(zn->zn_key_norm, norm) == 0);
}
if (norm != normbuf)
kmem_free(norm, namelen);
} else {
return (strcmp(zn->zn_key_orig, matchname) == 0);
res = (strcmp(zn->zn_key_orig, matchname) == 0);
}
return (res);
}
static kmem_cache_t *zap_name_cache;
static kmem_cache_t *zap_attr_cache;
static kmem_cache_t *zap_name_long_cache;
static kmem_cache_t *zap_attr_long_cache;
void
zap_init(void)
@ -177,6 +193,14 @@ zap_init(void)
zap_attr_cache = kmem_cache_create("zap_attr_cache",
sizeof (zap_attribute_t) + ZAP_MAXNAMELEN, 0, NULL,
NULL, NULL, NULL, NULL, 0);
zap_name_long_cache = kmem_cache_create("zap_name_long",
sizeof (zap_name_t) + ZAP_MAXNAMELEN_NEW, 0, NULL, NULL,
NULL, NULL, NULL, 0);
zap_attr_long_cache = kmem_cache_create("zap_attr_long_cache",
sizeof (zap_attribute_t) + ZAP_MAXNAMELEN_NEW, 0, NULL,
NULL, NULL, NULL, NULL, 0);
}
void
@ -184,33 +208,47 @@ zap_fini(void)
{
kmem_cache_destroy(zap_name_cache);
kmem_cache_destroy(zap_attr_cache);
kmem_cache_destroy(zap_name_long_cache);
kmem_cache_destroy(zap_attr_long_cache);
}
static zap_name_t *
zap_name_alloc(zap_t *zap)
zap_name_alloc(zap_t *zap, boolean_t longname)
{
zap_name_t *zn = kmem_cache_alloc(zap_name_cache, KM_SLEEP);
kmem_cache_t *cache = longname ? zap_name_long_cache : zap_name_cache;
zap_name_t *zn = kmem_cache_alloc(cache, KM_SLEEP);
zn->zn_zap = zap;
zn->zn_normbuf_len = longname ? ZAP_MAXNAMELEN_NEW : ZAP_MAXNAMELEN;
return (zn);
}
void
zap_name_free(zap_name_t *zn)
{
kmem_cache_free(zap_name_cache, zn);
if (zn->zn_normbuf_len == ZAP_MAXNAMELEN) {
kmem_cache_free(zap_name_cache, zn);
} else {
ASSERT3U(zn->zn_normbuf_len, ==, ZAP_MAXNAMELEN_NEW);
kmem_cache_free(zap_name_long_cache, zn);
}
}
static int
zap_name_init_str(zap_name_t *zn, const char *key, matchtype_t mt)
{
zap_t *zap = zn->zn_zap;
size_t key_len = strlen(key) + 1;
/* Make sure zn is allocated for longname if key is long */
IMPLY(key_len > ZAP_MAXNAMELEN,
zn->zn_normbuf_len == ZAP_MAXNAMELEN_NEW);
zn->zn_key_intlen = sizeof (*key);
zn->zn_key_orig = key;
zn->zn_key_orig_numints = strlen(zn->zn_key_orig) + 1;
zn->zn_key_orig_numints = key_len;
zn->zn_matchtype = mt;
zn->zn_normflags = zap->zap_normflags;
zn->zn_normbuf_len = ZAP_MAXNAMELEN;
/*
* If we're dealing with a case sensitive lookup on a mixed or
@ -226,7 +264,7 @@ zap_name_init_str(zap_name_t *zn, const char *key, matchtype_t mt)
* what the hash is computed from.
*/
if (zap_normalize(zap, key, zn->zn_normbuf,
zap->zap_normflags) != 0)
zap->zap_normflags, zn->zn_normbuf_len) != 0)
return (SET_ERROR(ENOTSUP));
zn->zn_key_norm = zn->zn_normbuf;
zn->zn_key_norm_numints = strlen(zn->zn_key_norm) + 1;
@ -245,7 +283,7 @@ zap_name_init_str(zap_name_t *zn, const char *key, matchtype_t mt)
* what the matching is based on. (Not the hash!)
*/
if (zap_normalize(zap, key, zn->zn_normbuf,
zn->zn_normflags) != 0)
zn->zn_normflags, zn->zn_normbuf_len) != 0)
return (SET_ERROR(ENOTSUP));
zn->zn_key_norm_numints = strlen(zn->zn_key_norm) + 1;
}
@ -256,7 +294,8 @@ zap_name_init_str(zap_name_t *zn, const char *key, matchtype_t mt)
zap_name_t *
zap_name_alloc_str(zap_t *zap, const char *key, matchtype_t mt)
{
zap_name_t *zn = zap_name_alloc(zap);
size_t key_len = strlen(key) + 1;
zap_name_t *zn = zap_name_alloc(zap, (key_len > ZAP_MAXNAMELEN));
if (zap_name_init_str(zn, key, mt) != 0) {
zap_name_free(zn);
return (NULL);
@ -491,7 +530,7 @@ mzap_open(dmu_buf_t *db)
zfs_btree_create_custom(&zap->zap_m.zap_tree, mze_compare,
mze_find_in_buf, sizeof (mzap_ent_t), 512);
zap_name_t *zn = zap_name_alloc(zap);
zap_name_t *zn = zap_name_alloc(zap, B_FALSE);
for (uint16_t i = 0; i < zap->zap_m.zap_num_chunks; i++) {
mzap_ent_phys_t *mze =
&zap_m_phys(zap)->mz_chunk[i];
@ -698,7 +737,7 @@ mzap_upgrade(zap_t **zapp, const void *tag, dmu_tx_t *tx, zap_flags_t flags)
fzap_upgrade(zap, tx, flags);
zap_name_t *zn = zap_name_alloc(zap);
zap_name_t *zn = zap_name_alloc(zap, B_FALSE);
for (int i = 0; i < nchunks; i++) {
mzap_ent_phys_t *mze = &mzp->mz_chunk[i];
if (mze->mze_name[0] == 0)
@ -1625,21 +1664,38 @@ zap_remove_uint64_by_dnode(dnode_t *dn, const uint64_t *key, int key_numints,
}
static zap_attribute_t *
zap_attribute_alloc_impl(boolean_t longname)
{
zap_attribute_t *za;
za = kmem_cache_alloc((longname)? zap_attr_long_cache : zap_attr_cache,
KM_SLEEP);
za->za_name_len = (longname)? ZAP_MAXNAMELEN_NEW : ZAP_MAXNAMELEN;
return (za);
}
zap_attribute_t *
zap_attribute_alloc(void)
{
uint32_t len = ZAP_MAXNAMELEN;
zap_attribute_t *za;
return (zap_attribute_alloc_impl(B_FALSE));
}
za = kmem_cache_alloc(zap_attr_cache, KM_SLEEP);
za->za_name_len = len;
return (za);
zap_attribute_t *
zap_attribute_long_alloc(void)
{
return (zap_attribute_alloc_impl(B_TRUE));
}
void
zap_attribute_free(zap_attribute_t *za)
{
kmem_cache_free(zap_attr_cache, za);
if (za->za_name_len == ZAP_MAXNAMELEN) {
kmem_cache_free(zap_attr_cache, za);
} else {
ASSERT3U(za->za_name_len, ==, ZAP_MAXNAMELEN_NEW);
kmem_cache_free(zap_attr_long_cache, za);
}
}
/*

35
module/zfs/zfs_ioctl.c
View File

@ -2594,6 +2594,41 @@ zfs_prop_set_special(const char *dsname, zprop_source_t source,
}
break;
}
case ZFS_PROP_LONGNAME:
{
zfsvfs_t *zfsvfs;
/*
* Ignore the checks if the property is being applied as part of
* 'zfs receive'. Because, we already check if the local pool
* has SPA_FEATURE_LONGNAME enabled in dmu_recv_begin_check().
*/
if (source == ZPROP_SRC_RECEIVED) {
cmn_err(CE_NOTE, "Skipping ZFS_PROP_LONGNAME checks "
"for dsname=%s\n", dsname);
err = -1;
break;
}
if ((err = zfsvfs_hold(dsname, FTAG, &zfsvfs, B_FALSE)) != 0) {
cmn_err(CE_WARN, "%s:%d Failed to hold for dsname=%s "
"err=%d\n", __FILE__, __LINE__, dsname, err);
break;
}
if (!spa_feature_is_enabled(zfsvfs->z_os->os_spa,
SPA_FEATURE_LONGNAME)) {
err = ENOTSUP;
} else {
/*
* Set err to -1 to force the zfs_set_prop_nvlist code
* down the default path to set the value in the nvlist.
*/
err = -1;
}
zfsvfs_rele(zfsvfs, FTAG);
break;
}
default:
err = -1;
}

8
module/zfs/zfs_znode.c
View File

@ -178,6 +178,7 @@ zfs_obj_to_path_impl(objset_t *osp, uint64_t obj, sa_handle_t *hdl,
dmu_buf_t *prevdb = NULL;
dmu_buf_t *sa_db = NULL;
char *path = buf + len - 1;
char *comp_buf;
int error;
*path = '\0';
@ -193,9 +194,10 @@ zfs_obj_to_path_impl(objset_t *osp, uint64_t obj, sa_handle_t *hdl,
return (error);
}
comp_buf = kmem_alloc(ZAP_MAXNAMELEN_NEW + 2, KM_SLEEP);
for (;;) {
uint64_t pobj = 0;
char component[MAXNAMELEN + 2];
char *component = comp_buf;
size_t complen;
int is_xattrdir = 0;
@ -219,7 +221,8 @@ zfs_obj_to_path_impl(objset_t *osp, uint64_t obj, sa_handle_t *hdl,
strcpy(component + 1, "<xattrdir>");
} else {
error = zap_value_search(osp, pobj, obj,
ZFS_DIRENT_OBJ(-1ULL), component + 1);
ZFS_DIRENT_OBJ(-1ULL), component + 1,
ZAP_MAXNAMELEN_NEW);
if (error != 0)
break;
}
@ -250,6 +253,7 @@ zfs_obj_to_path_impl(objset_t *osp, uint64_t obj, sa_handle_t *hdl,
if (error == 0)
(void) memmove(buf, path, buf + len - path);
kmem_free(comp_buf, ZAP_MAXNAMELEN_NEW +2);
return (error);
}

6
tests/runfiles/linux.run
View File

@ -143,6 +143,10 @@ pre =
post =
tags = ['functional', 'largest_pool']
[tests/functional/longname:Linux]
tests = ['longname_001_pos', 'longname_002_pos', 'longname_003_pos']
tags = ['functional', 'longname']
[tests/functional/mmap:Linux]
tests = ['mmap_libaio_001_pos', 'mmap_sync_001_pos']
tags = ['functional', 'mmap']
@ -187,7 +191,7 @@ tests = ['renameat2_noreplace', 'renameat2_exchange', 'renameat2_whiteout']
tags = ['functional', 'renameat2']
[tests/functional/rsend:Linux]
tests = ['send_realloc_dnode_size', 'send_encrypted_files']
tests = ['send_realloc_dnode_size', 'send_encrypted_files', 'send-c_longname']
tags = ['functional', 'rsend']
[tests/functional/simd:Linux]

6
tests/zfs-tests/tests/Makefile.am
View File

@ -1605,6 +1605,11 @@ nobase_dist_datadir_zfs_tests_tests_SCRIPTS += \
functional/link_count/link_count_001.ksh \
functional/link_count/link_count_root_inode.ksh \
functional/link_count/setup.ksh \
functional/longname/cleanup.ksh \
functional/longname/longname_001_pos.ksh \
functional/longname/longname_002_pos.ksh \
functional/longname/longname_003_pos.ksh \
functional/longname/setup.ksh \
functional/log_spacemap/log_spacemap_import_logs.ksh \
functional/migration/cleanup.ksh \
functional/migration/migration_001_pos.ksh \
@ -1938,6 +1943,7 @@ nobase_dist_datadir_zfs_tests_tests_SCRIPTS += \
functional/rsend/rsend_031_pos.ksh \
functional/rsend/send-c_embedded_blocks.ksh \
functional/rsend/send-c_incremental.ksh \
functional/rsend/send-c_longname.ksh \
functional/rsend/send-c_lz4_disabled.ksh \
functional/rsend/send-c_mixed_compression.ksh \
functional/rsend/send-c_props.ksh \

1
tests/zfs-tests/tests/functional/cli_root/zpool_get/zpool_get.cfg
View File

@ -110,5 +110,6 @@ if is_linux || is_freebsd; then
"feature@vdev_zaps_v2"
"feature@raidz_expansion"
"feature@fast_dedup"
"feature@longname"
)
fi

34
tests/zfs-tests/tests/functional/longname/cleanup.ksh Executable file
View File

@ -0,0 +1,34 @@
#!/bin/ksh -p
#
# CDDL HEADER START
#
# The contents of this file are subject to the terms of the
# Common Development and Distribution License (the "License").
# You may not use this file except in compliance with the License.
#
# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
# or http://www.opensolaris.org/os/licensing.
# See the License for the specific language governing permissions
# and limitations under the License.
#
# When distributing Covered Code, include this CDDL HEADER in each
# file and include the License file at usr/src/OPENSOLARIS.LICENSE.
# If applicable, add the following below this CDDL HEADER, with the
# fields enclosed by brackets "[]" replaced with your own identifying
# information: Portions Copyright [yyyy] [name of copyright owner]
#
# CDDL HEADER END
#
#
# Copyright 2007 Sun Microsystems, Inc. All rights reserved.
# Use is subject to license terms.
#
#
# Copyright (c) 2021 by Nutanix. All rights reserved.
#
. $STF_SUITE/include/libtest.shlib
default_cleanup

132
tests/zfs-tests/tests/functional/longname/longname_001_pos.ksh Executable file
View File

@ -0,0 +1,132 @@
#! /bin/ksh -p
#
# CDDL HEADER START
#
# The contents of this file are subject to the terms of the
# Common Development and Distribution License (the "License").
# You may not use this file except in compliance with the License.
#
# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
# or http://www.opensolaris.org/os/licensing.
# See the License for the specific language governing permissions
# and limitations under the License.
#
# When distributing Covered Code, include this CDDL HEADER in each
# file and include the License file at usr/src/OPENSOLARIS.LICENSE.
# If applicable, add the following below this CDDL HEADER, with the
# fields enclosed by brackets "[]" replaced with your own identifying
# information: Portions Copyright [yyyy] [name of copyright owner]
#
# CDDL HEADER END
#
#
# Copyright (c) 2021 by Nutanix. All rights reserved.
#
. $STF_SUITE/include/libtest.shlib
#
# DESCRIPTION:
# Verify the support for long filenames.
#
# STRATEGY:
# 0. On a fresh dataset ensure property "longname" is enabled by default.
# 1. Disable the longname.
# 2. Try to create a filename whose length is > 256 bytes. This should fail.
# 3. Enable "longname" property on the dataset.
# 4. Try to create files and dirs whose names are > 256 bytes.
# 5. Ensure that "ls" is able to list the file.
# 6. Ensure stat(1) is able to stat the file/directory.
# 7. Try to rename the files and directories
# 8. Try to delete the files and directories
verify_runnable "global"
WORKDIR=$TESTDIR/workdir
MOVEDIR=$TESTDIR/movedir/level2/level3/level4/level5/level6
function cleanup
{
log_must rm -rf $WORKDIR
log_must rm -rf $TESTDIR/movedir
}
LONGNAME=$(printf 'a%.0s' {1..512})
LONGFNAME="file-$LONGNAME"
LONGDNAME="dir-$LONGNAME"
LONGPNAME="mypipe-$LONGNAME"
LONGCNAME="char_dev-$LONGNAME"
LONGLNAME="link-$LONGNAME"
LONGNAME_255=$(printf 'a%.0s' {1..255})
LONGNAME_1023=$(printf 'a%.0s' {1..1023})
log_assert "Check longname support for directories/files"
log_onexit cleanup
log_must mkdir $WORKDIR
log_must mkdir -p $MOVEDIR
# Disable longname support
log_must zfs set longname=off $TESTPOOL/$TESTFS
#Ensure a file of length 255bytes can be created
log_must touch $WORKDIR/$LONGNAME_255
#Where as file of length 256bytes should fail
log_mustnot touch $WORKDIR/${LONGNAME_255}b
# Try to create a file with long name with property "longname=off"
log_mustnot touch $WORKDIR/$LONGFNAME
log_mustnot mkdir $WORKDIR/$LONGDNAME
# Enable longname support
log_must zfs set longname=on $TESTPOOL/$TESTFS
# Retry the longname creates and that should succeed
log_must mkdir $WORKDIR/$LONGDNAME
log_must touch $WORKDIR/$LONGFNAME
# Should be able to create a file with name of 1023 chars
log_must touch $WORKDIR/$LONGNAME_1023
# And names longer that 1023 should fail
log_mustnot touch $WORKDIR/${LONGNAME_1023}b
# Ensure the longnamed dir/file can be listed.
name=$(ls $WORKDIR/$LONGFNAME)
if [[ "${name}" != "$WORKDIR/$LONGFNAME" ]]; then
log_fail "Unable to list: $WORKDIR/$LONGFNAME ret:$name"
fi
name=$(ls -d $WORKDIR/$LONGDNAME)
if [[ "${name}" != "$WORKDIR/$LONGDNAME" ]]; then
log_fail "Unable to list: $WORKDIR/$LONGDNAME ret:$name"
fi
# Ensure stat works
log_must stat $WORKDIR/$LONGFNAME
log_must stat $WORKDIR/$LONGDNAME
# Ensure softlinks can be created from a longname to
# another longnamed file.
log_must ln -s $WORKDIR/$LONGFNAME $WORKDIR/$LONGLNAME
# Ensure a longnamed pipe and character device file
# can be created
log_must mknod $WORKDIR/$LONGPNAME p
log_must mknod $WORKDIR/$LONGCNAME c 92 1
# Ensure we can rename the longname file
log_must mv $WORKDIR/$LONGFNAME $WORKDIR/file2
# Delete the long named dir/file
log_must rmdir $WORKDIR/$LONGDNAME
log_must rm $WORKDIR/file2
log_must rm $WORKDIR/$LONGPNAME
log_must rm $WORKDIR/$LONGCNAME
log_must rm $WORKDIR/$LONGLNAME
log_pass

115
tests/zfs-tests/tests/functional/longname/longname_002_pos.ksh Executable file
View File

@ -0,0 +1,115 @@
#! /bin/ksh -p
#
# CDDL HEADER START
#
# The contents of this file are subject to the terms of the
# Common Development and Distribution License (the "License").
# You may not use this file except in compliance with the License.
#
# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
# or http://www.opensolaris.org/os/licensing.
# See the License for the specific language governing permissions
# and limitations under the License.
#
# When distributing Covered Code, include this CDDL HEADER in each
# file and include the License file at usr/src/OPENSOLARIS.LICENSE.
# If applicable, add the following below this CDDL HEADER, with the
# fields enclosed by brackets "[]" replaced with your own identifying
# information: Portions Copyright [yyyy] [name of copyright owner]
#
# CDDL HEADER END
#
#
# Copyright (c) 2021 by Nutanix. All rights reserved.
#
. $STF_SUITE/include/libtest.shlib
#
# DESCRIPTION:
# Check if longname feature is disabled by default and can be enabled.
#
# STRATEGY:
# 1. Create a zpool with longname feature disabled
# 2. Attempt to enable 'longname' property should fail.
# 3. Attempt to create a longnamed (>255) file should fail.
# 4. Enable the feature@longname
# 5. Enable 'longname' property on the dataset.
# 6. Should be able to create long named files and directories.
# 7. Should be able to disable longname property.
# 8. This should disallow creating new longnamed file/dirs. But, should be
# able to access existing longnamed files/dirs.
verify_runnable "global"
function cleanup
{
log_must rm -rf $WORKDIR
poolexists $TESTPOOL && zpool destroy $TESTPOOL
}
log_assert "Check feature@longname and 'longname' dataset propery work correctly"
log_onexit cleanup
log_must zpool destroy $TESTPOOL
log_must zpool create -o feature@longname=disabled $TESTPOOL $DISKS
log_must zfs create $TESTPOOL/$TESTFS2
log_must zfs set mountpoint=$TESTDIR2 $TESTPOOL/$TESTFS2
log_mustnot zfs set longname=on $TESTPOOL/$TESTFS2
LONGNAME=$(printf 'a%.0s' {1..512})
LONGFNAME="file-$LONGNAME"
LONGDNAME="dir-$LONGNAME"
SHORTDNAME="dir-short"
SHORTFNAME="file-short"
WORKDIR=$TESTDIR2/workdir
log_must mkdir $WORKDIR
log_mustnot touch $WORKDIR/$LONGFNAME
log_mustnot mkdir $WORKDIR/$LONGDNAME
log_must zpool set feature@longname=enabled $TESTPOOL
log_must zfs set longname=on $TESTPOOL/$TESTFS2
log_must mkdir $WORKDIR/$LONGDNAME
log_must touch $WORKDIR/$LONGFNAME
# Ensure the above changes are synced out.
log_must zpool sync $TESTPOOL
# Ensure that the feature is activated once longnamed files are created.
state=$(zpool get feature@longname -H -o value $TESTPOOL)
log_note "feature@longname on pool: $TESTPOOL : $state"
if [[ "$state" != "active" ]]; then
log_fail "feature@longname has state $state (expected active)"
fi
# Set longname=off.
log_must zfs set longname=off $TESTPOOL/$TESTFS2
# Ensure no new file/directory with longnames can be created or can be renamed
# to.
log_mustnot mkdir $WORKDIR/${LONGDNAME}.1
log_mustnot touch $WORKDIR/${LONGFNAME}.1
log_must mkdir $WORKDIR/$SHORTDNAME
log_mustnot mv $WORKDIR/$SHORTDNAME $WORKDIR/${LONGDNAME}.1
log_must touch $WORKDIR/$SHORTFNAME
log_mustnot mv $WORKDIR/$SHORTFNAME $WORKDIR/${LONGFNAME}.1
#Cleanup shortnames
log_must rmdir $WORKDIR/$SHORTDNAME
log_must rm $WORKDIR/$SHORTFNAME
# But, should be able to stat and rename existing files
log_must stat $WORKDIR/$LONGDNAME
log_must stat $WORKDIR/$LONGFNAME
log_must mv $WORKDIR/$LONGDNAME $WORKDIR/$SHORTDNAME
log_must mv $WORKDIR/$LONGFNAME $WORKDIR/$SHORTFNAME
log_pass

113
tests/zfs-tests/tests/functional/longname/longname_003_pos.ksh Executable file
View File

@ -0,0 +1,113 @@
#! /bin/ksh -p
#
# CDDL HEADER START
#
# The contents of this file are subject to the terms of the
# Common Development and Distribution License (the "License").
# You may not use this file except in compliance with the License.
#
# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
# or http://www.opensolaris.org/os/licensing.
# See the License for the specific language governing permissions
# and limitations under the License.
#
# When distributing Covered Code, include this CDDL HEADER in each
# file and include the License file at usr/src/OPENSOLARIS.LICENSE.
# If applicable, add the following below this CDDL HEADER, with the
# fields enclosed by brackets "[]" replaced with your own identifying
# information: Portions Copyright [yyyy] [name of copyright owner]
#
# CDDL HEADER END
#
#
# Copyright (c) 2021 by Nutanix. All rights reserved.
#
. $STF_SUITE/include/libtest.shlib
#
# DESCRIPTION:
# Check if longnames are handled correctly by ZIL replay and feature is activated.
#
# STRATEGY:
# 1. Create a zpool with longname feature disabled
# 2. Enable the feature@longname
# 3. Enable 'longname' property on the dataset.
# 4. Freeze the zpool
# 5. Create a longname
# 6. Export and import the zpool.
# 7. Replaying of longname create should activate the feature@longname
verify_runnable "global"
function cleanup
{
log_must rm -rf $WORKDIR
poolexists $TESTPOOL && zpool destroy $TESTPOOL
}
log_assert "Check feature@longname and 'longname' dataset propery work correctly"
log_onexit cleanup
poolexists $TESTPOOL && zpool destroy $TESTPOOL
log_must zpool create -o feature@longname=disabled $TESTPOOL $DISKS
log_must zfs create $TESTPOOL/$TESTFS
log_must zfs set mountpoint=$TESTDIR $TESTPOOL/$TESTFS
LONGNAME=$(printf 'a%.0s' {1..512})
LONGFNAME="file-$LONGNAME"
LONGDNAME="dir-$LONGNAME"
SHORTDNAME="dir-short"
SHORTFNAME="file-short"
WORKDIR=$TESTDIR/workdir
log_must mkdir $WORKDIR
log_must zpool set feature@longname=enabled $TESTPOOL
log_must zfs set longname=on $TESTPOOL/$TESTFS
# Ensure that the feature is NOT activated yet as no longnamed file is created.
state=$(zpool get feature@longname -H -o value $TESTPOOL)
log_note "feature@longname on pool: $TESTPOOL : $state"
if [[ "$state" != "enabled" ]]; then
log_fail "feature@longname has state $state (expected enabled)"
fi
#
# This dd command works around an issue where ZIL records aren't created
# after freezing the pool unless a ZIL header already exists. Create a file
# synchronously to force ZFS to write one out.
#
log_must dd if=/dev/zero of=/$WORKDIR/sync conv=fdatasync,fsync bs=1 count=1
log_must zpool freeze $TESTPOOL
log_must mkdir $WORKDIR/$LONGDNAME
log_must touch $WORKDIR/$LONGFNAME
# Export and re-import the zpool
log_must zpool export $TESTPOOL
log_must zpool import $TESTPOOL
# Ensure that the feature is activated once longnamed files are created.
state=$(zpool get feature@longname -H -o value $TESTPOOL)
log_note "feature@longname on pool: $TESTPOOL : $state"
if [[ "$state" != "active" ]]; then
log_fail "feature@longname has state $state (expected active)"
fi
# Destroying the dataset where the feature is activated should put the feature
# back to 'enabled' state
log_must zfs destroy -r $TESTPOOL/$TESTFS
state=$(zpool get feature@longname -H -o value $TESTPOOL)
log_note "feature@longname on pool: $TESTPOOL : $state"
if [[ "$state" != "enabled" ]]; then
log_fail "feature@longname has state $state (expected active)"
fi
log_pass

35
tests/zfs-tests/tests/functional/longname/setup.ksh Executable file
View File

@ -0,0 +1,35 @@
#!/bin/ksh -p
#
# CDDL HEADER START
#
# The contents of this file are subject to the terms of the
# Common Development and Distribution License (the "License").
# You may not use this file except in compliance with the License.
#
# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
# or http://www.opensolaris.org/os/licensing.
# See the License for the specific language governing permissions
# and limitations under the License.
#
# When distributing Covered Code, include this CDDL HEADER in each
# file and include the License file at usr/src/OPENSOLARIS.LICENSE.
# If applicable, add the following below this CDDL HEADER, with the
# fields enclosed by brackets "[]" replaced with your own identifying
# information: Portions Copyright [yyyy] [name of copyright owner]
#
# CDDL HEADER END
#
#
# Copyright 2007 Sun Microsystems, Inc. All rights reserved.
# Use is subject to license terms.
#
#
# Copyright (c) 2021 by Nutanix. All rights reserved.
#
. $STF_SUITE/include/libtest.shlib
DISK=${DISKS%% *}
default_setup $DISK

1
tests/zfs-tests/tests/functional/rsend/rsend.kshlib
View File

@ -713,6 +713,7 @@ function stream_has_features
feature[resuming]="100000"
feature[redacted]="200000"
feature[compressed]="400000"
feature[longname]="10000000"
typeset flag known derived=0
for flag in "$@"; do

98
tests/zfs-tests/tests/functional/rsend/send-c_longname.ksh Executable file
View File

@ -0,0 +1,98 @@
#!/bin/ksh -p
#
# This file and its contents are supplied under the terms of the
# Common Development and Distribution License ("CDDL"), version 1.0.
# You may only use this file in accordance with the terms of version
# 1.0 of the CDDL.
#
# A full copy of the text of the CDDL should have accompanied this
# source. A copy of the CDDL is also available via the Internet at
# http://www.illumos.org/license/CDDL.
#
#
# Copyright (c) 2021 by Nutanix. All rights reserved.
#
. $STF_SUITE/tests/functional/rsend/rsend.kshlib
. $STF_SUITE/include/properties.shlib
#
# Description:
# Verify that longname featureflag is present in the stream.
#
# Strategy:
# 1. Create a filesystem with longnamed files/directories.
# 2. Verify that the sendstream has the longname featureflag is present in the
# send stream.
# 3. Verify the created streams can be received correctly.
# 4. Verify that the longnamed files/directories are present in the received
# filesystem.
#
verify_runnable "both"
log_assert "Verify that longnames are handled correctly in send stream."
log_onexit cleanup_pool $POOL $POOL2 $POOL3
typeset sendfs=$POOL/sendfs
typeset recvfs=$POOL2/recvfs
typeset recvfs3=$POOL3/recvfs
typeset stream=$BACKDIR/stream
typeset dump=$BACKDIR/dump
log_must zfs create -o longname=on $sendfs
typeset dir=$(get_prop mountpoint $sendfs)
# Create a longnamed dir and a file in the send dataset
LONGNAME=$(printf 'a%.0s' {1..512})
LONGFNAME="file-$LONGNAME"
LONGDNAME="dir-$LONGNAME"
log_must mkdir $dir/$LONGDNAME
log_must touch $dir/$LONGFNAME
# When POOL3 is created by rsend.kshlib feature@longname is 'enabled'.
# Recreate the POOL3 with feature@longname disabled.
datasetexists $POOL3 && log_must zpool destroy $POOL3
log_must zpool create -o feature@longname=disabled $POOL3 $DISK3
# Generate the streams and zstreamdump output.
log_must zfs snapshot $sendfs@now
log_must eval "zfs send -p $sendfs@now >$stream"
log_must eval "zstream dump -v <$stream >$dump"
log_must eval "zfs recv $recvfs <$stream"
cmp_ds_cont $sendfs $recvfs
log_must stream_has_features $stream longname
# Ensure the the receiving pool has feature@longname activated after receiving.
feat_val=$(zpool get -H -o value feature@longname $POOL2)
log_note "Zpool $POOL2 feature@longname=$feat_val"
if [[ "$feat_val" != "active" ]]; then
log_fail "pool $POOL2 feature@longname=$feat_val (expected 'active')"
fi
# Receiving of the stream on $POOL3 should fail as longname is not enabled
log_mustnot eval "zfs recv $recvfs3 <$stream"
# Enable feature@longname and retry the receiving the stream.
# It should succeed this time.
log_must eval "zpool set feature@longname=enabled $POOL3"
log_must eval "zfs recv $recvfs3 <$stream"
log_must zfs get longname $recvfs3
prop_val=$(zfs get -H -o value longname $recvfs3)
log_note "dataset $recvfs3 has longname=$prop_val"
if [[ "$prop_val" != "on" ]]; then
log_fail "$recvfs3 has longname=$prop_val (expected 'on')"
fi
#
# TODO:
# - Add a testcase to cover the case where send-stream does not contain
# properties (generated without "-p").
# In this case the target dataset would have longname files/directories which
# cannot be accessed if the dataset property 'longname=off'.
#
log_pass "Longnames are handled correctly in send/recv"