Quelle  orangefs-utils.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
/*
 * (C) 2001 Clemson University and The University of Chicago
 * Copyright 2018 Omnibond Systems, L.L.C.
 *
 * See COPYING in top-level directory.
 */
#include <linux/kernel.h>
#include "protocol.h"
#include "orangefs-kernel.h"
#include "orangefs-dev-proto.h"
#include "orangefs-bufmap.h"

__s32 fsid_of_op(struct orangefs_kernel_op_s *op)
{
 __s32 fsid = ORANGEFS_FS_ID_NULL;

 if (op) {
  switch (op->upcall.type) {
  case ORANGEFS_VFS_OP_FILE_IO:
   fsid = op->upcall.req.io.refn.fs_id;
   break;
  case ORANGEFS_VFS_OP_LOOKUP:
   fsid = op->upcall.req.lookup.parent_refn.fs_id;
   break;
  case ORANGEFS_VFS_OP_CREATE:
   fsid = op->upcall.req.create.parent_refn.fs_id;
   break;
  case ORANGEFS_VFS_OP_GETATTR:
   fsid = op->upcall.req.getattr.refn.fs_id;
   break;
  case ORANGEFS_VFS_OP_REMOVE:
   fsid = op->upcall.req.remove.parent_refn.fs_id;
   break;
  case ORANGEFS_VFS_OP_MKDIR:
   fsid = op->upcall.req.mkdir.parent_refn.fs_id;
   break;
  case ORANGEFS_VFS_OP_READDIR:
   fsid = op->upcall.req.readdir.refn.fs_id;
   break;
  case ORANGEFS_VFS_OP_SETATTR:
   fsid = op->upcall.req.setattr.refn.fs_id;
   break;
  case ORANGEFS_VFS_OP_SYMLINK:
   fsid = op->upcall.req.sym.parent_refn.fs_id;
   break;
  case ORANGEFS_VFS_OP_RENAME:
   fsid = op->upcall.req.rename.old_parent_refn.fs_id;
   break;
  case ORANGEFS_VFS_OP_STATFS:
   fsid = op->upcall.req.statfs.fs_id;
   break;
  case ORANGEFS_VFS_OP_TRUNCATE:
   fsid = op->upcall.req.truncate.refn.fs_id;
   break;
  case ORANGEFS_VFS_OP_RA_FLUSH:
   fsid = op->upcall.req.ra_cache_flush.refn.fs_id;
   break;
  case ORANGEFS_VFS_OP_FS_UMOUNT:
   fsid = op->upcall.req.fs_umount.fs_id;
   break;
  case ORANGEFS_VFS_OP_GETXATTR:
   fsid = op->upcall.req.getxattr.refn.fs_id;
   break;
  case ORANGEFS_VFS_OP_SETXATTR:
   fsid = op->upcall.req.setxattr.refn.fs_id;
   break;
  case ORANGEFS_VFS_OP_LISTXATTR:
   fsid = op->upcall.req.listxattr.refn.fs_id;
   break;
  case ORANGEFS_VFS_OP_REMOVEXATTR:
   fsid = op->upcall.req.removexattr.refn.fs_id;
   break;
  case ORANGEFS_VFS_OP_FSYNC:
   fsid = op->upcall.req.fsync.refn.fs_id;
   break;
  default:
   break;
  }
 }
 return fsid;
}

static int orangefs_inode_flags(struct ORANGEFS_sys_attr_s *attrs)
{
 int flags = 0;
 if (attrs->flags & ORANGEFS_IMMUTABLE_FL)
  flags |= S_IMMUTABLE;
 else
  flags &= ~S_IMMUTABLE;
 if (attrs->flags & ORANGEFS_APPEND_FL)
  flags |= S_APPEND;
 else
  flags &= ~S_APPEND;
 if (attrs->flags & ORANGEFS_NOATIME_FL)
  flags |= S_NOATIME;
 else
  flags &= ~S_NOATIME;
 return flags;
}

static int orangefs_inode_perms(struct ORANGEFS_sys_attr_s *attrs)
{
 int perm_mode = 0;

 if (attrs->perms & ORANGEFS_O_EXECUTE)
  perm_mode |= S_IXOTH;
 if (attrs->perms & ORANGEFS_O_WRITE)
  perm_mode |= S_IWOTH;
 if (attrs->perms & ORANGEFS_O_READ)
  perm_mode |= S_IROTH;

 if (attrs->perms & ORANGEFS_G_EXECUTE)
  perm_mode |= S_IXGRP;
 if (attrs->perms & ORANGEFS_G_WRITE)
  perm_mode |= S_IWGRP;
 if (attrs->perms & ORANGEFS_G_READ)
  perm_mode |= S_IRGRP;

 if (attrs->perms & ORANGEFS_U_EXECUTE)
  perm_mode |= S_IXUSR;
 if (attrs->perms & ORANGEFS_U_WRITE)
  perm_mode |= S_IWUSR;
 if (attrs->perms & ORANGEFS_U_READ)
  perm_mode |= S_IRUSR;

 if (attrs->perms & ORANGEFS_G_SGID)
  perm_mode |= S_ISGID;
 if (attrs->perms & ORANGEFS_U_SUID)
  perm_mode |= S_ISUID;

 return perm_mode;
}

/*
 * NOTE: in kernel land, we never use the sys_attr->link_target for
 * anything, so don't bother copying it into the sys_attr object here.
 */
static inline void copy_attributes_from_inode(struct inode *inode,
    struct ORANGEFS_sys_attr_s *attrs)
{
 struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode);
 attrs->mask = 0;
 if (orangefs_inode->attr_valid & ATTR_UID) {
  attrs->owner = from_kuid(&init_user_ns, inode->i_uid);
  attrs->mask |= ORANGEFS_ATTR_SYS_UID;
  gossip_debug(GOSSIP_UTILS_DEBUG, "(UID) %d\n", attrs->owner);
 }
 if (orangefs_inode->attr_valid & ATTR_GID) {
  attrs->group = from_kgid(&init_user_ns, inode->i_gid);
  attrs->mask |= ORANGEFS_ATTR_SYS_GID;
  gossip_debug(GOSSIP_UTILS_DEBUG, "(GID) %d\n", attrs->group);
 }

 if (orangefs_inode->attr_valid & ATTR_ATIME) {
  attrs->mask |= ORANGEFS_ATTR_SYS_ATIME;
  if (orangefs_inode->attr_valid & ATTR_ATIME_SET) {
   attrs->atime = (time64_t) inode_get_atime_sec(inode);
   attrs->mask |= ORANGEFS_ATTR_SYS_ATIME_SET;
  }
 }
 if (orangefs_inode->attr_valid & ATTR_MTIME) {
  attrs->mask |= ORANGEFS_ATTR_SYS_MTIME;
  if (orangefs_inode->attr_valid & ATTR_MTIME_SET) {
   attrs->mtime = (time64_t) inode_get_mtime_sec(inode);
   attrs->mask |= ORANGEFS_ATTR_SYS_MTIME_SET;
  }
 }
 if (orangefs_inode->attr_valid & ATTR_CTIME)
  attrs->mask |= ORANGEFS_ATTR_SYS_CTIME;

 /*
 * ORANGEFS cannot set size with a setattr operation. Probably not
 * likely to be requested through the VFS, but just in case, don't
 * worry about ATTR_SIZE
 */

 if (orangefs_inode->attr_valid & ATTR_MODE) {
  attrs->perms = ORANGEFS_util_translate_mode(inode->i_mode);
  attrs->mask |= ORANGEFS_ATTR_SYS_PERM;
 }
}

static int orangefs_inode_type(enum orangefs_ds_type objtype)
{
 if (objtype == ORANGEFS_TYPE_METAFILE)
  return S_IFREG;
 else if (objtype == ORANGEFS_TYPE_DIRECTORY)
  return S_IFDIR;
 else if (objtype == ORANGEFS_TYPE_SYMLINK)
  return S_IFLNK;
 else
  return -1;
}

static void orangefs_make_bad_inode(struct inode *inode)
{
 if (is_root_handle(inode)) {
  /*
 * if this occurs, the pvfs2-client-core was killed but we
 * can't afford to lose the inode operations and such
 * associated with the root handle in any case.
 */
  gossip_debug(GOSSIP_UTILS_DEBUG,
        "*** NOT making bad root inode %pU\n",
        get_khandle_from_ino(inode));
 } else {
  gossip_debug(GOSSIP_UTILS_DEBUG,
        "*** making bad inode %pU\n",
        get_khandle_from_ino(inode));
  make_bad_inode(inode);
 }
}

static int orangefs_inode_is_stale(struct inode *inode,
    struct ORANGEFS_sys_attr_s *attrs, char *link_target)
{
 struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode);
 int type = orangefs_inode_type(attrs->objtype);
 /*
 * If the inode type or symlink target have changed then this
 * inode is stale.
 */
 if (type == -1 || inode_wrong_type(inode, type)) {
  orangefs_make_bad_inode(inode);
  return 1;
 }
 if (type == S_IFLNK && strncmp(orangefs_inode->link_target,
     link_target, ORANGEFS_NAME_MAX)) {
  orangefs_make_bad_inode(inode);
  return 1;
 }
 return 0;
}

int orangefs_inode_getattr(struct inode *inode, int flags)
{
 struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode);
 struct orangefs_kernel_op_s *new_op;
 loff_t inode_size;
 int ret, type;

 gossip_debug(GOSSIP_UTILS_DEBUG, "%s: called on inode %pU flags %d\n",
     __func__, get_khandle_from_ino(inode), flags);

again:
 spin_lock(&inode->i_lock);
 /* Must have all the attributes in the mask and be within cache time. */
 if ((!flags && time_before(jiffies, orangefs_inode->getattr_time)) ||
     orangefs_inode->attr_valid || inode->i_state & I_DIRTY_PAGES) {
  if (orangefs_inode->attr_valid) {
   spin_unlock(&inode->i_lock);
   write_inode_now(inode, 1);
   goto again;
  }
  spin_unlock(&inode->i_lock);
  return 0;
 }
 spin_unlock(&inode->i_lock);

 new_op = op_alloc(ORANGEFS_VFS_OP_GETATTR);
 if (!new_op)
  return -ENOMEM;
 new_op->upcall.req.getattr.refn = orangefs_inode->refn;
 /*
 * Size is the hardest attribute to get.  The incremental cost of any
 * other attribute is essentially zero.
 */
 if (flags)
  new_op->upcall.req.getattr.mask = ORANGEFS_ATTR_SYS_ALL_NOHINT;
 else
  new_op->upcall.req.getattr.mask =
      ORANGEFS_ATTR_SYS_ALL_NOHINT & ~ORANGEFS_ATTR_SYS_SIZE;

 ret = service_operation(new_op, __func__,
     get_interruptible_flag(inode));
 if (ret != 0)
  goto out;

again2:
 spin_lock(&inode->i_lock);
 /* Must have all the attributes in the mask and be within cache time. */
 if ((!flags && time_before(jiffies, orangefs_inode->getattr_time)) ||
     orangefs_inode->attr_valid || inode->i_state & I_DIRTY_PAGES) {
  if (orangefs_inode->attr_valid) {
   spin_unlock(&inode->i_lock);
   write_inode_now(inode, 1);
   goto again2;
  }
  if (inode->i_state & I_DIRTY_PAGES) {
   ret = 0;
   goto out_unlock;
  }
  gossip_debug(GOSSIP_UTILS_DEBUG, "%s: in cache or dirty\n",
      __func__);
  ret = 0;
  goto out_unlock;
 }

 if (!(flags & ORANGEFS_GETATTR_NEW)) {
  ret = orangefs_inode_is_stale(inode,
      &new_op->downcall.resp.getattr.attributes,
      new_op->downcall.resp.getattr.link_target);
  if (ret) {
   ret = -ESTALE;
   goto out_unlock;
  }
 }

 type = orangefs_inode_type(new_op->
     downcall.resp.getattr.attributes.objtype);
 switch (type) {
 case S_IFREG:
  inode->i_flags = orangefs_inode_flags(&new_op->
      downcall.resp.getattr.attributes);
  if (flags) {
   inode_size = (loff_t)new_op->
       downcall.resp.getattr.attributes.size;
   inode->i_size = inode_size;
   inode->i_blkbits = ffs(new_op->downcall.resp.getattr.
       attributes.blksize);
   inode->i_bytes = inode_size;
   inode->i_blocks =
       (inode_size + 512 - inode_size % 512)/512;
  }
  break;
 case S_IFDIR:
  if (flags) {
   inode->i_size = PAGE_SIZE;
   inode_set_bytes(inode, inode->i_size);
  }
  set_nlink(inode, 1);
  break;
 case S_IFLNK:
  if (flags & ORANGEFS_GETATTR_NEW) {
   inode->i_size = (loff_t)strlen(new_op->
       downcall.resp.getattr.link_target);
   ret = strscpy(orangefs_inode->link_target,
       new_op->downcall.resp.getattr.link_target,
       ORANGEFS_NAME_MAX);
   if (ret == -E2BIG) {
    ret = -EIO;
    goto out_unlock;
   }
   inode->i_link = orangefs_inode->link_target;
  }
  break;
 /* i.e. -1 */
 default:
  /* XXX: ESTALE?  This is what is done if it is not new. */
  orangefs_make_bad_inode(inode);
  ret = -ESTALE;
  goto out_unlock;
 }

 inode->i_uid = make_kuid(&init_user_ns, new_op->
     downcall.resp.getattr.attributes.owner);
 inode->i_gid = make_kgid(&init_user_ns, new_op->
     downcall.resp.getattr.attributes.group);
 inode_set_atime(inode,
   (time64_t)new_op->downcall.resp.getattr.attributes.atime,
   0);
 inode_set_mtime(inode,
   (time64_t)new_op->downcall.resp.getattr.attributes.mtime,
   0);
 inode_set_ctime(inode,
   (time64_t)new_op->downcall.resp.getattr.attributes.ctime,
   0);

 /* special case: mark the root inode as sticky */
 inode->i_mode = type | (is_root_handle(inode) ? S_ISVTX : 0) |
     orangefs_inode_perms(&new_op->downcall.resp.getattr.attributes);

 orangefs_inode->getattr_time = jiffies +
     orangefs_getattr_timeout_msecs*HZ/1000;
 ret = 0;
out_unlock:
 spin_unlock(&inode->i_lock);
out:
 op_release(new_op);
 return ret;
}

int orangefs_inode_check_changed(struct inode *inode)
{
 struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode);
 struct orangefs_kernel_op_s *new_op;
 int ret;

 gossip_debug(GOSSIP_UTILS_DEBUG, "%s: called on inode %pU\n", __func__,
     get_khandle_from_ino(inode));

 new_op = op_alloc(ORANGEFS_VFS_OP_GETATTR);
 if (!new_op)
  return -ENOMEM;
 new_op->upcall.req.getattr.refn = orangefs_inode->refn;
 new_op->upcall.req.getattr.mask = ORANGEFS_ATTR_SYS_TYPE |
     ORANGEFS_ATTR_SYS_LNK_TARGET;

 ret = service_operation(new_op, __func__,
     get_interruptible_flag(inode));
 if (ret != 0)
  goto out;

 ret = orangefs_inode_is_stale(inode,
     &new_op->downcall.resp.getattr.attributes,
     new_op->downcall.resp.getattr.link_target);
out:
 op_release(new_op);
 return ret;
}

/*
 * issues a orangefs setattr request to make sure the new attribute values
 * take effect if successful.  returns 0 on success; -errno otherwise
 */
int orangefs_inode_setattr(struct inode *inode)
{
 struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode);
 struct orangefs_kernel_op_s *new_op;
 int ret;

 new_op = op_alloc(ORANGEFS_VFS_OP_SETATTR);
 if (!new_op)
  return -ENOMEM;

 spin_lock(&inode->i_lock);
 new_op->upcall.uid = from_kuid(&init_user_ns, orangefs_inode->attr_uid);
 new_op->upcall.gid = from_kgid(&init_user_ns, orangefs_inode->attr_gid);
 new_op->upcall.req.setattr.refn = orangefs_inode->refn;
 copy_attributes_from_inode(inode,
     &new_op->upcall.req.setattr.attributes);
 orangefs_inode->attr_valid = 0;
 if (!new_op->upcall.req.setattr.attributes.mask) {
  spin_unlock(&inode->i_lock);
  op_release(new_op);
  return 0;
 }
 spin_unlock(&inode->i_lock);

 ret = service_operation(new_op, __func__,
     get_interruptible_flag(inode) | ORANGEFS_OP_WRITEBACK);
 gossip_debug(GOSSIP_UTILS_DEBUG,
     "orangefs_inode_setattr: returning %d\n", ret);
 if (ret)
  orangefs_make_bad_inode(inode);

 op_release(new_op);

 if (ret == 0)
  orangefs_inode->getattr_time = jiffies - 1;
 return ret;
}

/*
 * The following is a very dirty hack that is now a permanent part of the
 * ORANGEFS protocol. See protocol.h for more error definitions.
 */

/* The order matches include/orangefs-types.h in the OrangeFS source. */
static int PINT_errno_mapping[] = {
 0, EPERM, ENOENT, EINTR, EIO, ENXIO, EBADF, EAGAIN, ENOMEM,
 EFAULT, EBUSY, EEXIST, ENODEV, ENOTDIR, EISDIR, EINVAL, EMFILE,
 EFBIG, ENOSPC, EROFS, EMLINK, EPIPE, EDEADLK, ENAMETOOLONG,
 ENOLCK, ENOSYS, ENOTEMPTY, ELOOP, EWOULDBLOCK, ENOMSG, EUNATCH,
 EBADR, EDEADLOCK, ENODATA, ETIME, ENONET, EREMOTE, ECOMM,
 EPROTO, EBADMSG, EOVERFLOW, ERESTART, EMSGSIZE, EPROTOTYPE,
 ENOPROTOOPT, EPROTONOSUPPORT, EOPNOTSUPP, EADDRINUSE,
 EADDRNOTAVAIL, ENETDOWN, ENETUNREACH, ENETRESET, ENOBUFS,
 ETIMEDOUT, ECONNREFUSED, EHOSTDOWN, EHOSTUNREACH, EALREADY,
 EACCES, ECONNRESET, ERANGE
};

int orangefs_normalize_to_errno(__s32 error_code)
{
 __u32 i;

 /* Success */
 if (error_code == 0) {
  return 0;
 /*
 * This shouldn't ever happen. If it does it should be fixed on the
 * server.
 */
 } else if (error_code > 0) {
  gossip_err("orangefs: error status received.\n");
  gossip_err("orangefs: assuming error code is inverted.\n");
  error_code = -error_code;
 }

 /*
 * XXX: This is very bad since error codes from ORANGEFS may not be
 * suitable for return into userspace.
 */

 /*
 * Convert ORANGEFS error values into errno values suitable for return
 * from the kernel.
 */
 if ((-error_code) & ORANGEFS_NON_ERRNO_ERROR_BIT) {
  if (((-error_code) &
      (ORANGEFS_ERROR_NUMBER_BITS|ORANGEFS_NON_ERRNO_ERROR_BIT|
      ORANGEFS_ERROR_BIT)) == ORANGEFS_ECANCEL) {
   /*
 * cancellation error codes generally correspond to
 * a timeout from the client's perspective
 */
   error_code = -ETIMEDOUT;
  } else {
   /* assume a default error code */
   gossip_err("%s: bad error code :%d:.\n",
    __func__,
    error_code);
   error_code = -EINVAL;
  }

 /* Convert ORANGEFS encoded errno values into regular errno values. */
 } else if ((-error_code) & ORANGEFS_ERROR_BIT) {
  i = (-error_code) & ~(ORANGEFS_ERROR_BIT|ORANGEFS_ERROR_CLASS_BITS);
  if (i < ARRAY_SIZE(PINT_errno_mapping))
   error_code = -PINT_errno_mapping[i];
  else
   error_code = -EINVAL;

 /*
 * Only ORANGEFS protocol error codes should ever come here. Otherwise
 * there is a bug somewhere.
 */
 } else {
  gossip_err("%s: unknown error code.\n", __func__);
  error_code = -EINVAL;
 }
 return error_code;
}

#define NUM_MODES 11
__s32 ORANGEFS_util_translate_mode(int mode)
{
 int ret = 0;
 int i = 0;
 static int modes[NUM_MODES] = {
  S_IXOTH, S_IWOTH, S_IROTH,
  S_IXGRP, S_IWGRP, S_IRGRP,
  S_IXUSR, S_IWUSR, S_IRUSR,
  S_ISGID, S_ISUID
 };
 static int orangefs_modes[NUM_MODES] = {
  ORANGEFS_O_EXECUTE, ORANGEFS_O_WRITE, ORANGEFS_O_READ,
  ORANGEFS_G_EXECUTE, ORANGEFS_G_WRITE, ORANGEFS_G_READ,
  ORANGEFS_U_EXECUTE, ORANGEFS_U_WRITE, ORANGEFS_U_READ,
  ORANGEFS_G_SGID, ORANGEFS_U_SUID
 };

 for (i = 0; i < NUM_MODES; i++)
  if (mode & modes[i])
   ret |= orangefs_modes[i];

 return ret;
}
#undef NUM_MODES