Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 5891b4fe authored by Mike Marshall's avatar Mike Marshall
Browse files

Merge tag 'for-hubcap-v4.9-more' into for-next 

orangefs: miscellaneous improvements and feature negotiation

Two OrangeFS updates:

 "Pull in an OrangeFS branch containing miscellaneous improvements.

  - clean up debugfs globals
  - remove dead code in sysfs
  - reorganize duplicated sysfs attribute structs
  - consolidate sysfs show and store functions
  - remove duplicated sysfs_ops structures
  - describe organization of sysfs
  - make devreq_mutex static
  - g_orangefs_stats -> orangefs_stats for consistency
  - rename most remaining global variables"

 "Pull in an OrangeFS branch containing improvements which the userspace
  component and the kernel to negotiate mutually supported features."
parents a21aae3b b78b1198

fs/orangefs/dcache.c

+1 −1
Original line number Diff line number Diff line
@@ -73,7 +73,7 @@ static int orangefs_revalidate_lookup(struct dentry *dentry) 
		}

	}



	dentry->d_time = jiffies + dcache_timeout_msecs*HZ/1000;

	dentry->d_time = jiffies + orangefs_dcache_timeout_msecs*HZ/1000;

	ret = 1;

out_release_op:

	op_release(new_op);

fs/orangefs/devorangefs-req.c

+26 −138
Original line number Diff line number Diff line
@@ -11,14 +11,19 @@ 
#include "orangefs-kernel.h"

#include "orangefs-dev-proto.h"

#include "orangefs-bufmap.h"

#include "orangefs-debugfs.h"



#include <linux/debugfs.h>

#include <linux/slab.h>



/* this file implements the /dev/pvfs2-req device node */



uint32_t orangefs_userspace_version;



static int open_access_count;



static DEFINE_MUTEX(devreq_mutex);



#define DUMP_DEVICE_ERROR()                                                   \

do {                                                                          \

	gossip_err("*****************************************************\n");\
@@ -43,7 +48,7 @@ static void orangefs_devreq_add_op(struct orangefs_kernel_op_s *op) 
{

	int index = hash_func(op->tag, hash_table_size);



	list_add_tail(&op->list, &htable_ops_in_progress[index]);

	list_add_tail(&op->list, &orangefs_htable_ops_in_progress[index]);

}



/*
@@ -57,20 +62,20 @@ static struct orangefs_kernel_op_s *orangefs_devreq_remove_op(__u64 tag) 


	index = hash_func(tag, hash_table_size);



	spin_lock(&htable_ops_in_progress_lock);

	spin_lock(&orangefs_htable_ops_in_progress_lock);

	list_for_each_entry_safe(op,

				 next,

				 &htable_ops_in_progress[index],

				 &orangefs_htable_ops_in_progress[index],

				 list) {

		if (op->tag == tag && !op_state_purged(op) &&

		    !op_state_given_up(op)) {

			list_del_init(&op->list);

			spin_unlock(&htable_ops_in_progress_lock);

			spin_unlock(&orangefs_htable_ops_in_progress_lock);

			return op;

		}

	}



	spin_unlock(&htable_ops_in_progress_lock);

	spin_unlock(&orangefs_htable_ops_in_progress_lock);

	return NULL;

}
@@ -276,11 +281,11 @@ static ssize_t orangefs_devreq_read(struct file *file, 
	if (ret != 0)

		goto error;



	spin_lock(&htable_ops_in_progress_lock);

	spin_lock(&orangefs_htable_ops_in_progress_lock);

	spin_lock(&cur_op->lock);

	if (unlikely(op_state_given_up(cur_op))) {

		spin_unlock(&cur_op->lock);

		spin_unlock(&htable_ops_in_progress_lock);

		spin_unlock(&orangefs_htable_ops_in_progress_lock);

		complete(&cur_op->waitq);

		goto restart;

	}
@@ -298,7 +303,7 @@ static ssize_t orangefs_devreq_read(struct file *file, 
		     current->comm);

	orangefs_devreq_add_op(cur_op);

	spin_unlock(&cur_op->lock);

	spin_unlock(&htable_ops_in_progress_lock);

	spin_unlock(&orangefs_htable_ops_in_progress_lock);



	/* The client only asks to read one size buffer. */

	return MAX_DEV_REQ_UPSIZE;
@@ -387,6 +392,13 @@ static ssize_t orangefs_devreq_write_iter(struct kiocb *iocb, 
		return -EPROTO;

	}



	if (!orangefs_userspace_version) {

		orangefs_userspace_version = head.version;

	} else if (orangefs_userspace_version != head.version) {

		gossip_err("Error: userspace version changes\n");

		return -EPROTO;

	}



	/* remove the op from the in progress hash table */

	op = orangefs_devreq_remove_op(head.tag);

	if (!op) {
@@ -527,6 +539,7 @@ static int orangefs_devreq_release(struct inode *inode, struct file *file) 
	gossip_debug(GOSSIP_DEV_DEBUG,

		     "pvfs2-client-core: device close complete\n");

	open_access_count = 0;

	orangefs_userspace_version = 0;

	mutex_unlock(&devreq_mutex);

	return 0;

}
@@ -576,8 +589,6 @@ static long dispatch_ioctl_command(unsigned int command, unsigned long arg) 
	static __s32 max_down_size = MAX_DEV_REQ_DOWNSIZE;

	struct ORANGEFS_dev_map_desc user_desc;

	int ret = 0;

	struct dev_mask_info_s mask_info = { 0 };

	struct dev_mask2_info_s mask2_info = { 0, 0 };

	int upstream_kmod = 1;

	struct orangefs_sb_info_s *orangefs_sb;
@@ -619,7 +630,7 @@ static long dispatch_ioctl_command(unsigned int command, unsigned long arg) 
		 * all of the remounts are serviced (to avoid ops between

		 * mounts to fail)

		 */

		ret = mutex_lock_interruptible(&request_mutex);

		ret = mutex_lock_interruptible(&orangefs_request_mutex);

		if (ret < 0)

			return ret;

		gossip_debug(GOSSIP_DEV_DEBUG,
@@ -654,7 +665,7 @@ static long dispatch_ioctl_command(unsigned int command, unsigned long arg) 
		gossip_debug(GOSSIP_DEV_DEBUG,

			     "%s: priority remount complete\n",

			     __func__);

		mutex_unlock(&request_mutex);

		mutex_unlock(&orangefs_request_mutex);

		return ret;



	case ORANGEFS_DEV_UPSTREAM:
@@ -668,134 +679,11 @@ static long dispatch_ioctl_command(unsigned int command, unsigned long arg) 
			return ret;



	case ORANGEFS_DEV_CLIENT_MASK:

		ret = copy_from_user(&mask2_info,

				     (void __user *)arg,

				     sizeof(struct dev_mask2_info_s));



		if (ret != 0)

			return -EIO;



		client_debug_mask.mask1 = mask2_info.mask1_value;

		client_debug_mask.mask2 = mask2_info.mask2_value;



		pr_info("%s: client debug mask has been been received "

			":%llx: :%llx:\n",

			__func__,

			(unsigned long long)client_debug_mask.mask1,

			(unsigned long long)client_debug_mask.mask2);



		return ret;



		return orangefs_debugfs_new_client_mask((void __user *)arg);

	case ORANGEFS_DEV_CLIENT_STRING:

		ret = copy_from_user(&client_debug_array_string,

				     (void __user *)arg,

				     ORANGEFS_MAX_DEBUG_STRING_LEN);

		/*

		 * The real client-core makes an effort to ensure

		 * that actual strings that aren't too long to fit in

		 * this buffer is what we get here. We're going to use

		 * string functions on the stuff we got, so we'll make

		 * this extra effort to try and keep from

		 * flowing out of this buffer when we use the string

		 * functions, even if somehow the stuff we end up

		 * with here is garbage.

		 */

		client_debug_array_string[ORANGEFS_MAX_DEBUG_STRING_LEN - 1] =

			'\0';

		

		if (ret != 0) {

			pr_info("%s: CLIENT_STRING: copy_from_user failed\n",

				__func__);

			return -EIO;

		}



		pr_info("%s: client debug array string has been received.\n",

			__func__);



		if (!help_string_initialized) {



			/* Free the "we don't know yet" default string... */

			kfree(debug_help_string);



			/* build a proper debug help string */

			if (orangefs_prepare_debugfs_help_string(0)) {

				gossip_err("%s: no debug help string \n",

					   __func__);

				return -EIO;

			}



			/* Replace the boilerplate boot-time debug-help file. */

			debugfs_remove(help_file_dentry);



			help_file_dentry =

				debugfs_create_file(

					ORANGEFS_KMOD_DEBUG_HELP_FILE,

					0444,

					debug_dir,

					debug_help_string,

					&debug_help_fops);



			if (!help_file_dentry) {

				gossip_err("%s: debugfs_create_file failed for"

					   " :%s:!\n",

					   __func__,

					   ORANGEFS_KMOD_DEBUG_HELP_FILE);

				return -EIO;

			}

		}



		debug_mask_to_string(&client_debug_mask, 1);



		debugfs_remove(client_debug_dentry);



		orangefs_client_debug_init();



		help_string_initialized++;



		return ret;



		return orangefs_debugfs_new_client_string((void __user *)arg);

	case ORANGEFS_DEV_DEBUG:

		ret = copy_from_user(&mask_info,

				     (void __user *)arg,

				     sizeof(mask_info));



		if (ret != 0)

			return -EIO;



		if (mask_info.mask_type == KERNEL_MASK) {

			if ((mask_info.mask_value == 0)

			    && (kernel_mask_set_mod_init)) {

				/*

				 * the kernel debug mask was set when the

				 * kernel module was loaded; don't override

				 * it if the client-core was started without

				 * a value for ORANGEFS_KMODMASK.

				 */

				return 0;

			}

			debug_mask_to_string(&mask_info.mask_value,

					     mask_info.mask_type);

			gossip_debug_mask = mask_info.mask_value;

			pr_info("%s: kernel debug mask has been modified to "

				":%s: :%llx:\n",

				__func__,

				kernel_debug_string,

				(unsigned long long)gossip_debug_mask);

		} else if (mask_info.mask_type == CLIENT_MASK) {

			debug_mask_to_string(&mask_info.mask_value,

					     mask_info.mask_type);

			pr_info("%s: client debug mask has been modified to"

				":%s: :%llx:\n",

				__func__,

				client_debug_string,

				llu(mask_info.mask_value));

		} else {

			gossip_lerr("Invalid mask type....\n");

			return -EINVAL;

		}



		return ret;



		return orangefs_debugfs_new_debug((void __user *)arg);

	default:

		return -ENOIOCTLCMD;

	}

fs/orangefs/downcall.h

+6 −0
Original line number Diff line number Diff line
@@ -101,6 +101,11 @@ struct orangefs_fs_key_response { 
	char fs_key[FS_KEY_BUF_SIZE];

};



/* 2.9.6 */

struct orangefs_features_response {

	__u64 features;

};



struct orangefs_downcall_s {

	__s32 type;

	__s32 status;
@@ -122,6 +127,7 @@ struct orangefs_downcall_s { 
		struct orangefs_param_response param;

		struct orangefs_perf_count_response perf_count;

		struct orangefs_fs_key_response fs_key;

		struct orangefs_features_response features;

	} resp;

};

fs/orangefs/file.c

+11 −8
Original line number Diff line number Diff line
@@ -412,7 +412,7 @@ ssize_t orangefs_inode_read(struct inode *inode, 
	size_t bufmap_size;

	ssize_t ret = -EINVAL;



	g_orangefs_stats.reads++;

	orangefs_stats.reads++;



	bufmap_size = orangefs_bufmap_size_query();

	if (count > bufmap_size) {
@@ -453,7 +453,7 @@ static ssize_t orangefs_file_read_iter(struct kiocb *iocb, struct iov_iter *iter 


	gossip_debug(GOSSIP_FILE_DEBUG, "orangefs_file_read_iter\n");



	g_orangefs_stats.reads++;

	orangefs_stats.reads++;



	rc = do_readv_writev(ORANGEFS_IO_READ, file, &pos, iter);

	iocb->ki_pos = pos;
@@ -514,7 +514,7 @@ static ssize_t orangefs_file_write_iter(struct kiocb *iocb, struct iov_iter *ite 
	}



	iocb->ki_pos = pos;

	g_orangefs_stats.writes++;

	orangefs_stats.writes++;



out:
@@ -624,11 +624,14 @@ static int orangefs_file_release(struct inode *inode, struct file *file) 
	if (file->f_path.dentry->d_inode &&

	    file->f_path.dentry->d_inode->i_mapping &&

	    mapping_nrpages(&file->f_path.dentry->d_inode->i_data)) {

		if (orangefs_features & ORANGEFS_FEATURE_READAHEAD) {

			gossip_debug(GOSSIP_INODE_DEBUG,

			    "calling flush_racache on %pU\n",

			    get_khandle_from_ino(inode));

			flush_racache(inode);

		gossip_debug(GOSSIP_INODE_DEBUG, "flush_racache finished\n");

			gossip_debug(GOSSIP_INODE_DEBUG,

			    "flush_racache finished\n");

		}

		truncate_inode_pages(file->f_path.dentry->d_inode->i_mapping,

				     0);

	}

fs/orangefs/namei.c

+4 −4
Original line number Diff line number Diff line
@@ -72,7 +72,7 @@ static int orangefs_create(struct inode *dir, 


	d_instantiate(dentry, inode);

	unlock_new_inode(inode);

	dentry->d_time = jiffies + dcache_timeout_msecs*HZ/1000;

	dentry->d_time = jiffies + orangefs_dcache_timeout_msecs*HZ/1000;

	ORANGEFS_I(inode)->getattr_time = jiffies - 1;



	gossip_debug(GOSSIP_NAME_DEBUG,
@@ -183,7 +183,7 @@ static struct dentry *orangefs_lookup(struct inode *dir, struct dentry *dentry, 
		goto out;

	}



	dentry->d_time = jiffies + dcache_timeout_msecs*HZ/1000;

	dentry->d_time = jiffies + orangefs_dcache_timeout_msecs*HZ/1000;



	inode = orangefs_iget(dir->i_sb, &new_op->downcall.resp.lookup.refn);

	if (IS_ERR(inode)) {
@@ -322,7 +322,7 @@ static int orangefs_symlink(struct inode *dir, 


	d_instantiate(dentry, inode);

	unlock_new_inode(inode);

	dentry->d_time = jiffies + dcache_timeout_msecs*HZ/1000;

	dentry->d_time = jiffies + orangefs_dcache_timeout_msecs*HZ/1000;

	ORANGEFS_I(inode)->getattr_time = jiffies - 1;



	gossip_debug(GOSSIP_NAME_DEBUG,
@@ -386,7 +386,7 @@ static int orangefs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode 


	d_instantiate(dentry, inode);

	unlock_new_inode(inode);

	dentry->d_time = jiffies + dcache_timeout_msecs*HZ/1000;

	dentry->d_time = jiffies + orangefs_dcache_timeout_msecs*HZ/1000;

	ORANGEFS_I(inode)->getattr_time = jiffies - 1;



	gossip_debug(GOSSIP_NAME_DEBUG,