/**
* @brief Get supplementary groups given uid
*
* @param[in] uid The uid of the user
* @param[out] group_data
*
* @return true if successful, false otherwise
*/
bool uid2grp(uid_t uid, struct group_data **gdata)
{
bool success = false;
PTHREAD_RWLOCK_rdlock(&uid2grp_user_lock);
success = uid2grp_lookup_by_uid(uid, gdata);
/* Handle common case first */
if (success && !uid2grp_expired(*gdata)) {
uid2grp_hold_group_data(*gdata);
PTHREAD_RWLOCK_unlock(&uid2grp_user_lock);
return success;
}
PTHREAD_RWLOCK_unlock(&uid2grp_user_lock);
if (success) {
/* Cache entry is expired */
PTHREAD_RWLOCK_wrlock(&uid2grp_user_lock);
uid2grp_remove_by_uid(uid);
PTHREAD_RWLOCK_unlock(&uid2grp_user_lock);
}
*gdata = uid2grp_allocate_by_uid(uid);
PTHREAD_RWLOCK_wrlock(&uid2grp_user_lock);
if (*gdata)
uid2grp_add_user(*gdata);
success = uid2grp_lookup_by_uid(uid, gdata);
if (success)
uid2grp_hold_group_data(*gdata);
PTHREAD_RWLOCK_unlock(&uid2grp_user_lock);
return success;
}
/**
* @brief Adds a new state to a file
*
* @param[in,out] obj File to operate on
* @param[in] state_type State to be defined
* @param[in] state_data Data related to this state
* @param[in] owner_input Related open_owner
* @param[out] state The new state
* @param[in] refer Reference to compound creating state
*
* @return Operation status
*/
state_status_t state_add(struct fsal_obj_handle *obj,
enum state_type state_type,
union state_data *state_data,
state_owner_t *owner_input,
state_t **state, struct state_refer *refer)
{
state_status_t status = 0;
/* Ensure that states are are associated only with the appropriate
owners */
if (((state_type == STATE_TYPE_SHARE)
&& (owner_input->so_type != STATE_OPEN_OWNER_NFSV4))
|| ((state_type == STATE_TYPE_LOCK)
&& (owner_input->so_type != STATE_LOCK_OWNER_NFSV4))
||
(((state_type == STATE_TYPE_DELEG)
|| (state_type == STATE_TYPE_LAYOUT))
&& (owner_input->so_type != STATE_CLIENTID_OWNER_NFSV4))) {
return STATE_BAD_TYPE;
}
PTHREAD_RWLOCK_wrlock(&obj->state_hdl->state_lock);
status =
state_add_impl(obj, state_type, state_data, owner_input, state,
refer);
PTHREAD_RWLOCK_unlock(&obj->state_hdl->state_lock);
return status;
}
fsal_status_t vfs_close(struct fsal_obj_handle *obj_hdl)
{
struct vfs_fsal_obj_handle *myself;
fsal_status_t status;
assert(obj_hdl->type == REGULAR_FILE);
myself = container_of(obj_hdl, struct vfs_fsal_obj_handle, obj_handle);
if (obj_hdl->fsal != obj_hdl->fs->fsal) {
LogDebug(COMPONENT_FSAL,
"FSAL %s operation for handle belonging to FSAL %s, return EXDEV",
obj_hdl->fsal->name, obj_hdl->fs->fsal->name);
return fsalstat(posix2fsal_error(EXDEV), EXDEV);
}
/* Take write lock on object to protect file descriptor.
* This can block over an I/O operation.
*/
PTHREAD_RWLOCK_wrlock(&obj_hdl->lock);
status = vfs_close_my_fd(&myself->u.file.fd);
PTHREAD_RWLOCK_unlock(&obj_hdl->lock);
return status;
}
fsal_status_t vfs_close2(struct fsal_obj_handle *obj_hdl,
struct state_t *state)
{
struct vfs_fd *my_fd = (struct vfs_fd *)(state + 1);
struct vfs_fsal_obj_handle *myself = NULL;
myself = container_of(obj_hdl,
struct vfs_fsal_obj_handle,
obj_handle);
if (state->state_type == STATE_TYPE_SHARE ||
state->state_type == STATE_TYPE_NLM_SHARE ||
state->state_type == STATE_TYPE_9P_FID) {
/* This is a share state, we must update the share counters */
/* This can block over an I/O operation. */
PTHREAD_RWLOCK_wrlock(&obj_hdl->lock);
update_share_counters(&myself->u.file.share,
my_fd->openflags,
FSAL_O_CLOSED);
PTHREAD_RWLOCK_unlock(&obj_hdl->lock);
}
return vfs_close_my_fd(my_fd);
}
fsal_status_t vfs_merge(struct fsal_obj_handle *orig_hdl,
struct fsal_obj_handle *dupe_hdl)
{
fsal_status_t status = {ERR_FSAL_NO_ERROR, 0};
if (orig_hdl->type == REGULAR_FILE &&
dupe_hdl->type == REGULAR_FILE) {
/* We need to merge the share reservations on this file.
* This could result in ERR_FSAL_SHARE_DENIED.
*/
struct vfs_fsal_obj_handle *orig, *dupe;
orig = container_of(orig_hdl,
struct vfs_fsal_obj_handle,
obj_handle);
dupe = container_of(dupe_hdl,
struct vfs_fsal_obj_handle,
obj_handle);
/* This can block over an I/O operation. */
PTHREAD_RWLOCK_wrlock(&orig_hdl->lock);
status = merge_share(&orig->u.file.share, &dupe->u.file.share);
PTHREAD_RWLOCK_unlock(&orig_hdl->lock);
}
return status;
}
static inline void
src_dest_lock(cache_entry_t *src, cache_entry_t *dest)
{
if (src == dest)
PTHREAD_RWLOCK_wrlock(&src->content_lock);
else {
if (src < dest) {
PTHREAD_RWLOCK_wrlock(&src->content_lock);
PTHREAD_RWLOCK_wrlock(&dest->content_lock);
} else {
PTHREAD_RWLOCK_wrlock(&dest->content_lock);
PTHREAD_RWLOCK_wrlock(&src->content_lock);
}
}
}
void nfs4_fs_locations_get_ref(fsal_fs_locations_t *fs_locations)
{
PTHREAD_RWLOCK_wrlock(&fs_locations->lock);
fs_locations->ref++;
LogFullDebug(COMPONENT_NFS_V4, "(fs_locations, ref) = (%p, %u)",
fs_locations, fs_locations->ref);
PTHREAD_RWLOCK_unlock(&fs_locations->lock);
}
void nfs4_acl_entry_inc_ref(fsal_acl_t *acl)
{
/* Increase ref counter */
PTHREAD_RWLOCK_wrlock(&acl->lock);
acl->ref++;
LogDebug(COMPONENT_NFS_V4_ACL, "(acl, ref) = (%p, %u)", acl, acl->ref);
PTHREAD_RWLOCK_unlock(&acl->lock);
}
/**
* @brief Remove and free all (key,val) couples from the hash store
*
* This function removes all (key,val) couples from the hashtable and
* frees the stored data using the supplied function
*
* @param[in,out] ht The hashtable to be cleared of all entries
* @param[in] free_func The function with which to free the contents
* of each entry
*
* @return HASHTABLE_SUCCESS or errors
*/
hash_error_t
hashtable_delall(struct hash_table *ht,
int (*free_func)(struct gsh_buffdesc,
struct gsh_buffdesc))
{
/* Successive partition numbers */
uint32_t index = 0;
for (index = 0; index < ht->parameter.index_size; index++) {
/* The root of each successive partition */
struct rbt_head *root = &ht->partitions[index].rbt;
/* Pointer to node in tree for removal */
struct rbt_node *cursor = NULL;
PTHREAD_RWLOCK_wrlock(&ht->partitions[index].lock);
/* Continue until there are no more entries in the red-black
tree */
while ((cursor = RBT_LEFTMOST(root)) != NULL) {
/* Pointer to the key and value descriptors
for each successive entry */
struct hash_data *data = NULL;
/* Aliased poitner to node, for freeing
buffers after removal from tree */
struct rbt_node *holder = cursor;
/* Buffer descriptor for key, as stored */
struct gsh_buffdesc key;
/* Buffer descriptor for value, as stored */
struct gsh_buffdesc val;
/* Return code from the free function. Zero
on failure */
int rc = 0;
RBT_UNLINK(root, cursor);
data = RBT_OPAQ(holder);
key = data->key;
val = data->val;
pool_free(ht->data_pool, data);
pool_free(ht->node_pool, holder);
--ht->partitions[index].count;
rc = free_func(key, val);
if (rc == 0) {
PTHREAD_RWLOCK_unlock(&ht->partitions[index].
lock);
return HASHTABLE_ERROR_DELALL_FAIL;
}
}
PTHREAD_RWLOCK_unlock(&ht->partitions[index].lock);
}
return HASHTABLE_SUCCESS;
}
cache_inode_status_t
cache_inode_readlink(cache_entry_t *entry,
struct gsh_buffdesc *link_content)
{
cache_inode_status_t status = CACHE_INODE_SUCCESS;
fsal_status_t fsal_status = { ERR_FSAL_NO_ERROR, 0 };
bool refresh = false;
if (entry->type != SYMBOLIC_LINK) {
status = CACHE_INODE_BAD_TYPE;
return status;
}
PTHREAD_RWLOCK_rdlock(&entry->content_lock);
if (!(entry->flags & CACHE_INODE_TRUST_CONTENT)) {
/* Our data are stale. Drop the lock, get a
write-lock, load in new data, and copy it out to
the caller. */
PTHREAD_RWLOCK_unlock(&entry->content_lock);
PTHREAD_RWLOCK_wrlock(&entry->content_lock);
/* Make sure nobody updated the content while we were
waiting. */
refresh = !(entry->flags & CACHE_INODE_TRUST_CONTENT);
}
fsal_status =
entry->obj_handle->ops->readlink(entry->obj_handle,
link_content, refresh);
if (refresh && !(FSAL_IS_ERROR(fsal_status)))
atomic_set_uint32_t_bits(&entry->flags,
CACHE_INODE_TRUST_CONTENT);
PTHREAD_RWLOCK_unlock(&entry->content_lock);
if (FSAL_IS_ERROR(fsal_status)) {
status = cache_inode_error_convert(fsal_status);
if (fsal_status.major == ERR_FSAL_STALE) {
LogEvent(COMPONENT_CACHE_INODE,
"FSAL returned STALE from readlink");
cache_inode_kill_entry(entry);
}
return status;
}
return status;
}
void nfs4_fs_locations_release(fsal_fs_locations_t *fs_locations)
{
if (fs_locations == NULL)
return;
PTHREAD_RWLOCK_wrlock(&fs_locations->lock);
if (fs_locations->ref > 1) {
nfs4_fs_locations_put_ref(fs_locations);
PTHREAD_RWLOCK_unlock(&fs_locations->lock);
return;
} else {
LogFullDebug(COMPONENT_NFS_V4, "Free fs_locations: %p",
fs_locations);
}
PTHREAD_RWLOCK_unlock(&fs_locations->lock);
// Releasing fs_locations
nfs4_fs_locations_free(fs_locations);
}
fsal_status_t vfs_open(struct fsal_obj_handle *obj_hdl,
fsal_openflags_t openflags)
{
struct vfs_fsal_obj_handle *myself;
int fd;
fsal_errors_t fsal_error = ERR_FSAL_NO_ERROR;
int posix_flags = 0;
int retval = 0;
myself = container_of(obj_hdl, struct vfs_fsal_obj_handle, obj_handle);
if (obj_hdl->fsal != obj_hdl->fs->fsal) {
LogDebug(COMPONENT_FSAL,
"FSAL %s operation for handle belonging to FSAL %s, return EXDEV",
obj_hdl->fsal->name, obj_hdl->fs->fsal->name);
retval = EXDEV;
fsal_error = posix2fsal_error(retval);
return fsalstat(fsal_error, retval);
}
/* Take write lock on object to protect file descriptor. */
PTHREAD_RWLOCK_wrlock(&obj_hdl->lock);
assert(myself->u.file.fd == -1
&& myself->u.file.openflags == FSAL_O_CLOSED && openflags != 0);
fsal2posix_openflags(openflags, &posix_flags);
LogFullDebug(COMPONENT_FSAL, "open_by_handle_at flags from %x to %x",
openflags, posix_flags);
fd = vfs_fsal_open(myself, posix_flags, &fsal_error);
if (fd < 0) {
retval = -fd;
} else {
myself->u.file.fd = fd;
myself->u.file.openflags = openflags;
}
PTHREAD_RWLOCK_unlock(&obj_hdl->lock);
return fsalstat(fsal_error, retval);
}
static bool nfs_rpc_cbsim_get_v40_client_ids(DBusMessageIter *args,
DBusMessage *reply)
{
uint32_t i;
hash_table_t *ht = ht_confirmed_client_id;
struct rbt_head *head_rbt;
struct hash_data *pdata = NULL;
struct rbt_node *pn;
nfs_client_id_t *pclientid;
uint64_t clientid;
DBusMessageIter iter, sub_iter;
struct timespec ts;
/* create a reply from the message */
now(&ts);
dbus_message_iter_init_append(reply, &iter);
dbus_append_timestamp(&iter, &ts);
dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
DBUS_TYPE_UINT64_AS_STRING, &sub_iter);
/* For each bucket of the hashtable */
for (i = 0; i < ht->parameter.index_size; i++) {
head_rbt = &(ht->partitions[i].rbt);
/* acquire mutex */
PTHREAD_RWLOCK_wrlock(&(ht->partitions[i].lock));
/* go through all entries in the red-black-tree */
RBT_LOOP(head_rbt, pn) {
pdata = RBT_OPAQ(pn);
pclientid = pdata->val.addr;
clientid = pclientid->cid_clientid;
dbus_message_iter_append_basic(&sub_iter,
DBUS_TYPE_UINT64,
&clientid);
RBT_INCREMENT(pn);
}
PTHREAD_RWLOCK_unlock(&(ht->partitions[i].lock));
}
fsal_status_t vfs_close(struct fsal_obj_handle *obj_hdl)
{
struct vfs_fsal_obj_handle *myself;
fsal_errors_t fsal_error = ERR_FSAL_NO_ERROR;
int retval = 0;
assert(obj_hdl->type == REGULAR_FILE);
myself = container_of(obj_hdl, struct vfs_fsal_obj_handle, obj_handle);
if (obj_hdl->fsal != obj_hdl->fs->fsal) {
LogDebug(COMPONENT_FSAL,
"FSAL %s operation for handle belonging to FSAL %s, return EXDEV",
obj_hdl->fsal->name, obj_hdl->fs->fsal->name);
retval = EXDEV;
fsal_error = posix2fsal_error(retval);
return fsalstat(fsal_error, retval);
}
/* Take write lock on object to protect file descriptor. */
PTHREAD_RWLOCK_wrlock(&obj_hdl->lock);
if (myself->u.file.fd >= 0 &&
myself->u.file.openflags != FSAL_O_CLOSED) {
retval = close(myself->u.file.fd);
if (retval < 0) {
retval = errno;
fsal_error = posix2fsal_error(retval);
}
myself->u.file.fd = -1;
myself->u.file.openflags = FSAL_O_CLOSED;
}
PTHREAD_RWLOCK_unlock(&obj_hdl->lock);
return fsalstat(fsal_error, retval);
}
cache_inode_status_t
cache_inode_create(cache_entry_t *parent,
const char *name,
object_file_type_t type,
uint32_t mode,
cache_inode_create_arg_t *create_arg,
struct req_op_context *req_ctx,
cache_entry_t **entry)
{
cache_inode_status_t status = CACHE_INODE_SUCCESS;
fsal_status_t fsal_status = {0, 0};
struct fsal_obj_handle *object_handle;
struct attrlist object_attributes;
struct fsal_obj_handle *dir_handle;
cache_inode_create_arg_t zero_create_arg;
fsal_accessflags_t access_mask = 0;
memset(&zero_create_arg, 0, sizeof(zero_create_arg));
memset(&object_attributes, 0, sizeof(object_attributes));
if (create_arg == NULL) {
create_arg = &zero_create_arg;
}
if ((type != REGULAR_FILE) && (type != DIRECTORY) &&
(type != SYMBOLIC_LINK) && (type != SOCKET_FILE) &&
(type != FIFO_FILE) && (type != CHARACTER_FILE) &&
(type != BLOCK_FILE)) {
status = CACHE_INODE_BAD_TYPE;
*entry = NULL;
goto out;
}
/*
* Check if caller is allowed to perform the operation
*/
access_mask = FSAL_MODE_MASK_SET(FSAL_W_OK) |
FSAL_ACE4_MASK_SET(FSAL_ACE_PERM_ADD_FILE |
FSAL_ACE_PERM_ADD_SUBDIRECTORY);
status = cache_inode_access(parent,
access_mask,
req_ctx);
if (status != CACHE_INODE_SUCCESS)
{
*entry = NULL;
goto out;
}
/* Try to create it first */
dir_handle = parent->obj_handle;
/* we pass in attributes to the create. We will get them back below */
FSAL_SET_MASK(object_attributes.mask, ATTR_MODE|ATTR_OWNER|ATTR_GROUP);
object_attributes.owner = req_ctx->creds->caller_uid;
object_attributes.group = req_ctx->creds->caller_gid; /* be more selective? */
object_attributes.mode = mode;
switch (type) {
case REGULAR_FILE:
fsal_status = dir_handle->ops->create(dir_handle, req_ctx,
name,
&object_attributes,
&object_handle);
break;
case DIRECTORY:
fsal_status = dir_handle->ops->mkdir(dir_handle, req_ctx,
name,
&object_attributes,
&object_handle);
break;
case SYMBOLIC_LINK:
fsal_status = dir_handle->ops->symlink(dir_handle, req_ctx,
name,
create_arg->link_content,
&object_attributes,
&object_handle);
break;
case SOCKET_FILE:
case FIFO_FILE:
fsal_status = dir_handle->ops->mknode(dir_handle, req_ctx,
name,
type,
NULL, /* no dev_t needed */
&object_attributes,
&object_handle);
break;
case BLOCK_FILE:
case CHARACTER_FILE:
fsal_status = dir_handle->ops->mknode(dir_handle, req_ctx,
name,
type,
&create_arg->dev_spec,
&object_attributes,
&object_handle);
break;
default:
/* we should never go there */
status = CACHE_INODE_INCONSISTENT_ENTRY;
*entry = NULL;
goto out;
break;
}
cache_inode_refresh_attrs_locked(parent, req_ctx);
/* Check for the result */
if (FSAL_IS_ERROR(fsal_status)) {
if (fsal_status.major == ERR_FSAL_STALE) {
LogEvent(COMPONENT_CACHE_INODE,
"FSAL returned STALE on create type %d", type);
cache_inode_kill_entry(parent);
} else if (fsal_status.major == ERR_FSAL_EXIST) {
/* Already exists. Check if type if correct */
status = cache_inode_lookup(parent,
name,
req_ctx,
entry);
if (*entry != NULL) {
status = CACHE_INODE_ENTRY_EXISTS;
if ((*entry)->type != type) {
/* Incompatible types, returns NULL */
cache_inode_put(*entry);
*entry = NULL;
}
goto out;
}
if (status == CACHE_INODE_NOT_FOUND) {
/* Too bad, FSAL insist the file exists when we try to
* create it, but lookup couldn't find it, retry. */
status = CACHE_INODE_INCONSISTENT_ENTRY;
goto out;
}
}
status = cache_inode_error_convert(fsal_status);
*entry = NULL;
goto out;
}
status = cache_inode_new_entry(object_handle,
CACHE_INODE_FLAG_CREATE,
entry);
if (*entry == NULL) {
goto out;
}
PTHREAD_RWLOCK_wrlock(&parent->content_lock);
/* Add this entry to the directory (also takes an internal ref) */
status = cache_inode_add_cached_dirent(parent,
name,
*entry,
NULL);
PTHREAD_RWLOCK_unlock(&parent->content_lock);
if (status != CACHE_INODE_SUCCESS) {
cache_inode_put(*entry);
*entry = NULL;
goto out;
}
out:
return status;
}
fsal_status_t vfs_open2(struct fsal_obj_handle *obj_hdl,
struct state_t *state,
fsal_openflags_t openflags,
enum fsal_create_mode createmode,
const char *name,
struct attrlist *attrib_set,
fsal_verifier_t verifier,
struct fsal_obj_handle **new_obj,
struct attrlist *attrs_out,
bool *caller_perm_check)
{
int posix_flags = 0;
int fd, dir_fd;
int retval = 0;
mode_t unix_mode;
fsal_status_t status = {0, 0};
struct vfs_fd *my_fd = NULL;
struct vfs_fsal_obj_handle *myself, *hdl = NULL;
struct stat stat;
vfs_file_handle_t *fh = NULL;
bool truncated;
bool created = false;
if (state != NULL)
my_fd = (struct vfs_fd *)(state + 1);
myself = container_of(obj_hdl, struct vfs_fsal_obj_handle, obj_handle);
LogAttrlist(COMPONENT_FSAL, NIV_FULL_DEBUG,
"attrib_set ", attrib_set, false);
fsal2posix_openflags(openflags, &posix_flags);
truncated = (posix_flags & O_TRUNC) != 0;
LogFullDebug(COMPONENT_FSAL,
truncated ? "Truncate" : "No truncate");
if (createmode >= FSAL_EXCLUSIVE) {
/* Now fixup attrs for verifier if exclusive create */
set_common_verifier(attrib_set, verifier);
}
if (name == NULL) {
/* This is an open by handle */
struct vfs_fsal_obj_handle *myself;
myself = container_of(obj_hdl,
struct vfs_fsal_obj_handle,
obj_handle);
if (obj_hdl->fsal != obj_hdl->fs->fsal) {
LogDebug(COMPONENT_FSAL,
"FSAL %s operation for handle belonging to FSAL %s, return EXDEV",
obj_hdl->fsal->name, obj_hdl->fs->fsal->name);
return fsalstat(posix2fsal_error(EXDEV), EXDEV);
}
if (state != NULL) {
/* Prepare to take the share reservation, but only if we
* are called with a valid state (if state is NULL the
* caller is a stateless create such as NFS v3 CREATE).
*/
/* This can block over an I/O operation. */
PTHREAD_RWLOCK_wrlock(&obj_hdl->lock);
/* Check share reservation conflicts. */
status = check_share_conflict(&myself->u.file.share,
openflags,
false);
if (FSAL_IS_ERROR(status)) {
PTHREAD_RWLOCK_unlock(&obj_hdl->lock);
return status;
}
/* Take the share reservation now by updating the
* counters.
*/
update_share_counters(&myself->u.file.share,
FSAL_O_CLOSED,
openflags);
PTHREAD_RWLOCK_unlock(&obj_hdl->lock);
} else {
/* We need to use the global fd to continue, and take
* the lock to protect it.
*/
my_fd = &hdl->u.file.fd;
PTHREAD_RWLOCK_wrlock(&obj_hdl->lock);
}
status = vfs_open_my_fd(myself, openflags, posix_flags, my_fd);
if (FSAL_IS_ERROR(status)) {
if (state == NULL) {
/* Release the lock taken above, and return
* since there is nothing to undo.
*/
PTHREAD_RWLOCK_unlock(&obj_hdl->lock);
return status;
} else {
/* Error - need to release the share */
goto undo_share;
}
}
if (createmode >= FSAL_EXCLUSIVE || truncated) {
/* Refresh the attributes */
struct stat stat;
retval = fstat(my_fd->fd, &stat);
if (retval == 0) {
LogFullDebug(COMPONENT_FSAL,
"New size = %" PRIx64,
stat.st_size);
} else {
if (errno == EBADF)
errno = ESTALE;
status = fsalstat(posix2fsal_error(errno),
errno);
}
/* Now check verifier for exclusive, but not for
* FSAL_EXCLUSIVE_9P.
*/
if (!FSAL_IS_ERROR(status) &&
createmode >= FSAL_EXCLUSIVE &&
createmode != FSAL_EXCLUSIVE_9P &&
!check_verifier_stat(&stat, verifier)) {
/* Verifier didn't match, return EEXIST */
status =
fsalstat(posix2fsal_error(EEXIST), EEXIST);
}
}
if (state == NULL) {
/* If no state, release the lock taken above and return
* status.
*/
PTHREAD_RWLOCK_unlock(&obj_hdl->lock);
return status;
}
if (!FSAL_IS_ERROR(status)) {
/* Return success. */
return status;
}
(void) vfs_close_my_fd(my_fd);
undo_share:
/* Can only get here with state not NULL and an error */
/* On error we need to release our share reservation
* and undo the update of the share counters.
* This can block over an I/O operation.
*/
PTHREAD_RWLOCK_wrlock(&obj_hdl->lock);
update_share_counters(&myself->u.file.share,
openflags,
FSAL_O_CLOSED);
PTHREAD_RWLOCK_unlock(&obj_hdl->lock);
return status;
}
/* In this path where we are opening by name, we can't check share
* reservation yet since we don't have an object_handle yet. If we
* indeed create the object handle (there is no race with another
* open by name), then there CAN NOT be a share conflict, otherwise
* the share conflict will be resolved when the object handles are
* merged.
*/
#ifdef ENABLE_VFS_DEBUG_ACL
if (createmode != FSAL_NO_CREATE) {
/* Need to ammend attributes for inherited ACL, these will be
* set later. We also need to test for permission to create
* since there might be an ACL.
*/
struct attrlist attrs;
fsal_accessflags_t access_type;
access_type = FSAL_MODE_MASK_SET(FSAL_W_OK) |
FSAL_ACE4_MASK_SET(FSAL_ACE_PERM_ADD_FILE);
status = obj_hdl->obj_ops.test_access(obj_hdl, access_type,
NULL, NULL, false);
if (FSAL_IS_ERROR(status))
return status;
fsal_prepare_attrs(&attrs, ATTR_ACL);
status = obj_hdl->obj_ops.getattrs(obj_hdl, &attrs);
if (FSAL_IS_ERROR(status))
return status;
status.major = fsal_inherit_acls(attrib_set, attrs.acl,
FSAL_ACE_FLAG_FILE_INHERIT);
/* Done with the attrs */
fsal_release_attrs(&attrs);
if (FSAL_IS_ERROR(status))
return status;
}
#endif /* ENABLE_VFS_DEBUG_ACL */
if (createmode != FSAL_NO_CREATE) {
/* Now add in O_CREAT and O_EXCL. */
posix_flags |= O_CREAT;
/* And if we are at least FSAL_GUARDED, do an O_EXCL create. */
if (createmode >= FSAL_GUARDED)
posix_flags |= O_EXCL;
/* Fetch the mode attribute to use in the openat system call. */
unix_mode = fsal2unix_mode(attrib_set->mode) &
~op_ctx->fsal_export->exp_ops.fs_umask(op_ctx->fsal_export);
/* Don't set the mode if we later set the attributes */
FSAL_UNSET_MASK(attrib_set->mask, ATTR_MODE);
}
if (createmode == FSAL_UNCHECKED && (attrib_set->mask != 0)) {
/* If we have FSAL_UNCHECKED and want to set more attributes
* than the mode, we attempt an O_EXCL create first, if that
* succeeds, then we will be allowed to set the additional
* attributes, otherwise, we don't know we created the file
* and this can NOT set the attributes.
*/
posix_flags |= O_EXCL;
}
dir_fd = vfs_fsal_open(myself, O_PATH | O_NOACCESS, &status.major);
if (dir_fd < 0)
return fsalstat(status.major, -dir_fd);
/** @todo: not sure what this accomplishes... */
retval = vfs_stat_by_handle(dir_fd, &stat);
if (retval < 0) {
retval = errno;
status = fsalstat(posix2fsal_error(retval), retval);
goto direrr;
}
/* Become the user because we are creating an object in this dir.
*/
if (createmode != FSAL_NO_CREATE)
fsal_set_credentials(op_ctx->creds);
if ((posix_flags & O_CREAT) != 0)
fd = openat(dir_fd, name, posix_flags, unix_mode);
else
fd = openat(dir_fd, name, posix_flags);
if (fd == -1 && errno == EEXIST && createmode == FSAL_UNCHECKED) {
/* We tried to create O_EXCL to set attributes and failed.
* Remove O_EXCL and retry. We still try O_CREAT again just in
* case file disappears out from under us.
*
* Note that because we have dropped O_EXCL, later on we will
* not assume we created the file, and thus will not set
* additional attributes. We don't need to separately track
* the condition of not wanting to set attributes.
*/
posix_flags &= ~O_EXCL;
fd = openat(dir_fd, name, posix_flags, unix_mode);
}
/* Preserve errno */
retval = errno;
/* If we were creating, restore credentials now. */
if (createmode != FSAL_NO_CREATE)
fsal_restore_ganesha_credentials();
if (fd < 0) {
status = fsalstat(posix2fsal_error(retval), retval);
goto direrr;
}
/* Remember if we were responsible for creating the file.
* Note that in an UNCHECKED retry we MIGHT have re-created the
* file and won't remember that. Oh well, so in that rare case we
* leak a partially created file if we have a subsequent error in here.
* Also notify caller to do permission check if we DID NOT create the
* file. Note it IS possible in the case of a race between an UNCHECKED
* open and an external unlink, we did create the file, but we will
* still force a permission check. Of course that permission check
* SHOULD succeed since we also won't set the mode the caller requested
* and the default file create permissions SHOULD allow the owner
* read/write.
*/
created = (posix_flags & O_EXCL) != 0;
*caller_perm_check = !created;
vfs_alloc_handle(fh);
retval = vfs_name_to_handle(dir_fd, obj_hdl->fs, name, fh);
if (retval < 0) {
retval = errno;
status = fsalstat(posix2fsal_error(retval), retval);
goto fileerr;
}
retval = fstat(fd, &stat);
if (retval < 0) {
retval = errno;
status = fsalstat(posix2fsal_error(retval), retval);
goto fileerr;
}
/* allocate an obj_handle and fill it up */
hdl = alloc_handle(dir_fd, fh, obj_hdl->fs, &stat, myself->handle, name,
op_ctx->fsal_export);
if (hdl == NULL) {
status = fsalstat(posix2fsal_error(ENOMEM), ENOMEM);
goto fileerr;
}
/* If we didn't have a state above, use the global fd. At this point,
* since we just created the global fd, no one else can have a
* reference to it, and thus we can mamnipulate unlocked which is
* handy since we can then call setattr2 which WILL take the lock
* without a double locking deadlock.
*/
if (my_fd == NULL)
my_fd = &hdl->u.file.fd;
my_fd->fd = fd;
my_fd->openflags = openflags;
*new_obj = &hdl->obj_handle;
if (created && attrib_set->mask != 0) {
/* Set attributes using our newly opened file descriptor as the
* share_fd if there are any left to set (mode and truncate
* have already been handled).
*
* Note that we only set the attributes if we were responsible
* for creating the file and we have attributes to set.
*
* Note if we have ENABLE_VFS_DEBUG_ACL an inherited ACL might
* be part of the attributes we are setting here.
*/
status = (*new_obj)->obj_ops.setattr2(*new_obj,
false,
state,
attrib_set);
if (FSAL_IS_ERROR(status)) {
/* Release the handle we just allocated. */
(*new_obj)->obj_ops.release(*new_obj);
*new_obj = NULL;
goto fileerr;
}
if (attrs_out != NULL) {
status = (*new_obj)->obj_ops.getattrs(*new_obj,
attrs_out);
if (FSAL_IS_ERROR(status) &&
(attrs_out->mask & ATTR_RDATTR_ERR) == 0) {
/* Get attributes failed and caller expected
* to get the attributes. Otherwise continue
* with attrs_out indicating ATTR_RDATTR_ERR.
*/
goto fileerr;
}
}
} else if (attrs_out != NULL) {
/* Since we haven't set any attributes other than what was set
* on create (if we even created), just use the stat results
* we used to create the fsal_obj_handle.
*/
posix2fsal_attributes(&stat, attrs_out);
/* Make sure ATTR_RDATTR_ERR is cleared on success. */
attrs_out->mask &= ~ATTR_RDATTR_ERR;
}
close(dir_fd);
if (state != NULL) {
/* Prepare to take the share reservation, but only if we are
* called with a valid state (if state is NULL the caller is
* a stateless create such as NFS v3 CREATE).
*/
/* This can block over an I/O operation. */
PTHREAD_RWLOCK_wrlock(&(*new_obj)->lock);
/* Take the share reservation now by updating the counters. */
update_share_counters(&hdl->u.file.share,
FSAL_O_CLOSED,
openflags);
PTHREAD_RWLOCK_unlock(&(*new_obj)->lock);
}
return fsalstat(ERR_FSAL_NO_ERROR, 0);
fileerr:
close(fd);
/* Delete the file if we actually created it. */
if (created)
unlinkat(dir_fd, name, 0);
direrr:
close(dir_fd);
return fsalstat(posix2fsal_error(retval), retval);
}
fsal_status_t vfs_reopen2(struct fsal_obj_handle *obj_hdl,
struct state_t *state,
fsal_openflags_t openflags)
{
struct vfs_fd fd, *my_fd = &fd, *my_share_fd;
struct vfs_fsal_obj_handle *myself;
fsal_status_t status = {0, 0};
int posix_flags = 0;
fsal_openflags_t old_openflags;
my_share_fd = (struct vfs_fd *)(state + 1);
fsal2posix_openflags(openflags, &posix_flags);
LogFullDebug(COMPONENT_FSAL,
posix_flags & O_TRUNC ? "Truncate" : "No truncate");
memset(my_fd, 0, sizeof(*my_fd));
fd.fd = -1;
myself = container_of(obj_hdl,
struct vfs_fsal_obj_handle,
obj_handle);
if (obj_hdl->fsal != obj_hdl->fs->fsal) {
LogDebug(COMPONENT_FSAL,
"FSAL %s operation for handle belonging to FSAL %s, return EXDEV",
obj_hdl->fsal->name, obj_hdl->fs->fsal->name);
return fsalstat(posix2fsal_error(EXDEV), EXDEV);
}
/* This can block over an I/O operation. */
PTHREAD_RWLOCK_wrlock(&obj_hdl->lock);
old_openflags = my_share_fd->openflags;
/* We can conflict with old share, so go ahead and check now. */
status = check_share_conflict(&myself->u.file.share, openflags, false);
if (FSAL_IS_ERROR(status)) {
PTHREAD_RWLOCK_unlock(&obj_hdl->lock);
return status;
}
/* Set up the new share so we can drop the lock and not have a
* conflicting share be asserted, updating the share counters.
*/
update_share_counters(&myself->u.file.share, old_openflags, openflags);
PTHREAD_RWLOCK_unlock(&obj_hdl->lock);
status = vfs_open_my_fd(myself, openflags, posix_flags, my_fd);
if (!FSAL_IS_ERROR(status)) {
/* Close the existing file descriptor and copy the new
* one over.
*/
vfs_close_my_fd(my_share_fd);
*my_share_fd = fd;
} else {
/* We had a failure on open - we need to revert the share.
* This can block over an I/O operation.
*/
PTHREAD_RWLOCK_wrlock(&obj_hdl->lock);
update_share_counters(&myself->u.file.share,
openflags,
old_openflags);
PTHREAD_RWLOCK_unlock(&obj_hdl->lock);
}
return status;
}
static nfsstat4 nfs4_do_open_downgrade(struct nfs_argop4 *op,
compound_data_t *data,
state_owner_t *owner, state_t *state,
char **cause)
{
state_status_t state_status;
OPEN_DOWNGRADE4args *args = &op->nfs_argop4_u.opopen_downgrade;
fsal_status_t fsal_status;
fsal_openflags_t openflags = 0;
LogFullDebug(COMPONENT_STATE,
"Open downgrade current access=%x deny=%x access_prev=%x deny_prev=%x",
state->state_data.share.share_access,
state->state_data.share.share_deny,
state->state_data.share.share_access_prev,
state->state_data.share.share_deny_prev);
LogFullDebug(COMPONENT_STATE,
"Open downgrade to access=%x deny=%x",
args->share_access,
args->share_deny);
PTHREAD_RWLOCK_wrlock(&data->current_obj->state_hdl->state_lock);
/* Check if given share access is subset of current share access */
if ((state->state_data.share.share_access & args->share_access) !=
(args->share_access)) {
/* Open share access is not a superset of
* downgrade share access
*/
*cause = " (invalid share access for downgrade)";
PTHREAD_RWLOCK_unlock(
&data->current_obj->state_hdl->state_lock);
return NFS4ERR_INVAL;
}
/* Check if given share deny is subset of current share deny */
if ((state->state_data.share.share_deny & args->share_deny) !=
(args->share_deny)) {
/* Open share deny is not a superset of
* downgrade share deny
*/
*cause = " (invalid share deny for downgrade)";
PTHREAD_RWLOCK_unlock(
&data->current_obj->state_hdl->state_lock);
return NFS4ERR_INVAL;
}
/* Check if given share access is previously seen */
if (((state->state_data.share.share_access_prev &
(1 << args->share_access)) == 0) ||
((state->state_data.share.share_deny_prev &
(1 << args->share_deny)) == 0)) {
*cause = " (share access or deny never seen before)";
PTHREAD_RWLOCK_unlock(
&data->current_obj->state_hdl->state_lock);
return NFS4ERR_INVAL;
}
if ((args->share_access & OPEN4_SHARE_ACCESS_READ) != 0)
openflags |= FSAL_O_READ;
if ((args->share_access & OPEN4_SHARE_ACCESS_WRITE) != 0)
openflags |= FSAL_O_WRITE;
if ((args->share_deny & OPEN4_SHARE_DENY_READ) != 0)
openflags |= FSAL_O_DENY_READ;
if ((args->share_deny & OPEN4_SHARE_DENY_WRITE) != 0)
openflags |= FSAL_O_DENY_WRITE_MAND;
fsal_status = fsal_reopen2(data->current_obj,
state,
openflags,
true);
state_status = state_error_convert(fsal_status);
PTHREAD_RWLOCK_unlock(&data->current_obj->state_hdl->state_lock);
if (state_status != STATE_SUCCESS) {
*cause = " (state_share_downgrade failed)";
return NFS4ERR_SERVERFAULT;
}
return NFS4_OK;
}
/**
* @brief Copy file content.
*
* @param[in] src_entry File to copy from
* @param[in] src_offset Offset start from the source file
* @param[in] dst_entry Destination file to copy to
* @param[in] dst_offset Offset in the dest file
* @param[out] count Requested bytes to copy
* @param[out] copied Bytes successfully copied
*
* @return CACHE_INODE_SUCCESS or various errors
*/
cache_inode_status_t cache_inode_copy(cache_entry_t *src_entry,
uint64_t src_offset,
cache_entry_t *dst_entry,
uint64_t dst_offset, uint64_t count,
uint64_t *copied)
{
fsal_status_t fsal_status = { 0, 0 };
cache_inode_status_t status;
/**
* To avoid deadlock, we always lock the entry with a smaller address
* before the locking the other entry. Note that "content_lock"
* protects "cache content" instead of file content. So only reader
* lock is needed for either file.
*/
if ((size_t)src_entry < (size_t)dst_entry) {
PTHREAD_RWLOCK_rdlock(&src_entry->content_lock);
PTHREAD_RWLOCK_rdlock(&dst_entry->content_lock);
} else {
PTHREAD_RWLOCK_rdlock(&dst_entry->content_lock);
PTHREAD_RWLOCK_rdlock(&src_entry->content_lock);
}
if (!is_open(src_entry) || !is_open(dst_entry)) {
LogEvent(COMPONENT_CACHE_INODE,
"Cannot copy between files that are not open");
status = NFS4ERR_OPENMODE;
goto out;
}
if (count == UINT64_MAX) {
count = src_entry->obj_handle->attrs->filesize - src_offset;
LogDebug(COMPONENT_CACHE_INODE,
"0-count has an effective value of %zu", count);
}
fsal_status = src_entry->obj_handle->obj_ops.copy(src_entry->obj_handle,
src_offset,
dst_entry->obj_handle,
dst_offset,
count,
copied);
if (FSAL_IS_ERROR(fsal_status)) {
*copied = 0;
status = cache_inode_error_convert(fsal_status);
LogEvent(COMPONENT_CACHE_INODE,
"File copy failed: major = %d, minor = %d",
fsal_status.major, fsal_status.minor);
goto out;
}
/* Update dest file after coping to it. */
PTHREAD_RWLOCK_wrlock(&dst_entry->attr_lock);
status = cache_inode_refresh_attrs(dst_entry);
PTHREAD_RWLOCK_unlock(&dst_entry->attr_lock);
out:
if ((size_t)src_entry < (size_t)dst_entry) {
PTHREAD_RWLOCK_unlock(&dst_entry->content_lock);
PTHREAD_RWLOCK_unlock(&src_entry->content_lock);
} else {
PTHREAD_RWLOCK_unlock(&src_entry->content_lock);
PTHREAD_RWLOCK_unlock(&dst_entry->content_lock);
}
return status;
}
/**
* @brief Set the attributes for a file.
*
* This function sets the attributes of a file, both in the cache and
* in the underlying filesystem.
*
* @param[in] entry Entry whose attributes are to be set
* @param[in,out] attr Attributes to set/result of set
*
* @retval CACHE_INODE_SUCCESS if operation is a success
*/
cache_inode_status_t
cache_inode_setattr(cache_entry_t *entry,
struct attrlist *attr,
bool is_open_write)
{
struct fsal_obj_handle *obj_handle = entry->obj_handle;
fsal_status_t fsal_status = { 0, 0 };
fsal_acl_t *saved_acl = NULL;
fsal_acl_status_t acl_status = 0;
cache_inode_status_t status = CACHE_INODE_SUCCESS;
uint64_t before;
const struct user_cred *creds = op_ctx->creds;
/* True if we have taken the content lock on 'entry' */
bool content_locked = false;
if ((attr->mask & (ATTR_SIZE | ATTR4_SPACE_RESERVED))
&& (entry->type != REGULAR_FILE)) {
LogWarn(COMPONENT_CACHE_INODE,
"Attempt to truncate non-regular file: type=%d",
entry->type);
status = CACHE_INODE_BAD_TYPE;
goto out;
}
/* Is it allowed to change times ? */
if (!op_ctx->fsal_export->exp_ops.fs_supports(op_ctx->fsal_export,
fso_cansettime)
&&
(FSAL_TEST_MASK
(attr->mask,
(ATTR_ATIME | ATTR_CREATION | ATTR_CTIME | ATTR_MTIME)))) {
status = CACHE_INODE_INVALID_ARGUMENT;
goto out;
}
/* Get wrlock on attr_lock and verify attrs */
status = cache_inode_lock_trust_attrs(entry, true);
if (status != CACHE_INODE_SUCCESS)
return status;
/* Do permission checks */
status = cache_inode_check_setattr_perms(entry, attr, is_open_write);
if (status != CACHE_INODE_SUCCESS)
goto unlock;
if (attr->mask & (ATTR_SIZE | ATTR4_SPACE_RESERVED)) {
PTHREAD_RWLOCK_wrlock(&entry->content_lock);
content_locked = true;
}
/* Test for the following condition from chown(2):
*
* When the owner or group of an executable file are changed by an
* unprivileged user the S_ISUID and S_ISGID mode bits are cleared.
* POSIX does not specify whether this also should happen when
* root does the chown(); the Linux behavior depends on the kernel
* version. In case of a non-group-executable file (i.e., one for
* which the S_IXGRP bit is not set) the S_ISGID bit indicates
* mandatory locking, and is not cleared by a chown().
*
*/
if (creds->caller_uid != 0 &&
(FSAL_TEST_MASK(attr->mask, ATTR_OWNER) ||
FSAL_TEST_MASK(attr->mask, ATTR_GROUP)) &&
((entry->obj_handle->attrs->mode &
(S_IXOTH | S_IXUSR | S_IXGRP)) != 0) &&
((entry->obj_handle->attrs->mode &
(S_ISUID | S_ISGID)) != 0)) {
/* Non-priviledged user changing ownership on an executable
* file with S_ISUID or S_ISGID bit set, need to be cleared.
*/
if (!FSAL_TEST_MASK(attr->mask, ATTR_MODE)) {
/* Mode wasn't being set, so set it now, start with
* the current attributes.
*/
attr->mode = entry->obj_handle->attrs->mode;
FSAL_SET_MASK(attr->mask, ATTR_MODE);
}
/* Don't clear S_ISGID if the file isn't group executable.
* In that case, S_ISGID indicates mandatory locking and
* is not cleared by chown.
*/
if ((entry->obj_handle->attrs->mode & S_IXGRP) != 0)
attr->mode &= ~S_ISGID;
/* Clear S_ISUID. */
attr->mode &= ~S_ISUID;
}
/* Test for the following condition from chmod(2):
*
* If the calling process is not privileged (Linux: does not have
* the CAP_FSETID capability), and the group of the file does not
* match the effective group ID of the process or one of its
* supplementary group IDs, the S_ISGID bit will be turned off,
* but this will not cause an error to be returned.
*
* We test the actual mode being set before testing for group
* membership since that is a bit more expensive.
*/
if (creds->caller_uid != 0 &&
FSAL_TEST_MASK(attr->mask, ATTR_MODE) &&
(attr->mode & S_ISGID) != 0 &&
not_in_group_list(entry->obj_handle->attrs->group)) {
/* Clear S_ISGID */
attr->mode &= ~S_ISGID;
}
saved_acl = entry->obj_handle->attrs->acl;
before = entry->obj_handle->attrs->change;
fsal_status = obj_handle->obj_ops.setattrs(obj_handle, attr);
if (FSAL_IS_ERROR(fsal_status)) {
status = cache_inode_error_convert(fsal_status);
if (fsal_status.major == ERR_FSAL_STALE) {
LogEvent(COMPONENT_CACHE_INODE,
"FSAL returned STALE from setattrs");
cache_inode_kill_entry(entry);
}
goto unlock;
}
fsal_status = obj_handle->obj_ops.getattrs(obj_handle);
*attr = *entry->obj_handle->attrs;
if (FSAL_IS_ERROR(fsal_status)) {
status = cache_inode_error_convert(fsal_status);
if (fsal_status.major == ERR_FSAL_STALE) {
LogEvent(COMPONENT_CACHE_INODE,
"FSAL returned STALE from getattrs");
cache_inode_kill_entry(entry);
}
goto unlock;
}
if (before == entry->obj_handle->attrs->change)
entry->obj_handle->attrs->change++;
/* Decrement refcount on saved ACL */
nfs4_acl_release_entry(saved_acl, &acl_status);
if (acl_status != NFS_V4_ACL_SUCCESS)
LogCrit(COMPONENT_CACHE_INODE,
"Failed to release old acl, status=%d", acl_status);
cache_inode_fixup_md(entry);
/* Copy the complete set of new attributes out. */
*attr = *entry->obj_handle->attrs;
status = CACHE_INODE_SUCCESS;
unlock:
if (content_locked)
PTHREAD_RWLOCK_unlock(&entry->content_lock);
PTHREAD_RWLOCK_unlock(&entry->attr_lock);
out:
return status;
}
/**
* @brief Set the attributes for a file.
*
* This function sets the attributes of a file, both in the cache and
* in the underlying filesystem.
*
* @param[in] entry Entry whose attributes are to be set
* @param[in,out] attr Attributes to set/result of set
*
* @retval CACHE_INODE_SUCCESS if operation is a success
*/
cache_inode_status_t
cache_inode_setattr(cache_entry_t *entry,
struct attrlist *attr,
bool is_open_write)
{
struct fsal_obj_handle *obj_handle = entry->obj_handle;
fsal_status_t fsal_status = { 0, 0 };
fsal_acl_t *saved_acl = NULL;
fsal_acl_status_t acl_status = 0;
cache_inode_status_t status = CACHE_INODE_SUCCESS;
uint64_t before;
/* True if we have taken the content lock on 'entry' */
bool content_locked = false;
if ((attr->mask & (ATTR_SIZE | ATTR4_SPACE_RESERVED))
&& (entry->type != REGULAR_FILE)) {
LogWarn(COMPONENT_CACHE_INODE,
"Attempt to truncate non-regular file: type=%d",
entry->type);
status = CACHE_INODE_BAD_TYPE;
}
/* Is it allowed to change times ? */
if (!op_ctx->fsal_export->ops->fs_supports(op_ctx->fsal_export,
fso_cansettime)
&&
(FSAL_TEST_MASK
(attr->mask,
(ATTR_ATIME | ATTR_CREATION | ATTR_CTIME | ATTR_MTIME)))) {
status = CACHE_INODE_INVALID_ARGUMENT;
goto out;
}
/* Get wrlock on attr_lock and verify attrs */
status = cache_inode_lock_trust_attrs(entry, true);
if (status != CACHE_INODE_SUCCESS)
return status;
/* Do permission checks */
status = cache_inode_check_setattr_perms(entry, attr, is_open_write);
if (status != CACHE_INODE_SUCCESS)
goto unlock;
if (attr->mask & (ATTR_SIZE | ATTR4_SPACE_RESERVED)) {
PTHREAD_RWLOCK_wrlock(&entry->content_lock);
content_locked = true;
}
saved_acl = obj_handle->attributes.acl;
before = obj_handle->attributes.change;
fsal_status = obj_handle->ops->setattrs(obj_handle, attr);
if (FSAL_IS_ERROR(fsal_status)) {
status = cache_inode_error_convert(fsal_status);
if (fsal_status.major == ERR_FSAL_STALE) {
LogEvent(COMPONENT_CACHE_INODE,
"FSAL returned STALE from truncate");
cache_inode_kill_entry(entry);
}
goto unlock;
}
fsal_status = obj_handle->ops->getattrs(obj_handle);
*attr = obj_handle->attributes;
if (FSAL_IS_ERROR(fsal_status)) {
status = cache_inode_error_convert(fsal_status);
if (fsal_status.major == ERR_FSAL_STALE) {
LogEvent(COMPONENT_CACHE_INODE,
"FSAL returned STALE from setattrs");
cache_inode_kill_entry(entry);
}
goto unlock;
}
if (before == obj_handle->attributes.change)
obj_handle->attributes.change++;
/* Decrement refcount on saved ACL */
nfs4_acl_release_entry(saved_acl, &acl_status);
if (acl_status != NFS_V4_ACL_SUCCESS)
LogCrit(COMPONENT_CACHE_INODE,
"Failed to release old acl, status=%d", acl_status);
cache_inode_fixup_md(entry);
/* Copy the complete set of new attributes out. */
*attr = entry->obj_handle->attributes;
status = CACHE_INODE_SUCCESS;
unlock:
if (content_locked)
PTHREAD_RWLOCK_unlock(&entry->content_lock);
PTHREAD_RWLOCK_unlock(&entry->attr_lock);
out:
return status;
}
/**
* @brief Open a file descriptor for read or write and possibly create
*
* This function opens a file for read or write, possibly creating it.
* If the caller is passing a state, it must hold the state_lock
* exclusive.
*
* state can be NULL which indicates a stateless open (such as via the
* NFS v3 CREATE operation), in which case the FSAL must assure protection
* of any resources. If the file is being created, such protection is
* simple since no one else will have access to the object yet, however,
* in the case of an exclusive create, the common resources may still need
* protection.
*
* If Name is NULL, obj_hdl is the file itself, otherwise obj_hdl is the
* parent directory.
*
* On an exclusive create, the upper layer may know the object handle
* already, so it MAY call with name == NULL. In this case, the caller
* expects just to check the verifier.
*
* On a call with an existing object handle for an UNCHECKED create,
* we can set the size to 0.
*
* At least the mode attribute must be set if createmode is not FSAL_NO_CREATE.
* Some FSALs may still have to pass a mode on a create call for exclusive,
* and even with FSAL_NO_CREATE, and empty set of attributes MUST be passed.
*
* If an open by name succeeds and did not result in Ganesha creating a file,
* the caller will need to do a subsequent permission check to confirm the
* open. This is because the permission attributes were not available
* beforehand.
*
* @param[in] obj_hdl File to open or parent directory
* @param[in,out] state state_t to use for this operation
* @param[in] openflags Mode for open
* @param[in] createmode Mode for create
* @param[in] name Name for file if being created or opened
* @param[in] attrib_set Attributes to set on created file
* @param[in] verifier Verifier to use for exclusive create
* @param[in,out] new_obj Newly created object
* @param[in,out] attrs_out Newly created object attributes
* @param[in,out] caller_perm_check The caller must do a permission check
*
* @return FSAL status.
*/
fsal_status_t gpfs_open2(struct fsal_obj_handle *obj_hdl,
struct state_t *state,
fsal_openflags_t openflags,
enum fsal_create_mode createmode,
const char *name,
struct attrlist *attrib_set,
fsal_verifier_t verifier,
struct fsal_obj_handle **new_obj,
struct attrlist *attrs_out,
bool *caller_perm_check)
{
int posix_flags = 0;
mode_t unix_mode;
fsal_status_t status = {0, 0};
struct gpfs_fd *my_fd = NULL;
struct gpfs_fsal_obj_handle *myself;
struct gpfs_fsal_obj_handle *hdl = NULL;
struct gpfs_file_handle fh;
bool truncated;
bool created = false;
struct fsal_export *export = op_ctx->fsal_export;
struct gpfs_filesystem *gpfs_fs = obj_hdl->fs->private_data;
int *fd = NULL;
myself = container_of(obj_hdl, struct gpfs_fsal_obj_handle, obj_handle);
if (name)
LogFullDebug(COMPONENT_FSAL, "got name %s", name);
else
LogFullDebug(COMPONENT_FSAL, "no name");
LogAttrlist(COMPONENT_FSAL, NIV_FULL_DEBUG,
"attrs ", attrib_set, false);
if (state != NULL)
my_fd = (struct gpfs_fd *)(state + 1);
fsal2posix_openflags(openflags, &posix_flags);
truncated = (posix_flags & O_TRUNC) != 0;
if (createmode >= FSAL_EXCLUSIVE) {
/* Now fixup attrs for verifier if exclusive create */
set_common_verifier(attrib_set, verifier);
}
if (name == NULL) {
/* This is an open by handle */
if (state != NULL) {
/* Prepare to take the share reservation, but only if we
* are called with a valid state (if state is NULL the
* caller is a stateless create such as NFS v3 CREATE).
*/
/* This can block over an I/O operation. */
PTHREAD_RWLOCK_wrlock(&obj_hdl->lock);
/* Check share reservation conflicts. */
status = check_share_conflict(&myself->u.file.share,
openflags,
false);
if (FSAL_IS_ERROR(status)) {
PTHREAD_RWLOCK_unlock(&obj_hdl->lock);
return status;
}
/* Take the share reservation now by updating the
* counters.
*/
update_share_counters(&myself->u.file.share,
FSAL_O_CLOSED,
openflags);
PTHREAD_RWLOCK_unlock(&obj_hdl->lock);
fd = &my_fd->fd;
my_fd->openflags = openflags;
} else {
/* We need to use the global fd to continue, and take
* the lock to protect it.
*/
fd = &myself->u.file.fd.fd;
myself->u.file.fd.openflags = openflags;
PTHREAD_RWLOCK_wrlock(&obj_hdl->lock);
}
status = GPFSFSAL_open(obj_hdl, op_ctx, posix_flags, fd, false);
if (FSAL_IS_ERROR(status)) {
if (state == NULL) {
/* Release the lock taken above, and return
* since there is nothing to undo.
*/
PTHREAD_RWLOCK_unlock(&obj_hdl->lock);
return status;
}
/* Error - need to release the share */
goto undo_share;
}
if (attrs_out && (createmode >= FSAL_EXCLUSIVE || truncated)) {
/* Refresh the attributes */
status = GPFSFSAL_getattrs(export, gpfs_fs, op_ctx,
myself->handle, attrs_out);
if (!FSAL_IS_ERROR(status)) {
LogFullDebug(COMPONENT_FSAL,
"New size = %"PRIx64,
attrs_out->filesize);
}
/* Now check verifier for exclusive, but not for
* FSAL_EXCLUSIVE_9P.
*/
if (!FSAL_IS_ERROR(status) &&
createmode >= FSAL_EXCLUSIVE &&
createmode != FSAL_EXCLUSIVE_9P &&
!check_verifier_attrlist(attrs_out, verifier)) {
/* Verifier didn't match, return EEXIST */
status =
fsalstat(posix2fsal_error(EEXIST), EEXIST);
}
}
if (state == NULL) {
/* If no state, release the lock taken above and return
* status.
*/
PTHREAD_RWLOCK_unlock(&obj_hdl->lock);
return status;
}
if (!FSAL_IS_ERROR(status)) {
/* Return success. */
return status;
}
(void) fsal_internal_close(*fd, state->state_owner, 0);
undo_share:
/* Can only get here with state not NULL and an error */
/* On error we need to release our share reservation
* and undo the update of the share counters.
* This can block over an I/O operation.
*/
PTHREAD_RWLOCK_wrlock(&obj_hdl->lock);
update_share_counters(&myself->u.file.share,
openflags,
FSAL_O_CLOSED);
PTHREAD_RWLOCK_unlock(&obj_hdl->lock);
return status;
}
void nfs4_acl_release_entry(fsal_acl_t *acl, fsal_acl_status_t *status)
{
struct gsh_buffdesc key, old_key;
struct gsh_buffdesc old_value;
int rc;
struct hash_latch latch;
/* Set the return default to NFS_V4_ACL_SUCCESS */
*status = NFS_V4_ACL_SUCCESS;
if (!acl)
return;
PTHREAD_RWLOCK_wrlock(&acl->lock);
if (acl->ref > 1) {
nfs4_acl_entry_dec_ref(acl);
PTHREAD_RWLOCK_unlock(&acl->lock);
return;
} else
LogDebug(COMPONENT_NFS_V4_ACL, "Free ACL %p", acl);
key.addr = acl->aces;
key.len = acl->naces * sizeof(fsal_ace_t);
PTHREAD_RWLOCK_unlock(&acl->lock);
/* Get the hash table entry and hold latch */
rc = hashtable_getlatch(fsal_acl_hash, &key, &old_value, true, &latch);
switch (rc) {
case HASHTABLE_ERROR_NO_SUCH_KEY:
hashtable_releaselatched(fsal_acl_hash, &latch);
return;
case HASHTABLE_SUCCESS:
PTHREAD_RWLOCK_wrlock(&acl->lock);
nfs4_acl_entry_dec_ref(acl);
if (acl->ref != 0) {
/* Did not actually release last reference */
hashtable_releaselatched(fsal_acl_hash, &latch);
PTHREAD_RWLOCK_unlock(&acl->lock);
return;
}
/* use the key to delete the entry */
hashtable_deletelatched(fsal_acl_hash, &key, &latch,
&old_key, &old_value);
/* Release the latch */
hashtable_releaselatched(fsal_acl_hash, &latch);
break;
default:
LogCrit(COMPONENT_NFS_V4_ACL,
"ACL entry could not be deleted, status=%s",
hash_table_err_to_str(rc));
return;
}
/* Sanity check: old_value.addr is expected to be equal to acl,
* and is released later in this function */
assert(old_value.addr == acl);
PTHREAD_RWLOCK_unlock(&acl->lock);
/* Release acl */
nfs4_acl_free(acl);
}
/**
* @brief adds a new state to a file
*
* This version of the function does not take the state lock on the
* entry. It exists to allow callers to integrate state into a larger
* operation.
*
* The caller may have already allocated a state, in which case state
* need not be NULL.
*
* @note state_lock MUST be held for write
*
* @param[in,out] obj file to operate on
* @param[in] state_type State to be defined
* @param[in] state_data Data related to this state
* @param[in] owner_input Related open_owner
* @param[in,out] state The new state
* @param[in] refer Reference to compound creating state
*
* @return Operation status
*/
state_status_t state_add_impl(struct fsal_obj_handle *obj,
enum state_type state_type,
union state_data *state_data,
state_owner_t *owner_input, state_t **state,
struct state_refer *refer)
{
state_t *pnew_state = *state;
struct state_hdl *ostate = obj->state_hdl;
char str[DISPLAY_STATEID_OTHER_SIZE];
struct display_buffer dspbuf = {sizeof(str), str, str};
bool str_valid = false;
bool got_export_ref = false;
state_status_t status = 0;
bool mutex_init = false;
struct state_t *openstate = NULL;
struct gsh_buffdesc fh_desc;
if (isFullDebug(COMPONENT_STATE) && pnew_state != NULL) {
display_stateid(&dspbuf, pnew_state);
LogFullDebug(COMPONENT_STATE, "pnew_state=%s", str);
display_reset_buffer(&dspbuf);
}
/* Attempt to get a reference to the export. */
if (!export_ready(op_ctx->ctx_export)) {
/* If we could not get a reference, return stale.
* Release attr_lock
*/
LogDebug(COMPONENT_STATE, "Stale export");
status = STATE_ESTALE;
goto errout;
}
get_gsh_export_ref(op_ctx->ctx_export);
got_export_ref = true;
if (pnew_state == NULL) {
if (state_type == STATE_TYPE_LOCK)
openstate = state_data->lock.openstate;
pnew_state = op_ctx->fsal_export->exp_ops.alloc_state(
op_ctx->fsal_export,
state_type,
openstate);
}
PTHREAD_MUTEX_init(&pnew_state->state_mutex, NULL);
mutex_init = true;
/* Add the stateid.other, this will increment cid_stateid_counter */
nfs4_BuildStateId_Other(owner_input->so_owner.so_nfs4_owner.
so_clientrec, pnew_state->stateid_other);
/* Set the type and data for this state */
memcpy(&(pnew_state->state_data), state_data, sizeof(*state_data));
pnew_state->state_type = state_type;
pnew_state->state_seqid = 0; /* will be incremented to 1 later */
pnew_state->state_refcount = 2; /* sentinel plus returned ref */
if (refer)
pnew_state->state_refer = *refer;
if (isFullDebug(COMPONENT_STATE)) {
display_stateid_other(&dspbuf, pnew_state->stateid_other);
str_valid = true;
LogFullDebug(COMPONENT_STATE,
"About to call nfs4_State_Set for %s",
str);
}
glist_init(&pnew_state->state_list);
/* We need to initialize state_owner, state_export, and state_obj now so
* that the state can be indexed by owner/entry. We don't insert into
* lists and take references yet since no one else can see this state
* until we are completely done since we hold the state_lock. Might as
* well grab export now also...
*/
pnew_state->state_export = op_ctx->ctx_export;
pnew_state->state_owner = owner_input;
fh_desc.addr = &pnew_state->state_obj.digest;
fh_desc.len = sizeof(pnew_state->state_obj.digest);
obj->obj_ops.handle_digest(obj, FSAL_DIGEST_NFSV4, &fh_desc);
pnew_state->state_obj.len = fh_desc.len;
/* Add the state to the related hashtable */
if (!nfs4_State_Set(pnew_state)) {
if (!str_valid)
display_stateid_other(&dspbuf,
pnew_state->stateid_other);
LogCrit(COMPONENT_STATE,
"Can't create a new state id %s for the obj %p (F)",
str, obj);
/* Return STATE_MALLOC_ERROR since most likely the
* nfs4_State_Set failed to allocate memory.
*/
status = STATE_MALLOC_ERROR;
goto errout;
}
/* Each of the following blocks takes the state_mutex and releases it
* because we always want state_mutex to be the last lock taken.
*
* NOTE: We don't have to worry about state_del/state_del_locked being
* called in the midst of things because the state_lock is held.
*/
/* Attach this to an export */
PTHREAD_RWLOCK_wrlock(&op_ctx->ctx_export->lock);
PTHREAD_MUTEX_lock(&pnew_state->state_mutex);
glist_add_tail(&op_ctx->ctx_export->exp_state_list,
&pnew_state->state_export_list);
PTHREAD_MUTEX_unlock(&pnew_state->state_mutex);
PTHREAD_RWLOCK_unlock(&op_ctx->ctx_export->lock);
/* Add state to list for file */
PTHREAD_MUTEX_lock(&pnew_state->state_mutex);
glist_add_tail(&ostate->file.list_of_states, &pnew_state->state_list);
PTHREAD_MUTEX_unlock(&pnew_state->state_mutex);
/* Add state to list for owner */
PTHREAD_MUTEX_lock(&owner_input->so_mutex);
PTHREAD_MUTEX_lock(&pnew_state->state_mutex);
inc_state_owner_ref(owner_input);
glist_add_tail(&owner_input->so_owner.so_nfs4_owner.so_state_list,
&pnew_state->state_owner_list);
PTHREAD_MUTEX_unlock(&pnew_state->state_mutex);
PTHREAD_MUTEX_unlock(&owner_input->so_mutex);
#ifdef DEBUG_SAL
PTHREAD_MUTEX_lock(&all_state_v4_mutex);
glist_add_tail(&state_v4_all, &pnew_state->state_list_all);
PTHREAD_MUTEX_unlock(&all_state_v4_mutex);
#endif
if (pnew_state->state_type == STATE_TYPE_DELEG &&
pnew_state->state_data.deleg.sd_type == OPEN_DELEGATE_WRITE)
ostate->file.write_delegated = true;
/* Copy the result */
*state = pnew_state;
if (str_valid)
LogFullDebug(COMPONENT_STATE, "Add State: %p: %s",
pnew_state, str);
/* Regular exit */
status = STATE_SUCCESS;
return status;
errout:
if (mutex_init)
PTHREAD_MUTEX_destroy(&pnew_state->state_mutex);
if (pnew_state != NULL) {
/* Make sure the new state is closed (may have been passed in
* with file open).
*/
(void) obj->obj_ops.close2(obj, pnew_state);
pnew_state->state_exp->exp_ops.free_state(pnew_state);
}
if (got_export_ref)
put_gsh_export(op_ctx->ctx_export);
*state = NULL;
return status;
} /* state_add */
static nfsstat4 acquire_layout_state(compound_data_t *data,
stateid4 *supplied_stateid,
layouttype4 layout_type,
state_t **layout_state, const char *tag)
{
/* State associated with the client-supplied stateid */
state_t *supplied_state = NULL;
/* State owner for per-clientid states */
state_owner_t *clientid_owner = NULL;
/* Return from this function */
nfsstat4 nfs_status = 0;
/* Return from state functions */
state_status_t state_status = 0;
/* Layout state, forgotten about by caller */
state_t *condemned_state = NULL;
/* Tracking data for the layout state */
struct state_refer refer;
bool lock_held = false;
memcpy(refer.session, data->session->session_id, sizeof(sessionid4));
refer.sequence = data->sequence;
refer.slot = data->slot;
clientid_owner = &data->session->clientid_record->cid_owner;
/* Retrieve state corresponding to supplied ID, inspect it
* and, if necessary, create a new layout state
*/
nfs_status = nfs4_Check_Stateid(supplied_stateid,
data->current_obj,
&supplied_state,
data,
STATEID_SPECIAL_CURRENT,
0,
false,
tag);
if (nfs_status != NFS4_OK) {
/* The supplied stateid was invalid */
return nfs_status;
}
if (supplied_state->state_type == STATE_TYPE_LAYOUT) {
/* If the state supplied is a layout state, we can
* simply use it, return with the reference we just
* acquired.
*/
*layout_state = supplied_state;
return nfs_status;
} else if ((supplied_state->state_type == STATE_TYPE_SHARE)
|| (supplied_state->state_type == STATE_TYPE_DELEG)
|| (supplied_state->state_type == STATE_TYPE_LOCK)) {
/* For share, delegation, and lock states, create a
new layout state. */
union state_data layout_data;
memset(&layout_data, 0, sizeof(layout_data));
PTHREAD_RWLOCK_wrlock(
&data->current_obj->state_hdl->state_lock);
lock_held = true;
/* See if a layout state already exists */
state_status =
state_lookup_layout_state(data->current_obj,
clientid_owner,
layout_type,
&condemned_state);
/* If it does, we assume that the client is using the
* forgetful model and has forgotten it had any
* layouts. Free all layouts associated with the
* state and delete it.
*/
if (state_status == STATE_SUCCESS) {
/* Flag indicating whether all layouts were returned
* and the state was deleted
*/
bool deleted = false;
struct pnfs_segment entire = {
.io_mode = LAYOUTIOMODE4_ANY,
.offset = 0,
.length = NFS4_UINT64_MAX
};
if (condemned_state->state_data.layout.granting) {
nfs_status = NFS4ERR_DELAY;
dec_state_t_ref(condemned_state);
goto out;
}
nfs_status =
nfs4_return_one_state(data->current_obj,
0,
circumstance_forgotten,
condemned_state,
entire,
0,
NULL,
&deleted);
dec_state_t_ref(condemned_state);
if (nfs_status != NFS4_OK)
goto out;
if (!deleted) {
nfs_status = NFS4ERR_SERVERFAULT;
goto out;
}
condemned_state = NULL;
}
layout_data.layout.state_layout_type = layout_type;
layout_data.layout.state_return_on_close = false;
state_status = state_add_impl(data->current_obj,
STATE_TYPE_LAYOUT,
&layout_data,
clientid_owner,
layout_state,
&refer);
if (state_status != STATE_SUCCESS) {
nfs_status = nfs4_Errno_state(state_status);
goto out;
}
glist_init(&(*layout_state)->state_data.layout.state_segments);
} else {
static void open4_ex(OPEN4args *arg,
compound_data_t *data,
OPEN4res *res_OPEN4,
nfs_client_id_t *clientid,
state_owner_t *owner,
state_t **file_state,
bool *new_state)
{
/* Parent directory in which to open the file. */
struct fsal_obj_handle *parent = NULL;
/* The entry we associated with the desired file before open. */
struct fsal_obj_handle *file_obj = NULL;
/* Indicator that file_obj came from lookup. */
bool looked_up_file_obj = false;
/* The in_obj to pass to fsal_open2. */
struct fsal_obj_handle *in_obj = NULL;
/* The entry open associated with the file. */
struct fsal_obj_handle *out_obj = NULL;
fsal_openflags_t openflags = 0;
fsal_openflags_t old_openflags = 0;
enum fsal_create_mode createmode = FSAL_NO_CREATE;
/* The filename to create */
char *filename = NULL;
/* The supplied calim type */
open_claim_type4 claim = arg->claim.claim;
fsal_verifier_t verifier;
struct attrlist sattr;
/* Status for fsal calls */
fsal_status_t status = {0, 0};
/* The open state for the file */
bool state_lock_held = false;
/* Make sure the attributes are initialized */
memset(&sattr, 0, sizeof(sattr));
/* Make sure... */
*file_state = NULL;
*new_state = false;
/* Pre-process the claim type */
switch (claim) {
case CLAIM_NULL:
/* Check parent */
parent = data->current_obj;
in_obj = parent;
/* Parent must be a directory */
if (parent->type != DIRECTORY) {
if (parent->type == SYMBOLIC_LINK) {
res_OPEN4->status = NFS4ERR_SYMLINK;
goto out;
} else {
res_OPEN4->status = NFS4ERR_NOTDIR;
goto out;
}
}
/* Validate and convert the utf8 filename */
res_OPEN4->status =
nfs4_utf8string2dynamic(&arg->claim.open_claim4_u.file,
UTF8_SCAN_ALL, &filename);
if (res_OPEN4->status != NFS4_OK)
goto out;
/* Set the createmode if appropriate) */
if (arg->openhow.opentype == OPEN4_CREATE) {
open4_ex_create_args(arg, data, res_OPEN4, verifier,
&createmode, &sattr);
if (res_OPEN4->status != NFS4_OK)
goto out;
}
status = fsal_lookup(parent, filename, &file_obj, NULL);
if (!FSAL_IS_ERROR(status)) {
/* Check create situations. */
if (arg->openhow.opentype == OPEN4_CREATE) {
if (createmode >= FSAL_EXCLUSIVE) {
/* Could be a replay, need to continue.
*/
LogFullDebug(COMPONENT_STATE,
"EXCLUSIVE open with existing file %s",
filename);
} else if (createmode == FSAL_GUARDED) {
/* This will be a failure no matter'
* what.
*/
looked_up_file_obj = true;
res_OPEN4->status = NFS4ERR_EXIST;
goto out;
} else {
/* FSAL_UNCHECKED, may be a truncate
* and we need to pass in the case
* of fsal_reopen2 case.
*/
if (FSAL_TEST_MASK(sattr.valid_mask,
ATTR_SIZE) &&
sattr.filesize == 0) {
LogFullDebug(COMPONENT_STATE,
"Truncate");
openflags |= FSAL_O_TRUNC;
}
}
}
/* We found the file by lookup, discard the filename
* and remember that we found the entry by lookup.
*/
looked_up_file_obj = true;
gsh_free(filename);
filename = NULL;
} else if (status.major != ERR_FSAL_NOENT ||
arg->openhow.opentype != OPEN4_CREATE) {
/* A real error occurred */
res_OPEN4->status = nfs4_Errno_status(status);
goto out;
}
break;
/* Both of these just use the current filehandle. */
case CLAIM_PREVIOUS:
owner->so_owner.so_nfs4_owner.so_confirmed = true;
if (!nfs4_check_deleg_reclaim(clientid, &data->currentFH)) {
/* It must have been revoked. Can't reclaim.*/
LogInfo(COMPONENT_NFS_V4, "Can't reclaim delegation");
res_OPEN4->status = NFS4ERR_RECLAIM_BAD;
goto out;
}
openflags |= FSAL_O_RECLAIM;
file_obj = data->current_obj;
break;
case CLAIM_FH:
file_obj = data->current_obj;
break;
case CLAIM_DELEGATE_PREV:
/* FIXME: Remove this when we have full support
* for CLAIM_DELEGATE_PREV and delegpurge operations
*/
res_OPEN4->status = NFS4ERR_NOTSUPP;
goto out;
case CLAIM_DELEGATE_CUR:
res_OPEN4->status = open4_claim_deleg(arg, data);
if (res_OPEN4->status != NFS4_OK)
goto out;
openflags |= FSAL_O_RECLAIM;
file_obj = data->current_obj;
break;
default:
LogFatal(COMPONENT_STATE,
"Programming error. Invalid claim after check.");
}
if ((arg->share_access & OPEN4_SHARE_ACCESS_READ) != 0)
openflags |= FSAL_O_READ;
if ((arg->share_access & OPEN4_SHARE_ACCESS_WRITE) != 0)
openflags |= FSAL_O_WRITE;
if ((arg->share_deny & OPEN4_SHARE_DENY_READ) != 0)
openflags |= FSAL_O_DENY_READ;
if ((arg->share_deny & OPEN4_SHARE_DENY_WRITE) != 0)
openflags |= FSAL_O_DENY_WRITE_MAND;
/* Check if file_obj a REGULAR_FILE */
if (file_obj != NULL && file_obj->type != REGULAR_FILE) {
LogDebug(COMPONENT_NFS_V4,
"Wrong file type expected REGULAR_FILE actual %s",
object_file_type_to_str(file_obj->type));
if (file_obj->type == DIRECTORY) {
res_OPEN4->status = NFS4ERR_ISDIR;
} else {
/* All special nodes must return NFS4ERR_SYMLINK for
* proper client behavior per this linux-nfs post:
* http://marc.info/?l=linux-nfs&m=131342421825436&w=2
*/
res_OPEN4->status = NFS4ERR_SYMLINK;
}
goto out;
}
if (file_obj != NULL) {
/* Go ahead and take the state lock now. */
PTHREAD_RWLOCK_wrlock(&file_obj->state_hdl->state_lock);
state_lock_held = true;
in_obj = file_obj;
/* Check if any existing delegations conflict with this open.
* Delegation recalls will be scheduled if there is a conflict.
*/
if (state_deleg_conflict(file_obj,
(arg->share_access &
OPEN4_SHARE_ACCESS_WRITE) != 0)) {
res_OPEN4->status = NFS4ERR_DELAY;
goto out;
}
/* Check if there is already a state for this entry and owner.
*/
*file_state = nfs4_State_Get_Obj(file_obj, owner);
if (isFullDebug(COMPONENT_STATE) && *file_state != NULL) {
char str[LOG_BUFF_LEN] = "\0";
struct display_buffer dspbuf = {sizeof(str), str, str};
display_stateid(&dspbuf, *file_state);
LogFullDebug(COMPONENT_STATE,
"Found existing state %s",
str);
}
/* Check if open from another export */
if (*file_state != NULL &&
!state_same_export(*file_state, op_ctx->ctx_export)) {
LogEvent(COMPONENT_STATE,
"Lock Owner Export Conflict, Lock held for export %"
PRIu16" request for export %"PRIu16,
state_export_id(*file_state),
op_ctx->ctx_export->export_id);
res_OPEN4->status = NFS4ERR_INVAL;
goto out;
}
}
/* If that did not succeed, allocate a state from the FSAL. */
if (*file_state == NULL) {
*file_state = op_ctx->fsal_export->exp_ops.alloc_state(
op_ctx->fsal_export,
STATE_TYPE_SHARE,
NULL);
/* Remember we allocated a new state */
*new_state = true;
/* We are ready to perform the open (with possible create).
* in_obj has been set to the file itself or the parent.
* filename is NULL if in_obj is the file itself.
*
* Permission check has been done on directory if appropriate,
* otherwise fsal_open2 will do a directory permission
* check.
*
* fsal_open2 handles the permission check on the file
* itself and also handles all the share reservation stuff.
*
* fsal_open2 returns with a ref on out_obj, which should be
* passed to the state.
*/
LogFullDebug(COMPONENT_STATE,
"Calling open2 for %s", filename);
status = fsal_open2(in_obj,
*file_state,
openflags,
createmode,
filename,
&sattr,
verifier,
&out_obj,
NULL);
if (FSAL_IS_ERROR(status)) {
res_OPEN4->status = nfs4_Errno_status(status);
goto out;
}
} else if (createmode >= FSAL_EXCLUSIVE) {
/* We have an EXCLUSIVE create with an existing
* state. We still need to verify it, but no need
* to call reopen2.
*/
LogFullDebug(COMPONENT_STATE, "Calling verify2 ");
status = fsal_verify2(file_obj, verifier);
if (FSAL_IS_ERROR(status)) {
res_OPEN4->status = nfs4_Errno_status(status);
goto out;
}
/* We need an extra reference below. */
file_obj->obj_ops->get_ref(file_obj);
} else {
old_openflags =
file_obj->obj_ops->status2(file_obj, *file_state);
/* Open upgrade */
LogFullDebug(COMPONENT_STATE, "Calling reopen2");
status = fsal_reopen2(file_obj, *file_state,
openflags | old_openflags,
false);
if (FSAL_IS_ERROR(status)) {
res_OPEN4->status = nfs4_Errno_status(status);
goto out;
}
/* We need an extra reference below. */
file_obj->obj_ops->get_ref(file_obj);
}
if (file_obj == NULL) {
/* We have a new cache inode entry, take the state lock. */
file_obj = out_obj;
PTHREAD_RWLOCK_wrlock(&file_obj->state_hdl->state_lock);
state_lock_held = true;
}
/* Now the state_lock is held for sure and we have an extra LRU
* reference to file_obj, which is the opened file.
*/
if (*new_state) {
/* The state data to be added */
union state_data candidate_data;
/* Tracking data for the open state */
struct state_refer refer, *p_refer = NULL;
state_status_t state_status;
candidate_data.share.share_access =
arg->share_access & OPEN4_SHARE_ACCESS_BOTH;
candidate_data.share.share_deny = arg->share_deny;
candidate_data.share.share_access_prev =
(1 << candidate_data.share.share_access);
candidate_data.share.share_deny_prev =
(1 << candidate_data.share.share_deny);
LogFullDebug(COMPONENT_STATE,
"Creating new state access=%x deny=%x access_prev=%x deny_prev=%x",
candidate_data.share.share_access,
candidate_data.share.share_deny,
candidate_data.share.share_access_prev,
candidate_data.share.share_deny_prev);
/* Record the sequence info */
if (data->minorversion > 0) {
memcpy(refer.session,
data->session->session_id,
sizeof(sessionid4));
refer.sequence = data->sequence;
refer.slot = data->slot;
p_refer = &refer;
}
/* We need to register this state now. */
state_status = state_add_impl(file_obj,
STATE_TYPE_SHARE,
&candidate_data,
owner,
file_state,
p_refer);
if (state_status != STATE_SUCCESS) {
/* state_add_impl failure closed and freed state.
* file_state will also be NULL at this point. Also
* release the ref on file_obj, since the state add
* failed.
*/
file_obj->obj_ops->put_ref(file_obj);
res_OPEN4->status = nfs4_Errno_state(state_status);
*new_state = false;
goto out;
}
glist_init(&(*file_state)->state_data.share.share_lockstates);
}
res_OPEN4->status = open4_create_fh(data, file_obj, true);
if (res_OPEN4->status != NFS4_OK) {
if (*new_state) {
/* state_del_locked will close the file. */
state_del_locked(*file_state);
*file_state = NULL;
*new_state = false;
} else {
/*Do an open downgrade to the old open flags */
status = file_obj->obj_ops->reopen2(file_obj,
*file_state,
old_openflags);
if (FSAL_IS_ERROR(status)) {
LogCrit(COMPONENT_NFS_V4,
"Failed to allocate handle, reopen2 failed with %s",
fsal_err_txt(status));
}
/* Need to release the state_lock before the put_ref
* call.
*/
PTHREAD_RWLOCK_unlock(&file_obj->state_hdl->state_lock);
state_lock_held = false;
/* Release the extra LRU reference on file_obj. */
file_obj->obj_ops->put_ref(file_obj);
goto out;
}
}
/* Since open4_create_fh succeeded the LRU reference to file_obj was
* consumed by data->current_obj.
*/
if (!(*new_state)) {
LogFullDebug(COMPONENT_STATE,
"Open upgrade old access=%x deny=%x access_prev=%x deny_prev=%x",
(*file_state)->state_data.share.share_access,
(*file_state)->state_data.share.share_deny,
(*file_state)->state_data.share.share_access_prev,
(*file_state)->state_data.share.share_deny_prev);
LogFullDebug(COMPONENT_STATE,
"Open upgrade to access=%x deny=%x",
arg->share_access,
arg->share_deny);
/* Update share_access and share_deny */
(*file_state)->state_data.share.share_access |=
arg->share_access & OPEN4_SHARE_ACCESS_BOTH;
(*file_state)->state_data.share.share_deny |=
arg->share_deny;
/* Update share_access_prev and share_deny_prev */
(*file_state)->state_data.share.share_access_prev |=
(1 << (arg->share_access & OPEN4_SHARE_ACCESS_BOTH));
(*file_state)->state_data.share.share_deny_prev |=
(1 << arg->share_deny);
LogFullDebug(COMPONENT_STATE,
"Open upgrade new access=%x deny=%x access_prev=%x deny_prev=%x",
(*file_state)->state_data.share.share_access,
(*file_state)->state_data.share.share_deny,
(*file_state)->state_data.share.share_access_prev,
(*file_state)->state_data.share.share_deny_prev);
}
do_delegation(arg, res_OPEN4, data, owner, *file_state, clientid);
out:
/* Release the attributes (may release an inherited ACL) */
fsal_release_attrs(&sattr);
if (state_lock_held)
PTHREAD_RWLOCK_unlock(&file_obj->state_hdl->state_lock);
if (filename)
gsh_free(filename);
if (res_OPEN4->status != NFS4_OK) {
/* Cleanup state on error */
if (*new_state)
(*file_state)
->state_exp->exp_ops.free_state(
(*file_state)->state_exp, *file_state);
else if (*file_state != NULL)
dec_state_t_ref(*file_state);
*file_state = NULL;
}
if (looked_up_file_obj) {
/* We got file_obj via lookup, we need to unref it. */
file_obj->obj_ops->put_ref(file_obj);
}
}
/**
* @brief Look up an entry, latching the table
*
* This function looks up an entry in the hash table and latches the
* partition in which that entry would belong in preparation for other
* activities. This function is a primitive and is intended more for
* use building other access functions than for client code itself.
*
* @brief[in] ht The hash table to search
* @brief[in] key The key for which to search
* @brief[out] val The value found
* @brief[in] may_write This must be true if the followup call might
* mutate the hash table (set or delete)
* @brief[out] latch Opaque structure holding information on the
* table.
*
* @retval HASHTABLE_SUCCESS The entry was found, the table is
* latched.
* @retval HASHTABLE_ERROR_NOT_FOUND The entry was not found, the
* table is latched.
* @retval Others, failure, the table is not latched.
*/
hash_error_t
hashtable_getlatch(struct hash_table *ht,
const struct gsh_buffdesc *key,
struct gsh_buffdesc *val, bool may_write,
struct hash_latch *latch)
{
/* The index specifying the partition to search */
uint32_t index = 0;
/* The node found for the key */
struct rbt_node *locator = NULL;
/* The buffer descritpros for the key and value for the found entry */
struct hash_data *data = NULL;
/* The hash value to be searched for within the Red-Black tree */
uint64_t rbt_hash = 0;
/* Stored error return */
hash_error_t rc = HASHTABLE_SUCCESS;
/* This combination of options makes no sense ever */
assert(!(may_write && !latch));
rc = compute(ht, key, &index, &rbt_hash);
if (rc != HASHTABLE_SUCCESS)
return rc;
/* Acquire mutex */
if (may_write)
PTHREAD_RWLOCK_wrlock(&(ht->partitions[index].lock));
else
PTHREAD_RWLOCK_rdlock(&(ht->partitions[index].lock));
rc = key_locate(ht, key, index, rbt_hash, &locator);
if (rc == HASHTABLE_SUCCESS) {
/* Key was found */
data = RBT_OPAQ(locator);
if (val) {
val->addr = data->val.addr;
val->len = data->val.len;
}
if (isDebug(COMPONENT_HASHTABLE)
&& isFullDebug(ht->parameter.ht_log_component)) {
char dispval[HASHTABLE_DISPLAY_STRLEN];
if (ht->parameter.val_to_str != NULL)
ht->parameter.val_to_str(&data->val, dispval);
else
dispval[0] = '\0';
LogFullDebug(ht->parameter.ht_log_component,
"Get %s returning Value=%p {%s}",
ht->parameter.ht_name, data->val.addr,
dispval);
}
}
if (((rc == HASHTABLE_SUCCESS) || (rc == HASHTABLE_ERROR_NO_SUCH_KEY))
&& (latch != NULL)) {
latch->index = index;
latch->rbt_hash = rbt_hash;
latch->locator = locator;
} else {
PTHREAD_RWLOCK_unlock(&ht->partitions[index].lock);
}
if (rc != HASHTABLE_SUCCESS && isDebug(COMPONENT_HASHTABLE)
&& isFullDebug(ht->parameter.ht_log_component))
LogFullDebug(ht->parameter.ht_log_component,
"Get %s returning failure %s",
ht->parameter.ht_name, hash_table_err_to_str(rc));
return rc;
}
/**
*
* nlm4_send_grant_msg: Send NLMPROC4_GRANTED_MSG
*
* This runs in the nlm_asyn_thread context.
*/
static void nlm4_send_grant_msg(state_async_queue_t *arg,
struct req_op_context *req_ctx)
{
int retval;
char buffer[1024];
state_status_t state_status = STATE_SUCCESS;
state_cookie_entry_t *cookie_entry;
state_nlm_async_data_t *nlm_arg =
&arg->state_async_data.state_nlm_async_data;
if (isDebug(COMPONENT_NLM)) {
netobj_to_string(&nlm_arg->nlm_async_args.nlm_async_grant.
cookie, buffer, sizeof(buffer));
LogDebug(COMPONENT_NLM,
"Sending GRANTED for arg=%p svid=%d start=%llx len=%llx cookie=%s",
arg,
nlm_arg->nlm_async_args.nlm_async_grant.alock.svid,
(unsigned long long)nlm_arg->nlm_async_args.
nlm_async_grant.alock.l_offset,
(unsigned long long)nlm_arg->nlm_async_args.
nlm_async_grant.alock.l_len, buffer);
}
retval = nlm_send_async(NLMPROC4_GRANTED_MSG,
nlm_arg->nlm_async_host,
&nlm_arg->nlm_async_args.nlm_async_grant,
nlm_arg->nlm_async_key);
dec_nlm_client_ref(nlm_arg->nlm_async_host);
/* If success, we are done. */
if (retval == RPC_SUCCESS)
goto out;
/*
* We are not able call granted callback. Some client may retry
* the lock again. So remove the existing blocked nlm entry
*/
LogMajor(COMPONENT_NLM,
"GRANTED_MSG RPC call failed with return code %d. Removing the blocking lock",
retval);
state_status = state_find_grant(
nlm_arg->nlm_async_args.nlm_async_grant.cookie.n_bytes,
nlm_arg->nlm_async_args.nlm_async_grant.cookie.n_len,
&cookie_entry);
if (state_status != STATE_SUCCESS) {
/* This must be an old NLM_GRANTED_RES */
LogFullDebug(COMPONENT_NLM,
"Could not find cookie=%s status=%s", buffer,
state_err_str(state_status));
goto out;
}
PTHREAD_RWLOCK_wrlock(&cookie_entry->sce_entry->state_lock);
if (cookie_entry->sce_lock_entry->sle_block_data == NULL
|| !nlm_block_data_to_export(
cookie_entry->sce_lock_entry->sle_block_data)) {
/* Wow, we're not doing well... */
PTHREAD_RWLOCK_unlock(&cookie_entry->sce_entry->state_lock);
LogFullDebug(COMPONENT_NLM,
"Could not find block data for cookie=%s (must be an old NLM_GRANTED_RES)",
buffer);
goto out;
}
PTHREAD_RWLOCK_unlock(&cookie_entry->sce_entry->state_lock);
state_status = state_release_grant(cookie_entry, req_ctx);
if (state_status != STATE_SUCCESS) {
/* Huh? */
LogFullDebug(COMPONENT_NLM,
"Could not release cookie=%s status=%s",
buffer,
state_err_str(state_status));
}
out:
free_grant_arg(arg);
}
static nfsstat4 layoutget(struct fsal_obj_handle *obj_pub,
struct req_op_context *req_ctx, XDR *loc_body,
const struct fsal_layoutget_arg *arg,
struct fsal_layoutget_res *res)
{
/* The private 'full' export */
struct export *export =
container_of(req_ctx->fsal_export, struct export, export);
/* The private 'full' object handle */
struct handle *handle = container_of(obj_pub, struct handle, handle);
/* Structure containing the storage parameters of the file within
the Ceph cluster. */
struct ceph_file_layout file_layout;
/* Width of each stripe on the file */
uint32_t stripe_width = 0;
/* Utility parameter */
nfl_util4 util = 0;
/* The last byte that can be accessed through pNFS */
uint64_t last_possible_byte = 0;
/* The deviceid for this layout */
struct pnfs_deviceid deviceid = DEVICE_ID_INIT_ZERO(FSAL_ID_CEPH);
/* NFS Status */
nfsstat4 nfs_status = 0;
/* DS wire handle */
struct ds_wire ds_wire;
/* Descriptor for DS handle */
struct gsh_buffdesc ds_desc = {.addr = &ds_wire,
.len = sizeof(struct ds_wire)
};
/* The smallest layout the client will accept */
struct pnfs_segment smallest_acceptable = {
.io_mode = res->segment.io_mode,
.offset = res->segment.offset,
.length = arg->minlength
};
struct pnfs_segment forbidden_area = {
.io_mode = res->segment.io_mode,
.length = NFS4_UINT64_MAX
};
/* We support only LAYOUT4_NFSV4_1_FILES layouts */
if (arg->type != LAYOUT4_NFSV4_1_FILES) {
LogCrit(COMPONENT_PNFS, "Unsupported layout type: %x",
arg->type);
return NFS4ERR_UNKNOWN_LAYOUTTYPE;
}
/* Get basic information on the file and calculate the dimensions
of the layout we can support. */
memset(&file_layout, 0, sizeof(struct ceph_file_layout));
ceph_ll_file_layout(export->cmount, handle->wire.vi, &file_layout);
stripe_width = file_layout.fl_stripe_unit;
last_possible_byte = (BIGGEST_PATTERN * stripe_width) - 1;
forbidden_area.offset = last_possible_byte + 1;
/* Since the Linux kernel refuses to work with any layout that
doesn't cover the whole file, if a whole file layout is
requested, lie.
Otherwise, make sure the required layout doesn't go beyond
what can be accessed through pNFS. This is a preliminary
check before even talking to Ceph. */
if (!
((res->segment.offset == 0)
&& (res->segment.length == NFS4_UINT64_MAX))) {
if (pnfs_segments_overlap
(&smallest_acceptable, &forbidden_area)) {
LogCrit(COMPONENT_PNFS,
"Required layout extends beyond allowed region. offset: %"
PRIu64 ", minlength: %" PRIu64 ".",
res->segment.offset, arg->minlength);
return NFS4ERR_BADLAYOUT;
}
res->segment.offset = 0;
res->segment.length = stripe_width * BIGGEST_PATTERN;
}
LogFullDebug(COMPONENT_PNFS,
"will issue layout offset: %" PRIu64 " length: %" PRIu64,
res->segment.offset, res->segment.length);
/* We are using sparse layouts with commit-through-DS, so our
utility word contains only the stripe width, our first
stripe is always at the beginning of the layout, and there
is no pattern offset. */
if ((stripe_width & ~NFL4_UFLG_STRIPE_UNIT_SIZE_MASK) != 0) {
LogCrit(COMPONENT_PNFS,
"Ceph returned stripe width that is disallowed by NFS: %"
PRIu32 ".", stripe_width);
return NFS4ERR_SERVERFAULT;
}
util = stripe_width;
/* If we have a cached capbility, use that. Otherwise, call
in to Ceph. */
PTHREAD_RWLOCK_wrlock(&handle->handle.lock);
if (res->segment.io_mode == LAYOUTIOMODE4_READ) {
int32_t r = 0;
if (handle->rd_issued == 0) {
#if 0
/* (ceph part might be here: thunderbeast mbarrier1) */
r = ceph_ll_hold_rw(export->cmount, handle->wire.vi,
false, initiate_recall, handle,
&handle->rd_serial, NULL);
#endif
if (r < 0) {
PTHREAD_RWLOCK_unlock(&handle->handle.lock);
return posix2nfs4_error(-r);
}
}
++handle->rd_issued;
} else {
int32_t r = 0;
if (handle->rw_issued == 0) {
#if 0
r = ceph_ll_hold_rw(export->cmount, handle->wire.vi,
true, initiate_recall, handle,
&handle->rw_serial,
&handle->rw_max_len);
#endif
if (r < 0) {
PTHREAD_RWLOCK_unlock(&handle->handle.lock);
return posix2nfs4_error(-r);
}
}
forbidden_area.offset = handle->rw_max_len;
if (pnfs_segments_overlap
(&smallest_acceptable, &forbidden_area)) {
PTHREAD_RWLOCK_unlock(&handle->handle.lock);
return NFS4ERR_BADLAYOUT;
}
#if CLIENTS_WILL_ACCEPT_SEGMENTED_LAYOUTS /* sigh */
res->segment.length =
(handle->rw_max_len - res->segment.offset);
#endif
++handle->rw_issued;
}
cache_inode_status_t
cache_inode_remove(cache_entry_t *entry,
const char *name,
struct req_op_context *req_ctx)
{
cache_entry_t *to_remove_entry = NULL;
fsal_status_t fsal_status = {0, 0};
cache_inode_status_t status = CACHE_INODE_SUCCESS;
cache_inode_status_t status_ref_entry = CACHE_INODE_SUCCESS;
cache_inode_status_t status_ref_to_remove_entry = CACHE_INODE_SUCCESS;
fsal_accessflags_t access_mask = 0;
if(entry->type != DIRECTORY) {
status = CACHE_INODE_NOT_A_DIRECTORY;
goto out;
}
/* Check if caller is allowed to perform the operation */
access_mask = (FSAL_MODE_MASK_SET(FSAL_W_OK) |
FSAL_ACE4_MASK_SET(FSAL_ACE_PERM_DELETE_CHILD));
status = cache_inode_access(entry,
access_mask,
req_ctx);
if (status != CACHE_INODE_SUCCESS) {
goto out;
}
/* Factor this somewhat. In the case where the directory hasn't
been populated, the entry may not exist in the cache and we'd
be bringing it in just to dispose of it. */
/* Looks up for the entry to remove */
PTHREAD_RWLOCK_rdlock(&entry->content_lock);
status = cache_inode_lookup_impl(entry,
name,
req_ctx,
&to_remove_entry);
PTHREAD_RWLOCK_unlock(&entry->content_lock);
if (to_remove_entry == NULL) {
goto out;
}
status = cache_inode_check_sticky(entry, to_remove_entry, req_ctx);
if (status != CACHE_INODE_SUCCESS) {
goto out;
}
LogDebug(COMPONENT_CACHE_INODE,
"---> Cache_inode_remove : %s", name);
if (is_open(to_remove_entry)) {
/* entry is not locked and seems to be open for fd caching purpose.
* candidate for closing since unlink of an open file results in 'silly
* rename' on certain platforms */
status = cache_inode_close(to_remove_entry,
CACHE_INODE_FLAG_REALLYCLOSE);
if (status != CACHE_INODE_SUCCESS) {
/* non-fatal error. log the warning and move on */
LogCrit(COMPONENT_CACHE_INODE,
"Error closing file before unlink: %d.",
status);
}
}
fsal_status = entry->obj_handle->ops->unlink(entry->obj_handle, req_ctx,
name);
if (FSAL_IS_ERROR(fsal_status)) {
status = cache_inode_error_convert(fsal_status);
if(to_remove_entry->type == DIRECTORY &&
status == CACHE_INODE_DIR_NOT_EMPTY) {
/* its dirent tree is probably stale, flush it
* to try and make things right again */
PTHREAD_RWLOCK_wrlock(&to_remove_entry->content_lock);
(void)cache_inode_invalidate_all_cached_dirent(to_remove_entry);
PTHREAD_RWLOCK_unlock(&to_remove_entry->content_lock);
}
goto out;
}
/* Remove the entry from parent dir_entries avl */
PTHREAD_RWLOCK_wrlock(&entry->content_lock);
cache_inode_remove_cached_dirent(entry, name, req_ctx);
PTHREAD_RWLOCK_unlock(&entry->content_lock);
status_ref_entry = cache_inode_refresh_attrs_locked(entry, req_ctx);
if(FSAL_IS_ERROR(fsal_status)) {
status = cache_inode_error_convert(fsal_status);
goto out;
}
/* Update the attributes for the removed entry */
status_ref_to_remove_entry = cache_inode_refresh_attrs_locked(to_remove_entry, req_ctx);
if (status_ref_to_remove_entry == CACHE_INODE_FSAL_ESTALE) {
status_ref_to_remove_entry = CACHE_INODE_SUCCESS;
}
if (((status = status_ref_entry) != CACHE_INODE_SUCCESS) ||
((status = status_ref_to_remove_entry) != CACHE_INODE_SUCCESS)) {
goto out;
}
out:
LogFullDebug(COMPONENT_CACHE_INODE,
"cache_inode_remove_cached_dirent: status=%d", status);
/* This is for the reference taken by lookup */
if (to_remove_entry) {
cache_inode_put(to_remove_entry);
}
return status;
}
