Commit 5cf9dd55 authored by David Howells's avatar David Howells
Browse files

afs: Prospectively look up extra files when doing a single lookup 



When afs_lookup() is called, prospectively look up the next 50 uncached
fids also from that same directory and cache the results, rather than just
looking up the one file requested.

This allows us to use the FS.InlineBulkStatus RPC op to increase efficiency
by fetching up to 50 file statuses at a time.

Signed-off-by: default avatarDavid Howells <dhowells@redhat.com>
parent 17814aef

fs/afs/afs.h

+13 −8
Original line number Diff line number Diff line
@@ -67,10 +67,14 @@ typedef enum { 
} afs_callback_type_t;



struct afs_callback {

	struct afs_fid		fid;		/* file identifier */

	unsigned		version;	/* callback version */

	unsigned		expiry;		/* time at which expires */

	afs_callback_type_t	type;		/* type of callback */

	unsigned		version;	/* Callback version */

	unsigned		expiry;		/* Time at which expires */

	afs_callback_type_t	type;		/* Type of callback */

};



struct afs_callback_break {

	struct afs_fid		fid;		/* File identifier */

	struct afs_callback	cb;		/* Callback details */

};



#define AFSCBMAX 50	/* maximum callbacks transferred per bulk op */
@@ -123,21 +127,22 @@ typedef u32 afs_access_t; 
 * AFS file status information

 */

struct afs_file_status {

	u64			size;		/* file size */

	afs_dataversion_t	data_version;	/* current data version */

	time_t			mtime_client;	/* last time client changed data */

	time_t			mtime_server;	/* last time server changed data */

	unsigned		if_version;	/* interface version */

#define AFS_FSTATUS_VERSION	1

	unsigned		abort_code;	/* Abort if bulk-fetching this failed */



	afs_file_type_t		type;		/* file type */

	unsigned		nlink;		/* link count */

	u64			size;		/* file size */

	afs_dataversion_t	data_version;	/* current data version */

	u32			author;		/* author ID */

	kuid_t			owner;		/* owner ID */

	kgid_t			group;		/* group ID */

	afs_access_t		caller_access;	/* access rights for authenticated caller */

	afs_access_t		anon_access;	/* access rights for unauthenticated caller */

	umode_t			mode;		/* UNIX mode */

	time_t			mtime_client;	/* last time client changed data */

	time_t			mtime_server;	/* last time server changed data */

	s32			lock_count;	/* file lock count (0=UNLK -1=WRLCK +ve=#RDLCK */

};

fs/afs/afs_fs.h

+2 −0
Original line number Diff line number Diff line
@@ -31,10 +31,12 @@ enum AFS_FS_Operations { 
	FSGETVOLUMEINFO		= 148,	/* AFS Get information about a volume */

	FSGETVOLUMESTATUS	= 149,	/* AFS Get volume status information */

	FSGETROOTVOLUME		= 151,	/* AFS Get root volume name */

	FSBULKSTATUS		= 155,	/* AFS Fetch multiple file statuses */

	FSSETLOCK		= 156,	/* AFS Request a file lock */

	FSEXTENDLOCK		= 157,	/* AFS Extend a file lock */

	FSRELEASELOCK		= 158,	/* AFS Release a file lock */

	FSLOOKUP		= 161,	/* AFS lookup file in directory */

	FSINLINEBULKSTATUS	= 65536, /* AFS Fetch multiple file statuses with inline errors */

	FSFETCHDATA64		= 65537, /* AFS Fetch file data */

	FSSTOREDATA64		= 65538, /* AFS Store file data */

	FSGIVEUPALLCALLBACKS	= 65539, /* AFS Give up all outstanding callbacks on a server */

fs/afs/callback.c

+4 −4
Original line number Diff line number Diff line
@@ -187,7 +187,7 @@ static void afs_break_one_callback(struct afs_server *server, 
 * allow the fileserver to break callback promises

 */

void afs_break_callbacks(struct afs_server *server, size_t count,

			 struct afs_callback callbacks[])

			 struct afs_callback_break *callbacks)

{

	_enter("%p,%zu,", server, count);
@@ -199,9 +199,9 @@ void afs_break_callbacks(struct afs_server *server, size_t count, 
		       callbacks->fid.vid,

		       callbacks->fid.vnode,

		       callbacks->fid.unique,

		       callbacks->version,

		       callbacks->expiry,

		       callbacks->type

		       callbacks->cb.version,

		       callbacks->cb.expiry,

		       callbacks->cb.type

		       );

		afs_break_one_callback(server, &callbacks->fid);

	}

fs/afs/cmservice.c

+6 −6
Original line number Diff line number Diff line
@@ -178,8 +178,8 @@ static void SRXAFSCB_CallBack(struct work_struct *work) 
 */

static int afs_deliver_cb_callback(struct afs_call *call)

{

	struct afs_callback_break *cb;

	struct sockaddr_rxrpc srx;

	struct afs_callback *cb;

	struct afs_server *server;

	__be32 *bp;

	int ret, loop;
@@ -218,7 +218,7 @@ static int afs_deliver_cb_callback(struct afs_call *call) 


		_debug("unmarshall FID array");

		call->request = kcalloc(call->count,

					sizeof(struct afs_callback),

					sizeof(struct afs_callback_break),

					GFP_KERNEL);

		if (!call->request)

			return -ENOMEM;
@@ -229,7 +229,7 @@ static int afs_deliver_cb_callback(struct afs_call *call) 
			cb->fid.vid	= ntohl(*bp++);

			cb->fid.vnode	= ntohl(*bp++);

			cb->fid.unique	= ntohl(*bp++);

			cb->type	= AFSCM_CB_UNTYPED;

			cb->cb.type	= AFSCM_CB_UNTYPED;

		}



		call->offset = 0;
@@ -260,9 +260,9 @@ static int afs_deliver_cb_callback(struct afs_call *call) 
		cb = call->request;

		bp = call->buffer;

		for (loop = call->count2; loop > 0; loop--, cb++) {

			cb->version	= ntohl(*bp++);

			cb->expiry	= ntohl(*bp++);

			cb->type	= ntohl(*bp++);

			cb->cb.version	= ntohl(*bp++);

			cb->cb.expiry	= ntohl(*bp++);

			cb->cb.type	= ntohl(*bp++);

		}



		call->offset = 0;

fs/afs/dir.c

+250 −38
Original line number Diff line number Diff line
@@ -29,6 +29,8 @@ static int afs_readdir(struct file *file, struct dir_context *ctx); 
static int afs_d_revalidate(struct dentry *dentry, unsigned int flags);

static int afs_d_delete(const struct dentry *dentry);

static void afs_d_release(struct dentry *dentry);

static int afs_lookup_one_filldir(struct dir_context *ctx, const char *name, int nlen,

				  loff_t fpos, u64 ino, unsigned dtype);

static int afs_lookup_filldir(struct dir_context *ctx, const char *name, int nlen,

			      loff_t fpos, u64 ino, unsigned dtype);

static int afs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
@@ -134,11 +136,22 @@ struct afs_dir_page { 
	union afs_dir_block blocks[PAGE_SIZE / sizeof(union afs_dir_block)];

};



struct afs_lookup_cookie {

struct afs_lookup_one_cookie {

	struct dir_context	ctx;

	struct qstr		name;

	bool			found;

	struct afs_fid		fid;

};



struct afs_lookup_cookie {

	struct dir_context	ctx;

	struct qstr		name;

	int		found;

	bool			found;

	bool			one_only;

	unsigned short		nr_fids;

	struct afs_file_status	*statuses;

	struct afs_callback	*callbacks;

	struct afs_fid		fids[50];

};



/*
@@ -330,7 +343,8 @@ static int afs_dir_iterate_block(struct dir_context *ctx, 
		/* found the next entry */

		if (!dir_emit(ctx, dire->u.name, nlen,

			      ntohl(dire->u.vnode),

			      ctx->actor == afs_lookup_filldir ?

			      (ctx->actor == afs_lookup_filldir ||

			       ctx->actor == afs_lookup_one_filldir)?

			      ntohl(dire->u.unique) : DT_UNKNOWN)) {

			_leave(" = 0 [full]");

			return 0;
@@ -414,15 +428,15 @@ static int afs_readdir(struct file *file, struct dir_context *ctx) 
}



/*

 * search the directory for a name

 * Search the directory for a single name

 * - if afs_dir_iterate_block() spots this function, it'll pass the FID

 *   uniquifier through dtype

 */

static int afs_lookup_filldir(struct dir_context *ctx, const char *name,

static int afs_lookup_one_filldir(struct dir_context *ctx, const char *name,

				  int nlen, loff_t fpos, u64 ino, unsigned dtype)

{

	struct afs_lookup_cookie *cookie =

		container_of(ctx, struct afs_lookup_cookie, ctx);

	struct afs_lookup_one_cookie *cookie =

		container_of(ctx, struct afs_lookup_one_cookie, ctx);



	_enter("{%s,%u},%s,%u,,%llu,%u",

	       cookie->name.name, cookie->name.len, name, nlen,
@@ -447,15 +461,15 @@ static int afs_lookup_filldir(struct dir_context *ctx, const char *name, 
}



/*

 * do a lookup in a directory

 * Do a lookup of a single name in a directory

 * - just returns the FID the dentry name maps to if found

 */

static int afs_do_lookup(struct inode *dir, struct dentry *dentry,

static int afs_do_lookup_one(struct inode *dir, struct dentry *dentry,

			     struct afs_fid *fid, struct key *key)

{

	struct afs_super_info *as = dir->i_sb->s_fs_info;

	struct afs_lookup_cookie cookie = {

		.ctx.actor = afs_lookup_filldir,

	struct afs_lookup_one_cookie cookie = {

		.ctx.actor = afs_lookup_one_filldir,

		.name = dentry->d_name,

		.fid.vid = as->volume->vid

	};
@@ -481,6 +495,212 @@ static int afs_do_lookup(struct inode *dir, struct dentry *dentry, 
	return 0;

}



/*

 * search the directory for a name

 * - if afs_dir_iterate_block() spots this function, it'll pass the FID

 *   uniquifier through dtype

 */

static int afs_lookup_filldir(struct dir_context *ctx, const char *name,

			      int nlen, loff_t fpos, u64 ino, unsigned dtype)

{

	struct afs_lookup_cookie *cookie =

		container_of(ctx, struct afs_lookup_cookie, ctx);

	int ret;



	_enter("{%s,%u},%s,%u,,%llu,%u",

	       cookie->name.name, cookie->name.len, name, nlen,

	       (unsigned long long) ino, dtype);



	/* insanity checks first */

	BUILD_BUG_ON(sizeof(union afs_dir_block) != 2048);

	BUILD_BUG_ON(sizeof(union afs_dirent) != 32);



	if (cookie->found) {

		if (cookie->nr_fids < 50) {

			cookie->fids[cookie->nr_fids].vnode	= ino;

			cookie->fids[cookie->nr_fids].unique	= dtype;

			cookie->nr_fids++;

		}

	} else if (cookie->name.len == nlen &&

		   memcmp(cookie->name.name, name, nlen) == 0) {

		cookie->fids[0].vnode	= ino;

		cookie->fids[0].unique	= dtype;

		cookie->found = 1;

		if (cookie->one_only)

			return -1;

	}



	ret = cookie->nr_fids >= 50 ? -1 : 0;

	_leave(" = %d", ret);

	return ret;

}



/*

 * Do a lookup in a directory.  We make use of bulk lookup to query a slew of

 * files in one go and create inodes for them.  The inode of the file we were

 * asked for is returned.

 */

static struct inode *afs_do_lookup(struct inode *dir, struct dentry *dentry,

				   struct key *key)

{

	struct afs_lookup_cookie *cookie;

	struct afs_cb_interest *cbi = NULL;

	struct afs_super_info *as = dir->i_sb->s_fs_info;

	struct afs_iget_data data;

	struct afs_fs_cursor fc;

	struct afs_vnode *dvnode = AFS_FS_I(dir);

	struct inode *inode = NULL;

	int ret, i;



	_enter("{%lu},%p{%pd},", dir->i_ino, dentry, dentry);



	cookie = kzalloc(sizeof(struct afs_lookup_cookie), GFP_KERNEL);

	if (!cookie)

		return ERR_PTR(-ENOMEM);



	cookie->ctx.actor = afs_lookup_filldir;

	cookie->name = dentry->d_name;

	cookie->nr_fids = 1; /* slot 0 is saved for the fid we actually want */



	read_seqlock_excl(&dvnode->cb_lock);

	if (dvnode->cb_interest &&

	    dvnode->cb_interest->server &&

	    test_bit(AFS_SERVER_FL_NO_IBULK, &dvnode->cb_interest->server->flags))

		cookie->one_only = true;

	read_sequnlock_excl(&dvnode->cb_lock);



	for (i = 0; i < 50; i++)

		cookie->fids[i].vid = as->volume->vid;



	/* search the directory */

	ret = afs_dir_iterate(dir, &cookie->ctx, key);

	if (ret < 0) {

		inode = ERR_PTR(ret);

		goto out;

	}



	inode = ERR_PTR(-ENOENT);

	if (!cookie->found)

		goto out;



	/* Check to see if we already have an inode for the primary fid. */

	data.volume = dvnode->volume;

	data.fid = cookie->fids[0];

	inode = ilookup5(dir->i_sb, cookie->fids[0].vnode, afs_iget5_test, &data);

	if (inode)

		goto out;



	/* Need space for examining all the selected files */

	inode = ERR_PTR(-ENOMEM);

	cookie->statuses = kcalloc(cookie->nr_fids, sizeof(struct afs_file_status),

				   GFP_KERNEL);

	if (!cookie->statuses)

		goto out;



	cookie->callbacks = kcalloc(cookie->nr_fids, sizeof(struct afs_callback),

				    GFP_KERNEL);

	if (!cookie->callbacks)

		goto out_s;



	/* Try FS.InlineBulkStatus first.  Abort codes for the individual

	 * lookups contained therein are stored in the reply without aborting

	 * the whole operation.

	 */

	if (cookie->one_only)

		goto no_inline_bulk_status;



	inode = ERR_PTR(-ERESTARTSYS);

	if (afs_begin_vnode_operation(&fc, dvnode, key)) {

		while (afs_select_fileserver(&fc)) {

			if (test_bit(AFS_SERVER_FL_NO_IBULK,

				      &fc.cbi->server->flags)) {

				fc.ac.abort_code = RX_INVALID_OPERATION;

				fc.ac.error = -ECONNABORTED;

				break;

			}

			afs_fs_inline_bulk_status(&fc,

						  afs_v2net(dvnode),

						  cookie->fids,

						  cookie->statuses,

						  cookie->callbacks,

						  cookie->nr_fids, NULL);

		}



		if (fc.ac.error == 0)

			cbi = afs_get_cb_interest(fc.cbi);

		if (fc.ac.abort_code == RX_INVALID_OPERATION)

			set_bit(AFS_SERVER_FL_NO_IBULK, &fc.cbi->server->flags);

		inode = ERR_PTR(afs_end_vnode_operation(&fc));

	}



	if (!IS_ERR(inode))

		goto success;

	if (fc.ac.abort_code != RX_INVALID_OPERATION)

		goto out_c;



no_inline_bulk_status:

	/* We could try FS.BulkStatus next, but this aborts the entire op if

	 * any of the lookups fails - so, for the moment, revert to

	 * FS.FetchStatus for just the primary fid.

	 */

	cookie->nr_fids = 1;

	inode = ERR_PTR(-ERESTARTSYS);

	if (afs_begin_vnode_operation(&fc, dvnode, key)) {

		while (afs_select_fileserver(&fc)) {

			afs_fs_fetch_status(&fc,

					    afs_v2net(dvnode),

					    cookie->fids,

					    cookie->statuses,

					    cookie->callbacks,

					    NULL);

		}



		if (fc.ac.error == 0)

			cbi = afs_get_cb_interest(fc.cbi);

		inode = ERR_PTR(afs_end_vnode_operation(&fc));

	}



	if (IS_ERR(inode))

		goto out_c;



	for (i = 0; i < cookie->nr_fids; i++)

		cookie->statuses[i].abort_code = 0;



success:

	/* Turn all the files into inodes and save the first one - which is the

	 * one we actually want.

	 */

	if (cookie->statuses[0].abort_code != 0)

		inode = ERR_PTR(afs_abort_to_error(cookie->statuses[0].abort_code));



	for (i = 0; i < cookie->nr_fids; i++) {

		struct inode *ti;



		if (cookie->statuses[i].abort_code != 0)

			continue;



		ti = afs_iget(dir->i_sb, key, &cookie->fids[i],

			      &cookie->statuses[i],

			      &cookie->callbacks[i],

			      cbi);

		if (i == 0) {

			inode = ti;

		} else {

			if (!IS_ERR(ti))

				iput(ti);

		}

	}



out_c:

	afs_put_cb_interest(afs_v2net(dvnode), cbi);

	kfree(cookie->callbacks);

out_s:

	kfree(cookie->statuses);

out:

	kfree(cookie);

	return inode;

}



/*

 * Probe to see if a cell may exist.  This prevents positive dentries from

 * being created unnecessarily.
@@ -516,8 +736,7 @@ static int afs_probe_cell_name(struct dentry *dentry) 
 * Try to auto mount the mountpoint with pseudo directory, if the autocell

 * operation is setted.

 */

static struct inode *afs_try_auto_mntpt(struct dentry *dentry,

					struct inode *dir, struct afs_fid *fid)

static struct inode *afs_try_auto_mntpt(struct dentry *dentry, struct inode *dir)

{

	struct afs_vnode *vnode = AFS_FS_I(dir);

	struct inode *inode;
@@ -539,7 +758,6 @@ static struct inode *afs_try_auto_mntpt(struct dentry *dentry, 
		goto out;

	}



	*fid = AFS_FS_I(inode)->fid;

	_leave("= %p", inode);

	return inode;
@@ -554,16 +772,13 @@ out: 
static struct dentry *afs_lookup(struct inode *dir, struct dentry *dentry,

				 unsigned int flags)

{

	struct afs_vnode *vnode;

	struct afs_fid fid;

	struct afs_vnode *dvnode = AFS_FS_I(dir);

	struct inode *inode;

	struct key *key;

	int ret;



	vnode = AFS_FS_I(dir);



	_enter("{%x:%u},%p{%pd},",

	       vnode->fid.vid, vnode->fid.vnode, dentry, dentry);

	       dvnode->fid.vid, dvnode->fid.vnode, dentry, dentry);



	ASSERTCMP(d_inode(dentry), ==, NULL);
@@ -572,28 +787,29 @@ static struct dentry *afs_lookup(struct inode *dir, struct dentry *dentry, 
		return ERR_PTR(-ENAMETOOLONG);

	}



	if (test_bit(AFS_VNODE_DELETED, &vnode->flags)) {

	if (test_bit(AFS_VNODE_DELETED, &dvnode->flags)) {

		_leave(" = -ESTALE");

		return ERR_PTR(-ESTALE);

	}



	key = afs_request_key(vnode->volume->cell);

	key = afs_request_key(dvnode->volume->cell);

	if (IS_ERR(key)) {

		_leave(" = %ld [key]", PTR_ERR(key));

		return ERR_CAST(key);

	}



	ret = afs_validate(vnode, key);

	ret = afs_validate(dvnode, key);

	if (ret < 0) {

		key_put(key);

		_leave(" = %d [val]", ret);

		return ERR_PTR(ret);

	}



	ret = afs_do_lookup(dir, dentry, &fid, key);

	if (ret < 0) {

	inode = afs_do_lookup(dir, dentry, key);

	if (IS_ERR(inode)) {

		ret = PTR_ERR(inode);

		if (ret == -ENOENT) {

			inode = afs_try_auto_mntpt(dentry, dir, &fid);

			inode = afs_try_auto_mntpt(dentry, dir);

			if (!IS_ERR(inode)) {

				key_put(key);

				goto success;
@@ -611,10 +827,9 @@ static struct dentry *afs_lookup(struct inode *dir, struct dentry *dentry, 
		_leave(" = %d [do]", ret);

		return ERR_PTR(ret);

	}

	dentry->d_fsdata = (void *)(unsigned long) vnode->status.data_version;

	dentry->d_fsdata = (void *)(unsigned long)dvnode->status.data_version;



	/* instantiate the dentry */

	inode = afs_iget(dir->i_sb, key, &fid, NULL, NULL, NULL);

	key_put(key);

	if (IS_ERR(inode)) {

		_leave(" = %ld", PTR_ERR(inode));
@@ -623,9 +838,7 @@ static struct dentry *afs_lookup(struct inode *dir, struct dentry *dentry, 


success:

	d_add(dentry, inode);

	_leave(" = 0 { vn=%u u=%u } -> { ino=%lu v=%u }",

	       fid.vnode,

	       fid.unique,

	_leave(" = 0 { ino=%lu v=%u }",

	       d_inode(dentry)->i_ino,

	       d_inode(dentry)->i_generation);
@@ -639,7 +852,6 @@ static struct dentry *afs_dynroot_lookup(struct inode *dir, struct dentry *dentr 
					 unsigned int flags)

{

	struct afs_vnode *vnode;

	struct afs_fid fid;

	struct inode *inode;

	int ret;
@@ -654,7 +866,7 @@ static struct dentry *afs_dynroot_lookup(struct inode *dir, struct dentry *dentr 
		return ERR_PTR(-ENAMETOOLONG);

	}



	inode = afs_try_auto_mntpt(dentry, dir, &fid);

	inode = afs_try_auto_mntpt(dentry, dir);

	if (IS_ERR(inode)) {

		ret = PTR_ERR(inode);

		if (ret == -ENOENT) {
@@ -736,7 +948,7 @@ static int afs_d_revalidate(struct dentry *dentry, unsigned int flags) 
	_debug("dir modified");



	/* search the directory for this vnode */

	ret = afs_do_lookup(&dir->vfs_inode, dentry, &fid, key);

	ret = afs_do_lookup_one(&dir->vfs_inode, dentry, &fid, key);

	switch (ret) {

	case 0:

		/* the filename maps to something */

CRA Git | Maintained and supported by SUSTech CRA and CCSE