DAOS-14698 crtl: Create container with attributes

ci/unit/test_nlt_node.sh

@@ -41,5 +41,5 @@ pip install /opt/daos/lib/daos/python/
 sudo prlimit --nofile=1024:262144 --pid $$
 prlimit -n
 
-./utils/node_local_test.py --max-log-size 1700MiB --dfuse-dir /localhome/jenkins/ \
+./utils/node_local_test.py --max-log-size 1900MiB --dfuse-dir /localhome/jenkins/ \
     --log-usage-save nltir.xml --log-usage-export nltr.json all

src/client/dfs/duns.c

@@ -1,5 +1,5 @@
 /**
- * (C) Copyright 2019-2023 Intel Corporation.
+ * (C) Copyright 2019-2024 Intel Corporation.
  *
  * SPDX-License-Identifier: BSD-2-Clause-Patent
  */
@@ -1131,18 +1131,20 @@ duns_create_path(daos_handle_t poh, const char *path, struct duns_attr_t *attrp)
 int
 duns_link_cont(daos_handle_t poh, const char *cont, const char *path)
 {
-	daos_handle_t		coh;
-	daos_prop_t		*prop;
-	struct daos_prop_entry	*entry;
-	daos_pool_info_t	pinfo = {0};
-	daos_cont_info_t	cinfo = {0};
-	daos_cont_layout_t	type;
-	char			pool_str[DAOS_UUID_STR_SIZE];
-	char			cont_str[DAOS_UUID_STR_SIZE];
-	int			len;
-	char			str[DUNS_MAX_XATTR_LEN];
-	char			type_str[10];
-	int			rc, rc2;
+	daos_handle_t           coh;
+	daos_prop_t            *prop;
+	struct daos_prop_entry *entry;
+	daos_pool_info_t        pinfo = {0};
+	daos_cont_info_t        cinfo = {0};
+	daos_cont_layout_t      type;
+	char                    pool_str[DAOS_UUID_STR_SIZE];
+	char                    cont_str[DAOS_UUID_STR_SIZE];
+	int                     len;
+	char                    str[DUNS_MAX_XATTR_LEN];
+	char                    type_str[10];
+	bool                    backend_dfuse = false;
+	int                     rc2;
+	int                     rc;
 
 	if (path == NULL) {
 		D_ERROR("Invalid path\n");
@@ -1155,7 +1157,7 @@ duns_link_cont(daos_handle_t poh, const char *cont, const char *path)
 		return daos_der2errno(rc);
 	}
 
-	rc = daos_cont_open(poh, cont, DAOS_COO_RO, &coh, &cinfo, NULL);
+	rc = daos_cont_open(poh, cont, DAOS_COO_RW, &coh, &cinfo, NULL);
 	if (rc) {
 		D_ERROR("daos_cont_open() failed "DF_RC"\n", DP_RC(rc));
 		return daos_der2errno(rc);
@@ -1203,7 +1205,6 @@ duns_link_cont(daos_handle_t poh, const char *cont, const char *path)
 			D_FREE(dir);
 			D_GOTO(out_cont, rc = err);
 		}
-		D_FREE(dir);
 #ifdef LUSTRE_INCLUDE
 		if (fs.f_type == LL_SUPER_MAGIC) {
 			rc = duns_link_lustre_path(pool_str, cont_str, type, path, mode);
@@ -1218,28 +1219,46 @@ duns_link_cont(daos_handle_t poh, const char *cont, const char *path)
 		if (rc == -1) {
 			rc = errno;
 			D_ERROR("Failed to create dir %s: %d (%s)\n", path, rc, strerror(rc));
+			D_FREE(dir);
 			D_GOTO(out_cont, rc);
 		}
 
 		/* Open the parent directory for the new container so we can call a dfuse iotcl
 		 * to discover the user running dfuse.
 		 */
 		if (fs.f_type == FUSE_SUPER_MAGIC) {
-			struct stat finfo;
-			/*
-			 * This next stat will cause dfuse to lookup the entry point and perform a
-			 * container connect, therefore this data will be read from root of the new
-			 * container, not the directory.
-			 *
-			 * TODO: This could call getxattr to verify success.
-			 */
-			rc = stat(path, &finfo);
-			if (rc) {
-				rc = errno;
-				D_ERROR("Failed to access container: %d (%s)\n", rc, strerror(rc));
+			int                     fd;
+			struct dfuse_user_reply dur = {};
+
+			fd = open(dirp, O_RDONLY | O_DIRECTORY | O_NOFOLLOW);
+			if (fd == -1) {
+				int err = errno;
+
+				DS_ERROR(err, "Dfuse open failed '%s", dirp);
+				D_FREE(dir);
+				D_GOTO(err_link, err);
+			}
+
+			rc = ioctl(fd, DFUSE_IOCTL_DFUSE_USER, &dur);
+			close(fd);
+			if (rc == -1) {
+				int err = errno;
+
+				DS_ERROR(err, "Dfuse ioctl failed %s", dirp);
+				D_FREE(dir);
+				D_GOTO(err_link, err);
+			}
+
+			rc = duns_set_fuse_acl(dur.uid, coh);
+			if (rc != -DER_SUCCESS) {
+				DS_ERROR(rc, "Dfuse set acl failed %s", dirp);
+				D_FREE(dir);
 				D_GOTO(err_link, rc);
 			}
+
+			backend_dfuse = true;
 		}
+		D_FREE(dir);
 	} else if (type != DAOS_PROP_CO_LAYOUT_UNKNOWN) {
 		/** create a new file for other container types */
 		int fd;
@@ -1304,11 +1323,33 @@ duns_link_cont(daos_handle_t poh, const char *cont, const char *path)
 		}
 		D_GOTO(err_link, rc);
 	}
+	if (backend_dfuse) {
+		struct stat finfo;
+		/*
+		 * This next stat will cause dfuse to lookup the entry point and perform a
+		 * container connect, therefore this data will be read from root of the new
+		 * container, not the directory.
+		 *
+		 * TODO: This could call getxattr to verify success.
+		 */
+		rc = stat(path, &finfo);
+		if (rc) {
+			rc = errno;
+			DS_ERROR(rc, "Failed to access container bind at '%s'", path);
+			goto err_link;
+		}
+	}
 
 out_cont:
 	rc2 = daos_cont_close(coh, NULL);
-	if (rc == 0)
-		rc = rc2;
+	if (rc2 != -DER_SUCCESS) {
+		DL_ERROR(rc2, "failed to close container");
+		if (rc2 == -DER_NOMEM)
+			/* Second close to properly handle fault injection */
+			daos_cont_close(coh, NULL);
+		else if (rc == -DER_SUCCESS)
+			rc = daos_der2errno(rc2);
+	}
 	return rc;
 err_link:
 	if (type == DAOS_PROP_CO_LAYOUT_POSIX)

src/control/cmd/daos/container.go

@@ -251,6 +251,7 @@ type containerCreateCmd struct {
 	Mode            ConsModeFlag         `long:"mode" short:"M" description:"DFS consistency mode"`
 	ACLFile         string               `long:"acl-file" short:"A" description:"input file containing ACL"`
 	Group           ui.ACLPrincipalFlag  `long:"group" short:"g" description:"group who will own the container (group@[domain])"`
+	Attrs           ui.SetPropertiesFlag `long:"attrs" short:"a" description:"user-defined attributes (key:val[,key:val...])"`
 	Args            struct {
 		Label string `positional-arg-name:"label"`
 	} `positional-args:"yes"`
@@ -305,11 +306,7 @@ func (cmd *containerCreateCmd) Execute(_ []string) (err error) {
 	defer disconnectPool()
 
 	var contID string
-	if cmd.Path != "" {
-		contID, err = cmd.contCreateUNS()
-	} else {
-		contID, err = cmd.contCreate()
-	}
+	contID, err = cmd.contCreate()
 	if err != nil {
 		return err
 	}
@@ -397,76 +394,50 @@ func (cmd *containerCreateCmd) contCreate() (string, error) {
 	if err != nil {
 		return "", err
 	}
+	contID := cmd.contUUID.String()
+	cContID := C.CString(contID)
+	defer freeString(cContID)
 
-	var contID string
-	if cmd.contUUID == uuid.Nil {
-		contID = cmd.contLabel
-	} else {
-		contID = cmd.contUUID.String()
-	}
-
-	cmd.Infof("Successfully created container %s", contID)
-	return contID, nil
-}
-
-func (cmd *containerCreateCmd) contCreateUNS() (string, error) {
-	var dattr C.struct_duns_attr_t
-
-	props, cleanupProps, err := cmd.getCreateProps()
-	if err != nil {
-		return "", err
+	cleanupContainer := func() {
+		rc := C.daos_cont_destroy(cmd.cPoolHandle, cContID, goBool2int(true), nil)
+		if err := daosError(rc); err != nil {
+			cmd.Noticef("Failed to clean-up container %v", err)
+		}
 	}
-	defer cleanupProps()
-	dattr.da_props = props
 
-	if !cmd.Type.Set {
-		return "", errors.New("container type is required for UNS")
-	}
-	dattr.da_type = cmd.Type.Type
+	if len(cmd.Attrs.ParsedProps) != 0 {
+		attrs := make(attrList, 0, len(cmd.Attrs.ParsedProps))
+		for key, val := range cmd.Attrs.ParsedProps {
+			attrs = append(attrs, &attribute{
+				Name:  key,
+				Value: []byte(val),
+			})
+		}
 
-	if cmd.poolUUID != uuid.Nil {
-		poolUUIDStr := C.CString(cmd.poolUUID.String())
-		defer freeString(poolUUIDStr)
-		C.uuid_parse(poolUUIDStr, &dattr.da_puuid[0])
-	}
-	if cmd.contUUID != uuid.Nil {
-		contUUIDStr := C.CString(cmd.contUUID.String())
-		defer freeString(contUUIDStr)
-		C.uuid_parse(contUUIDStr, &dattr.da_cuuid[0])
-	}
+		if err := cmd.openContainer(C.DAOS_COO_RW); err != nil {
+			cleanupContainer()
+			return "", errors.Wrapf(err, "failed to open new container %s", contID)
+		}
+		defer cmd.closeContainer()
 
-	if cmd.ChunkSize.Set {
-		dattr.da_chunk_size = cmd.ChunkSize.Size
-	}
-	if cmd.ObjectClass.Set {
-		dattr.da_oclass_id = cmd.ObjectClass.Class
-	}
-	if cmd.DirObjectClass.Set {
-		dattr.da_dir_oclass_id = cmd.DirObjectClass.Class
-	}
-	if cmd.FileObjectClass.Set {
-		dattr.da_file_oclass_id = cmd.FileObjectClass.Class
-	}
-	if cmd.CHints != "" {
-		hint := C.CString(cmd.CHints)
-		defer freeString(hint)
-		C.strncpy(&dattr.da_hints[0], hint, C.DAOS_CONT_HINT_MAX_LEN-1)
+		if err := setDaosAttributes(cmd.cContHandle, contAttr, attrs); err != nil {
+			cleanupContainer()
+			return "", errors.Wrapf(err, "failed to set user attributes on new container %s", contID)
+		}
 	}
 
-	cPath := C.CString(cmd.Path)
-	defer freeString(cPath)
+	if cmd.Path != "" {
+		cPath := C.CString(cmd.Path)
+		defer freeString(cPath)
 
-	dunsErrno := C.duns_create_path(cmd.cPoolHandle, cPath, &dattr)
-	rc := C.daos_errno2der(dunsErrno)
-	if err := daosError(rc); err != nil {
-		return "", errors.Wrapf(err, "duns_create_path() failed")
+		dunsErrno := C.duns_link_cont(cmd.cPoolHandle, cContID, cPath)
+		rc := C.daos_errno2der(dunsErrno)
+		if err := daosError(rc); err != nil {
+			cleanupContainer()
+			return "", errors.Wrapf(err, "duns_link_cont() failed")
+		}
 	}
 
-	contID := C.GoString(&dattr.da_cont[0])
-	cmd.contUUID, err = uuid.Parse(contID)
-	if err != nil {
-		cmd.contLabel = contID
-	}
 	cmd.Infof("Successfully created container %s type %s", contID, cmd.Type.String())
 	return contID, nil
 }