/*
* Copyright (C) 2013, Trustees of Indiana University
*
- * Copyright (c) 2014, Intel Corporation.
+ * Copyright (c) 2017, Intel Corporation.
*
* Author: Joshua Walgenbach <jjw@iu.edu>
*/
#include <linux/module.h>
#include <linux/sort.h>
-#include <lnet/nidstr.h>
+#include <uapi/linux/lnet/nidstr.h>
#include <lustre_net.h>
#include <lustre_acl.h>
-#include <lustre_eacl.h>
#include <obd_class.h>
#include "nodemap_internal.h"
nm_member_reclassify_nodemap(nodemap);
up_read(&active_config->nmc_range_tree_lock);
- write_lock(&nodemap->nm_idmap_lock);
+ down_write(&nodemap->nm_idmap_lock);
idmap_delete_tree(nodemap);
- write_unlock(&nodemap->nm_idmap_lock);
+ up_write(&nodemap->nm_idmap_lock);
mutex_unlock(&active_config_lock);
*/
struct lu_nodemap *nodemap_classify_nid(lnet_nid_t nid)
{
- struct lu_nid_range *range;
- struct lu_nodemap *nodemap;
+ struct lu_nid_range *range;
+ struct lu_nodemap *nodemap;
int rc;
ENTRY;
/* don't use 0@lo, use the first non-lo local NID instead */
- if (LNET_NETTYP(LNET_NIDNET(nid)) == LOLND) {
- lnet_process_id_t id;
+ if (nid == LNET_NID_LO_0) {
+ struct lnet_processid id;
int i = 0;
do {
rc = LNetGetId(i++, &id);
if (rc < 0)
RETURN(ERR_PTR(-EINVAL));
- } while (LNET_NETTYP(LNET_NIDNET(id.nid)) == LOLND);
+ } while (nid_is_lo0(&id.nid));
- nid = id.nid;
+ nid = lnet_nid_to_nid4(&id.nid);
CDEBUG(D_INFO, "found nid %s\n", libcfs_nid2str(nid));
}
/**
* add an idmap to the proper nodemap trees
*
- * \param name name of nodemap
+ * \param nodemap nodemap to add idmap to
* \param id_type NODEMAP_UID or NODEMAP_GID
* \param map array[2] __u32 containing the map values
* map[0] is client id
* map[1] is the filesystem id
*
- * \retval 0 on success
+ * \retval 0 on success
+ * \retval < 0 if error occurs
*/
int nodemap_add_idmap_helper(struct lu_nodemap *nodemap,
enum nodemap_id_type id_type,
const __u32 map[2])
{
struct lu_idmap *idmap;
+ struct lu_idmap *temp;
int rc = 0;
idmap = idmap_create(map[0], map[1]);
if (idmap == NULL)
GOTO(out, rc = -ENOMEM);
- write_lock(&nodemap->nm_idmap_lock);
- idmap_insert(id_type, idmap, nodemap);
- write_unlock(&nodemap->nm_idmap_lock);
+ down_write(&nodemap->nm_idmap_lock);
+ temp = idmap_insert(id_type, idmap, nodemap);
+ /* If the new id_client or id_fs is matched, the old idmap and its
+ * index should be deleted according to its id_client before the new
+ * idmap is added again.
+ */
+ if (IS_ERR(temp))
+ GOTO(out_insert, rc = PTR_ERR(temp));
+ if (temp) {
+ __u32 del_map[2];
+
+ del_map[0] = temp->id_client;
+ idmap_delete(id_type, temp, nodemap);
+ rc = nodemap_idx_idmap_del(nodemap, id_type, del_map);
+ /* In case there is any corrupted idmap */
+ if (!rc || unlikely(rc == -ENOENT)) {
+ temp = idmap_insert(id_type, idmap, nodemap);
+ if (IS_ERR(temp))
+ rc = PTR_ERR(temp);
+ else if (!temp)
+ rc = 0;
+ else
+ rc = -EPERM;
+ }
+ }
+out_insert:
+ if (rc)
+ OBD_FREE_PTR(idmap);
+ up_write(&nodemap->nm_idmap_lock);
nm_member_revoke_locks(nodemap);
out:
struct lu_nodemap *nodemap = NULL;
int rc;
+ ENTRY;
+
mutex_lock(&active_config_lock);
nodemap = nodemap_lookup(name);
if (IS_ERR(nodemap)) {
nodemap_putref(nodemap);
out:
- return rc;
+ RETURN(rc);
}
EXPORT_SYMBOL(nodemap_add_idmap);
struct lu_idmap *idmap = NULL;
int rc = 0;
+ ENTRY;
+
mutex_lock(&active_config_lock);
nodemap = nodemap_lookup(name);
if (IS_ERR(nodemap)) {
if (is_default_nodemap(nodemap))
GOTO(out_putref, rc = -EINVAL);
- write_lock(&nodemap->nm_idmap_lock);
+ down_write(&nodemap->nm_idmap_lock);
idmap = idmap_search(nodemap, NODEMAP_CLIENT_TO_FS, id_type,
map[0]);
if (idmap == NULL) {
idmap_delete(id_type, idmap, nodemap);
rc = nodemap_idx_idmap_del(nodemap, id_type, map);
}
- write_unlock(&nodemap->nm_idmap_lock);
+ up_write(&nodemap->nm_idmap_lock);
out_putref:
mutex_unlock(&active_config_lock);
nodemap_putref(nodemap);
out:
- return rc;
+ RETURN(rc);
}
EXPORT_SYMBOL(nodemap_del_idmap);
* mapping function for nodemap idmaps
*
* \param nodemap lu_nodemap structure defining nodemap
- * \param node_type NODEMAP_UID or NODEMAP_GID
+ * \param node_type NODEMAP_UID or NODEMAP_GID or NODEMAP_PROJID
* \param tree_type NODEMAP_CLIENT_TO_FS or
* NODEMAP_FS_TO_CLIENT
* \param id id to map
* is, return 0. Otherwise, return the squash uid or gid.
*
* if the nodemap is configured to trusted the ids from the client system, just
- * return the passwd id without mapping.
+ * return the passed id without mapping.
*
* if by this point, we haven't returned and the nodemap in question is the
* default nodemap, return the squash uid or gid.
if (id == 0) {
if (nodemap->nmf_allow_root_access)
goto out;
- else
- goto squash;
+ goto squash;
}
+ if (id_type == NODEMAP_UID &&
+ !(nodemap->nmf_map_mode & NODEMAP_MAP_UID))
+ goto out;
+
+ if (id_type == NODEMAP_GID &&
+ !(nodemap->nmf_map_mode & NODEMAP_MAP_GID))
+ goto out;
+
+ if (id_type == NODEMAP_PROJID &&
+ !(nodemap->nmf_map_mode & NODEMAP_MAP_PROJID))
+ goto out;
+
if (nodemap->nmf_trust_client_ids)
goto out;
if (is_default_nodemap(nodemap))
goto squash;
- read_lock(&nodemap->nm_idmap_lock);
+ down_read(&nodemap->nm_idmap_lock);
idmap = idmap_search(nodemap, tree_type, id_type, id);
if (idmap == NULL) {
- read_unlock(&nodemap->nm_idmap_lock);
+ up_read(&nodemap->nm_idmap_lock);
goto squash;
}
found_id = idmap->id_client;
else
found_id = idmap->id_fs;
- read_unlock(&nodemap->nm_idmap_lock);
+ up_read(&nodemap->nm_idmap_lock);
RETURN(found_id);
squash:
if (id_type == NODEMAP_UID)
RETURN(nodemap->nm_squash_uid);
- else
+ if (id_type == NODEMAP_GID)
RETURN(nodemap->nm_squash_gid);
+ if (id_type == NODEMAP_PROJID)
+ RETURN(nodemap->nm_squash_projid);
out:
RETURN(id);
}
enum nodemap_tree_type tree_type)
{
posix_acl_xattr_header *header = buf;
- posix_acl_xattr_entry *entry = &header->a_entries[0];
+ posix_acl_xattr_entry *entry = GET_POSIX_ACL_XATTR_ENTRY(header);
posix_acl_xattr_entry *new_entry = entry;
posix_acl_xattr_entry *end;
int count;
+ ENTRY;
+
if (!nodemap_active)
- return size;
+ RETURN(size);
if (unlikely(nodemap == NULL))
- return size;
+ RETURN(size);
count = posix_acl_xattr_count(size);
if (count < 0)
- return -EINVAL;
+ RETURN(-EINVAL);
if (count == 0)
- return 0;
+ /* if not proper ACL, do nothing and return initial size */
+ RETURN(size);
for (end = entry + count; entry != end; entry++) {
__u16 tag = le16_to_cpu(entry->e_tag);
new_entry++;
}
- return (void *)new_entry - (void *)header;
+ RETURN((void *)new_entry - (void *)header);
}
EXPORT_SYMBOL(nodemap_map_acl);
}
rc = range_insert(&config->nmc_range_tree, range);
- if (rc != 0) {
- CERROR("cannot insert nodemap range into '%s': rc = %d\n",
- nodemap->nm_name, rc);
+ if (rc) {
+ CDEBUG_LIMIT(rc == -EEXIST ? D_INFO : D_ERROR,
+ "cannot insert nodemap range into '%s': rc = %d\n",
+ nodemap->nm_name, rc);
up_write(&config->nmc_range_tree_lock);
list_del(&range->rn_list);
range_destroy(range);
- GOTO(out, rc = -ENOMEM);
+ GOTO(out, rc);
}
list_add(&range->rn_list, &nodemap->nm_ranges);
- nm_member_reclassify_nodemap(config->nmc_default_nodemap);
+
+ /* nodemaps have no members if they aren't on the active config */
+ if (config == active_config)
+ nm_member_reclassify_nodemap(config->nmc_default_nodemap);
+
up_write(&config->nmc_range_tree_lock);
/* if range_id is non-zero, we are loading from disk */
if (range_id == 0)
rc = nodemap_idx_range_add(range, nid);
- nm_member_revoke_locks(config->nmc_default_nodemap);
- nm_member_revoke_locks(nodemap);
+ if (config == active_config) {
+ nm_member_revoke_locks(config->nmc_default_nodemap);
+ nm_member_revoke_locks(nodemap);
+ }
out:
return rc;
}
+
int nodemap_add_range(const char *name, const lnet_nid_t nid[2])
{
struct lu_nodemap *nodemap = NULL;
/**
* delete a range
* \param name nodemap name
- * \param range_str string containing range
+ * \param nid nid range
* \retval 0 on success
*
* Delete range from global range tree, and remove it
up_write(&active_config->nmc_range_tree_lock);
GOTO(out_putref, rc = -EINVAL);
}
+ if (range->rn_nodemap != nodemap) {
+ up_write(&active_config->nmc_range_tree_lock);
+ GOTO(out_putref, rc = -EINVAL);
+ }
rc = nodemap_idx_range_del(range);
range_delete(&active_config->nmc_range_tree, range);
nm_member_reclassify_nodemap(nodemap);
{
int rc = 0;
- /* we allow fileset = "" which means clear fileset info */
- if (fileset == NULL || (fileset[0] != 0 && fileset[0] != '/'))
+ /* Allow 'fileset=clear' in addition to 'fileset=""' to clear fileset
+ * because either command 'lctl set_param -P *.*.fileset=""' or
+ * 'lctl nodemap_set_fileset --fileset ""' can only work correctly
+ * on MGS, while on other servers, both commands will invoke upcall
+ * "/usr/sbin/lctl set_param nodemap.default.fileset=" by function
+ * process_param2_config(), which will cause "no value" error and
+ * won't clear fileset.
+ * 'fileset=""' is still kept for compatibility reason.
+ */
+ if (fileset == NULL)
+ rc = -EINVAL;
+ else if (fileset[0] == '\0' || strcmp(fileset, "clear") == 0)
+ nodemap->nm_fileset[0] = '\0';
+ else if (fileset[0] != '/')
rc = -EINVAL;
else if (strlcpy(nodemap->nm_fileset, fileset,
sizeof(nodemap->nm_fileset)) >=
GOTO(out, rc = PTR_ERR(nodemap));
}
- if (is_default_nodemap(nodemap))
- rc = -EINVAL;
- else
- rc = nodemap_set_fileset_helper(active_config, nodemap,
- fileset);
+ rc = nodemap_set_fileset_helper(active_config, nodemap, fileset);
mutex_unlock(&active_config_lock);
nodemap_putref(nodemap);
*/
char *nodemap_get_fileset(const struct lu_nodemap *nodemap)
{
- if (!nodemap_active || is_default_nodemap(nodemap))
+ if (!nodemap_active)
return NULL;
- else
- return (char *)nodemap->nm_fileset;
+
+ return (char *)nodemap->nm_fileset;
}
EXPORT_SYMBOL(nodemap_get_fileset);
+static int nodemap_validate_sepol(const char *sepol)
+{
+ char buf[LUSTRE_NODEMAP_SEPOL_LENGTH + 1];
+ char *p = (char *)sepol;
+ char *q = buf;
+ char polname[NAME_MAX + 1] = "";
+ char hash[SELINUX_POLICY_HASH_LEN + 1] = "";
+ unsigned char mode;
+ unsigned short ver;
+
+ BUILD_BUG_ON(sizeof(buf) != sizeof(((struct lu_nodemap *)0)->nm_sepol));
+
+ if (sepol == NULL)
+ return -EINVAL;
+
+ /* we allow sepol = "" which means clear SELinux policy info */
+ if (sepol[0] == '\0')
+ return 0;
+
+ /* make a copy of sepol, by replacing ':' with space
+ * so that we can use sscanf over the string
+ */
+ while (p-sepol < sizeof(buf)) {
+ if (*p == ':')
+ *q = ' ';
+ else
+ *q = *p;
+ if (*p == '\0')
+ break;
+ p++;
+ q++;
+ }
+ if (p-sepol == sizeof(buf))
+ return -ENAMETOOLONG;
+
+ if (sscanf(buf, "%1hhu %s %hu %s", &mode, polname, &ver, hash) != 4)
+ return -EINVAL;
+
+ if (mode != 0 && mode != 1)
+ return -EINVAL;
+
+ return 0;
+}
+
+/**
+ * set SELinux policy on nodemap
+ * \param name nodemap to set SELinux policy info on
+ * \param sepol string containing SELinux policy info
+ * \retval 0 on success
+ *
+ * set SELinux policy info on the named nodemap
+ */
+int nodemap_set_sepol(const char *name, const char *sepol)
+{
+ struct lu_nodemap *nodemap = NULL;
+ int rc;
+
+ rc = nodemap_validate_sepol(sepol);
+ if (rc < 0)
+ GOTO(out, rc);
+
+ mutex_lock(&active_config_lock);
+ nodemap = nodemap_lookup(name);
+ if (IS_ERR(nodemap)) {
+ mutex_unlock(&active_config_lock);
+ GOTO(out, rc = PTR_ERR(nodemap));
+ }
+
+ if (is_default_nodemap(nodemap)) {
+ /* We do not want nodes in the default nodemap to have
+ * SELinux restrictions. Sec admin should create dedicated
+ * nodemap entries for this.
+ */
+ GOTO(out_putref, rc = -EINVAL);
+ }
+
+ /* truncation cannot happen, as string length was checked in
+ * nodemap_validate_sepol()
+ */
+ strlcpy(nodemap->nm_sepol, sepol, sizeof(nodemap->nm_sepol));
+
+out_putref:
+ mutex_unlock(&active_config_lock);
+ nodemap_putref(nodemap);
+out:
+ return rc;
+}
+EXPORT_SYMBOL(nodemap_set_sepol);
+
+/**
+ * get SELinux policy info defined on nodemap
+ * \param nodemap nodemap to get SELinux policy info from
+ * \retval SELinux policy info, or NULL if not defined or not activated
+ *
+ * get the SELinux policy info defined on the nodemap
+ */
+const char *nodemap_get_sepol(const struct lu_nodemap *nodemap)
+{
+ if (is_default_nodemap(nodemap))
+ return NULL;
+ else
+ return (char *)nodemap->nm_sepol;
+}
+EXPORT_SYMBOL(nodemap_get_sepol);
+
/**
* Nodemap constructor
*
* Creates an lu_nodemap structure and assigns sane default
* member values. If this is the default nodemap, the defaults
- * are the most restictive in xterms of mapping behavior. Otherwise
+ * are the most restrictive in terms of mapping behavior. Otherwise
* the default flags should be inherited from the default nodemap.
* The adds nodemap to nodemap_hash.
*
struct lu_nodemap *default_nodemap;
struct cfs_hash *hash = config->nmc_nodemap_hash;
int rc = 0;
+ ENTRY;
default_nodemap = config->nmc_default_nodemap;
OBD_ALLOC_PTR(nodemap);
if (nodemap == NULL) {
- CERROR("cannot allocate memory (%zu bytes)"
- "for nodemap '%s'\n", sizeof(*nodemap),
- name);
+ CERROR("cannot allocate memory (%zu bytes) for nodemap '%s'\n",
+ sizeof(*nodemap), name);
GOTO(out, rc = -ENOMEM);
}
INIT_LIST_HEAD(&nodemap->nm_member_list);
mutex_init(&nodemap->nm_member_list_lock);
- rwlock_init(&nodemap->nm_idmap_lock);
+ init_rwsem(&nodemap->nm_idmap_lock);
nodemap->nm_fs_to_client_uidmap = RB_ROOT;
nodemap->nm_client_to_fs_uidmap = RB_ROOT;
nodemap->nm_fs_to_client_gidmap = RB_ROOT;
nodemap->nm_client_to_fs_gidmap = RB_ROOT;
+ nodemap->nm_fs_to_client_projidmap = RB_ROOT;
+ nodemap->nm_client_to_fs_projidmap = RB_ROOT;
if (is_default) {
nodemap->nm_id = LUSTRE_NODEMAP_DEFAULT_ID;
if (is_default || default_nodemap == NULL) {
nodemap->nmf_trust_client_ids = 0;
nodemap->nmf_allow_root_access = 0;
+ nodemap->nmf_deny_unknown = 0;
+ nodemap->nmf_map_mode = NODEMAP_MAP_ALL;
+ nodemap->nmf_enable_audit = 1;
+ nodemap->nmf_forbid_encryption = 0;
+ nodemap->nmf_readonly_mount = 0;
+ nodemap->nmf_rbac = NODEMAP_RBAC_ALL;
nodemap->nm_squash_uid = NODEMAP_NOBODY_UID;
nodemap->nm_squash_gid = NODEMAP_NOBODY_GID;
+ nodemap->nm_squash_projid = NODEMAP_NOBODY_PROJID;
+ nodemap->nm_fileset[0] = '\0';
+ nodemap->nm_sepol[0] = '\0';
if (!is_default)
CWARN("adding nodemap '%s' to config without"
" default nodemap\n", nodemap->nm_name);
default_nodemap->nmf_trust_client_ids;
nodemap->nmf_allow_root_access =
default_nodemap->nmf_allow_root_access;
+ nodemap->nmf_deny_unknown = default_nodemap->nmf_deny_unknown;
+ nodemap->nmf_map_mode = default_nodemap->nmf_map_mode;
+ nodemap->nmf_enable_audit = default_nodemap->nmf_enable_audit;
+ nodemap->nmf_forbid_encryption =
+ default_nodemap->nmf_forbid_encryption;
+ nodemap->nmf_readonly_mount =
+ default_nodemap->nmf_readonly_mount;
+ nodemap->nmf_rbac = default_nodemap->nmf_rbac;
nodemap->nm_squash_uid = default_nodemap->nm_squash_uid;
nodemap->nm_squash_gid = default_nodemap->nm_squash_gid;
- nodemap->nm_fileset[0] = 0;
+ nodemap->nm_squash_projid = default_nodemap->nm_squash_projid;
+ nodemap->nm_fileset[0] = '\0';
+ nodemap->nm_sepol[0] = '\0';
}
- return nodemap;
+ RETURN(nodemap);
out:
CERROR("cannot add nodemap: '%s': rc = %d\n", name, rc);
- return ERR_PTR(rc);
+ RETURN(ERR_PTR(rc));
}
/**
- * update flag to turn on or off nodemap functions
+ * Set the nmf_deny_unknown flag to true or false.
* \param name nodemap name
- * \param admin_string string containing updated value
+ * \param deny_unknown if true, squashed users will get EACCES
+ * \retval 0 on success
+ *
+ */
+int nodemap_set_deny_unknown(const char *name, bool deny_unknown)
+{
+ struct lu_nodemap *nodemap = NULL;
+ int rc = 0;
+
+ mutex_lock(&active_config_lock);
+ nodemap = nodemap_lookup(name);
+ mutex_unlock(&active_config_lock);
+ if (IS_ERR(nodemap))
+ GOTO(out, rc = PTR_ERR(nodemap));
+
+ nodemap->nmf_deny_unknown = deny_unknown;
+ rc = nodemap_idx_nodemap_update(nodemap);
+
+ nm_member_revoke_locks(nodemap);
+ nodemap_putref(nodemap);
+out:
+ return rc;
+}
+EXPORT_SYMBOL(nodemap_set_deny_unknown);
+
+/**
+ * Set the nmf_allow_root_access flag to true or false.
+ * \param name nodemap name
+ * \param allow_root if true, nodemap will not squash the root user
* \retval 0 on success
*
- * Update admin flag to turn on or off nodemap functions.
*/
int nodemap_set_allow_root(const char *name, bool allow_root)
{
EXPORT_SYMBOL(nodemap_set_allow_root);
/**
- * updated trust_client_ids flag for nodemap
+ * Set the nmf_trust_client_ids flag to true or false.
*
- * \param name nodemap name
- * \param trust_string new value for trust flag
+ * \param name nodemap name
+ * \param trust_client_ids if true, nodemap will not map its IDs
* \retval 0 on success
*
- * Update the trust_client_ids flag for a nodemap.
*/
int nodemap_set_trust_client_ids(const char *name, bool trust_client_ids)
{
}
EXPORT_SYMBOL(nodemap_set_trust_client_ids);
+int nodemap_set_mapping_mode(const char *name,
+ enum nodemap_mapping_modes map_mode)
+{
+ struct lu_nodemap *nodemap = NULL;
+ int rc = 0;
+
+ mutex_lock(&active_config_lock);
+ nodemap = nodemap_lookup(name);
+ mutex_unlock(&active_config_lock);
+ if (IS_ERR(nodemap))
+ GOTO(out, rc = PTR_ERR(nodemap));
+
+ nodemap->nmf_map_mode = map_mode;
+ rc = nodemap_idx_nodemap_update(nodemap);
+
+ nm_member_revoke_locks(nodemap);
+ nodemap_putref(nodemap);
+out:
+ return rc;
+}
+EXPORT_SYMBOL(nodemap_set_mapping_mode);
+
+int nodemap_set_rbac(const char *name, enum nodemap_rbac_roles rbac)
+{
+ struct lu_nodemap *nodemap = NULL;
+ enum nodemap_rbac_roles old_rbac;
+ int rc = 0;
+
+ mutex_lock(&active_config_lock);
+ nodemap = nodemap_lookup(name);
+ mutex_unlock(&active_config_lock);
+ if (IS_ERR(nodemap))
+ GOTO(out, rc = PTR_ERR(nodemap));
+
+ if (is_default_nodemap(nodemap))
+ GOTO(put, rc = -EINVAL);
+
+ old_rbac = nodemap->nmf_rbac;
+ /* if value does not change, do nothing */
+ if (rbac == old_rbac)
+ GOTO(put, rc = 0);
+
+ nodemap->nmf_rbac = rbac;
+ if (rbac == NODEMAP_RBAC_ALL)
+ /* if new value is ALL (default), just delete
+ * NODEMAP_CLUSTER_ROLES idx
+ */
+ rc = nodemap_idx_cluster_roles_del(nodemap);
+ else if (old_rbac == NODEMAP_RBAC_ALL)
+ /* if old value is ALL (default), need to insert
+ * NODEMAP_CLUSTER_ROLES idx
+ */
+ rc = nodemap_idx_cluster_roles_add(nodemap);
+ else
+ /* otherwise just update existing NODEMAP_CLUSTER_ROLES idx */
+ rc = nodemap_idx_cluster_roles_update(nodemap);
+
+ nm_member_revoke_locks(nodemap);
+put:
+ nodemap_putref(nodemap);
+out:
+ return rc;
+}
+EXPORT_SYMBOL(nodemap_set_rbac);
+
/**
- * update the squash_uid for a nodemap
+ * Update the squash_uid for a nodemap.
*
* \param name nodemap name
- * \param uid_string string containing new squash_uid value
+ * \param uid the new uid to squash unknown users to
* \retval 0 on success
*
* Update the squash_uid for a nodemap. The squash_uid is the uid
* Update the squash_gid for a nodemap.
*
* \param name nodemap name
- * \param gid_string string containing new squash_gid value
+ * \param gid the new gid to squash unknown gids to
* \retval 0 on success
*
- * Update the squash_gid for a nodemap. The squash_uid is the gid
+ * Update the squash_gid for a nodemap. The squash_gid is the gid
* that the all client gids are mapped to if nodemap is active,
* the trust_client_ids flag is not set, and the gid is not in
* the idmap tree.
EXPORT_SYMBOL(nodemap_set_squash_gid);
/**
- * Returns true if this nodemap has root user access. Always returns true if
- * nodemaps are not active.
+ * Update the squash_projid for a nodemap.
+ *
+ * \param name nodemap name
+ * \param gid the new projid to squash unknown projids to
+ * \retval 0 on success
+ *
+ * Update the squash_projid for a nodemap. The squash_projid is the projid
+ * that the all client projids are mapped to if nodemap is active,
+ * the trust_client_ids flag is not set, and the projid is not in
+ * the idmap tree.
+ */
+int nodemap_set_squash_projid(const char *name, projid_t projid)
+{
+ struct lu_nodemap *nodemap = NULL;
+ int rc = 0;
+
+ mutex_lock(&active_config_lock);
+ nodemap = nodemap_lookup(name);
+ mutex_unlock(&active_config_lock);
+ if (IS_ERR(nodemap))
+ GOTO(out, rc = PTR_ERR(nodemap));
+
+ nodemap->nm_squash_projid = projid;
+ rc = nodemap_idx_nodemap_update(nodemap);
+
+ nm_member_revoke_locks(nodemap);
+ nodemap_putref(nodemap);
+out:
+ return rc;
+}
+EXPORT_SYMBOL(nodemap_set_squash_projid);
+
+/**
+ * Check if nodemap allows setting quota.
+ *
+ * If nodemap is not active, always allow.
+ * For user and group quota, allow if the nodemap allows root access.
+ * For project quota, allow if project id is not squashed or deny_unknown
+ * is not set.
*
* \param nodemap nodemap to check access for
+ * \param qc_type quota type
+ * \param id client id to map
+ * \retval true is setquota is allowed, false otherwise
*/
-bool nodemap_can_setquota(const struct lu_nodemap *nodemap)
+bool nodemap_can_setquota(struct lu_nodemap *nodemap, __u32 qc_type, __u32 id)
{
- return !nodemap_active || (nodemap && nodemap->nmf_allow_root_access);
+ if (!nodemap_active)
+ return true;
+
+ if (!nodemap || !nodemap->nmf_allow_root_access ||
+ !(nodemap->nmf_rbac & NODEMAP_RBAC_QUOTA_OPS))
+ return false;
+
+ if (qc_type == PRJQUOTA) {
+ id = nodemap_map_id(nodemap, NODEMAP_PROJID,
+ NODEMAP_CLIENT_TO_FS, id);
+
+ if (id == nodemap->nm_squash_projid &&
+ nodemap->nmf_deny_unknown)
+ return false;
+ }
+
+ return true;
}
EXPORT_SYMBOL(nodemap_can_setquota);
/**
+ * Set the nmf_enable_audit flag to true or false.
+ * \param name nodemap name
+ * \param audit_mode if true, allow audit
+ * \retval 0 on success
+ *
+ */
+int nodemap_set_audit_mode(const char *name, bool enable_audit)
+{
+ struct lu_nodemap *nodemap = NULL;
+ int rc = 0;
+
+ mutex_lock(&active_config_lock);
+ nodemap = nodemap_lookup(name);
+ mutex_unlock(&active_config_lock);
+ if (IS_ERR(nodemap))
+ GOTO(out, rc = PTR_ERR(nodemap));
+
+ nodemap->nmf_enable_audit = enable_audit;
+ rc = nodemap_idx_nodemap_update(nodemap);
+
+ nm_member_revoke_locks(nodemap);
+ nodemap_putref(nodemap);
+out:
+ return rc;
+}
+EXPORT_SYMBOL(nodemap_set_audit_mode);
+
+/**
+ * Set the nmf_forbid_encryption flag to true or false.
+ * \param name nodemap name
+ * \param forbid_encryption if true, forbid encryption
+ * \retval 0 on success
+ *
+ */
+int nodemap_set_forbid_encryption(const char *name, bool forbid_encryption)
+{
+ struct lu_nodemap *nodemap = NULL;
+ int rc = 0;
+
+ mutex_lock(&active_config_lock);
+ nodemap = nodemap_lookup(name);
+ mutex_unlock(&active_config_lock);
+ if (IS_ERR(nodemap))
+ GOTO(out, rc = PTR_ERR(nodemap));
+
+ nodemap->nmf_forbid_encryption = forbid_encryption;
+ rc = nodemap_idx_nodemap_update(nodemap);
+
+ nm_member_revoke_locks(nodemap);
+ nodemap_putref(nodemap);
+out:
+ return rc;
+}
+EXPORT_SYMBOL(nodemap_set_forbid_encryption);
+
+/**
+ * Set the nmf_readonly_mount flag to true or false.
+ * \param name nodemap name
+ * \param readonly_mount if true, forbid rw mount
+ * \retval 0 on success
+ *
+ */
+int nodemap_set_readonly_mount(const char *name, bool readonly_mount)
+{
+ struct lu_nodemap *nodemap = NULL;
+ int rc = 0;
+
+ mutex_lock(&active_config_lock);
+ nodemap = nodemap_lookup(name);
+ mutex_unlock(&active_config_lock);
+ if (IS_ERR(nodemap))
+ GOTO(out, rc = PTR_ERR(nodemap));
+
+ nodemap->nmf_readonly_mount = readonly_mount;
+ rc = nodemap_idx_nodemap_update(nodemap);
+
+ nm_member_revoke_locks(nodemap);
+ nodemap_putref(nodemap);
+out:
+ return rc;
+}
+EXPORT_SYMBOL(nodemap_set_readonly_mount);
+
+/**
* Add a nodemap
*
* \param name name of nodemap
init_rwsem(&config->nmc_range_tree_lock);
+ config->nmc_range_tree.nmrt_range_interval_root = INTERVAL_TREE_ROOT;
+
return config;
}
EXPORT_SYMBOL(nodemap_config_alloc);
*/
list_for_each_entry_safe(nodemap, nodemap_temp, &nodemap_list_head,
nm_list) {
+ mutex_lock(&active_config_lock);
down_write(&config->nmc_range_tree_lock);
- /* move members to new config */
+ /* move members to new config, requires ac lock */
nm_member_reclassify_nodemap(nodemap);
list_for_each_entry_safe(range, range_temp, &nodemap->nm_ranges,
rn_list)
range_delete(&config->nmc_range_tree, range);
up_write(&config->nmc_range_tree_lock);
+ mutex_unlock(&active_config_lock);
+ /* putref must be outside of ac lock if nm could be destroyed */
nodemap_putref(nodemap);
}
OBD_FREE_PTR(config);
}
EXPORT_SYMBOL(nodemap_config_dealloc);
-static int nm_hash_list_cb(struct cfs_hash *hs, struct cfs_hash_bd *bd,
- struct hlist_node *hnode,
- void *nodemap_list_head)
+/*
+ * callback for cfs_hash_for_each_safe used to convert a nodemap hash to a
+ * nodemap list, generally for locking purposes as a hash cb can't sleep.
+ */
+int nm_hash_list_cb(struct cfs_hash *hs, struct cfs_hash_bd *bd,
+ struct hlist_node *hnode,
+ void *nodemap_list_head)
{
struct lu_nodemap *nodemap;
struct nodemap_config *old_config = active_config;
struct lu_nodemap *nodemap;
struct lu_nodemap *tmp;
+ bool revoke_locks;
LIST_HEAD(nodemap_list_head);
ENTRY;
}
}
+ /*
+ * We only need to revoke locks if old nodemap was active, and new
+ * config is now nodemap inactive. nodemap_config_dealloc will
+ * reclassify exports, triggering a lock revoke if and only if new
+ * nodemap is active.
+ */
+ revoke_locks = !config->nmc_nodemap_is_active && nodemap_active;
+
/* if new config is inactive, deactivate live config before switching */
if (!config->nmc_nodemap_is_active)
nodemap_active = false;
if (old_config != NULL)
nodemap_config_dealloc(old_config);
- nm_member_revoke_all();
+ if (revoke_locks)
+ nm_member_revoke_all();
EXIT;
}
/* revoke_locks sleeps, so can't call in cfs hash cb */
list_for_each_entry_safe(nodemap, tmp, &nodemap_list_head, nm_list)
- nm_member_revoke_locks(nodemap);
+ nm_member_revoke_locks_always(nodemap);
mutex_unlock(&active_config_lock);
}