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

Commit 31143d5d authored by David Howells's avatar David Howells Committed by Linus Torvalds
Browse files

AFS: implement basic file write support 



Implement support for writing to regular AFS files, including:

 (1) write

 (2) truncate

 (3) fsync, fdatasync

 (4) chmod, chown, chgrp, utime.

AFS writeback attempts to batch writes into as chunks as large as it can manage
up to the point that it writes back 65535 pages in one chunk or it meets a
locked page.

Furthermore, if a page has been written to using a particular key, then should
another write to that page use some other key, the first write will be flushed
before the second is allowed to take place.  If the first write fails due to a
security error, then the page will be scrapped and reread before the second
write takes place.

If a page is dirty and the callback on it is broken by the server, then the
dirty data is not discarded (same behaviour as NFS).

Shared-writable mappings are not supported by this patch.

[akpm@linux-foundation.org: fix a bunch of warnings]
Signed-off-by: default avatarDavid Howells <dhowells@redhat.com>
Signed-off-by: default avatarAndrew Morton <akpm@linux-foundation.org>
Signed-off-by: default avatarLinus Torvalds <torvalds@linux-foundation.org>
parent 416351f2

fs/afs/Makefile

+2 −1
Original line number Diff line number Diff line
@@ -22,6 +22,7 @@ kafs-objs := \ 
	vlclient.o \

	vlocation.o \

	vnode.o \

	volume.o

	volume.o \

	write.o



obj-$(CONFIG_AFS_FS)  := kafs.o

fs/afs/afs_fs.h

+2 −0
Original line number Diff line number Diff line
@@ -18,6 +18,8 @@ 
enum AFS_FS_Operations {

	FSFETCHDATA		= 130,	/* AFS Fetch file data */

	FSFETCHSTATUS		= 132,	/* AFS Fetch file status */

	FSSTOREDATA		= 133,	/* AFS Store file data */

	FSSTORESTATUS		= 135,	/* AFS Store file status */

	FSREMOVEFILE		= 136,	/* AFS Remove a file */

	FSCREATEFILE		= 137,	/* AFS Create a file */

	FSRENAME		= 138,	/* AFS Rename or move a file or directory */

fs/afs/dir.c

+1 −0
Original line number Diff line number Diff line
@@ -56,6 +56,7 @@ const struct inode_operations afs_dir_inode_operations = { 
	.rename		= afs_rename,

	.permission	= afs_permission,

	.getattr	= afs_getattr,

	.setattr	= afs_setattr,

};



static struct dentry_operations afs_fs_dentry_operations = {

fs/afs/file.c

+26 −6
Original line number Diff line number Diff line
@@ -15,32 +15,43 @@ 
#include <linux/slab.h>

#include <linux/fs.h>

#include <linux/pagemap.h>

#include <linux/writeback.h>

#include "internal.h"



static int afs_readpage(struct file *file, struct page *page);

static void afs_invalidatepage(struct page *page, unsigned long offset);

static int afs_releasepage(struct page *page, gfp_t gfp_flags);

static int afs_launder_page(struct page *page);



const struct file_operations afs_file_operations = {

	.open		= afs_open,

	.release	= afs_release,

	.llseek		= generic_file_llseek,

	.read		= do_sync_read,

	.write		= do_sync_write,

	.aio_read	= generic_file_aio_read,

	.aio_write	= afs_file_write,

	.mmap		= generic_file_readonly_mmap,

	.sendfile	= generic_file_sendfile,

	.fsync		= afs_fsync,

};



const struct inode_operations afs_file_inode_operations = {

	.getattr	= afs_getattr,

	.setattr	= afs_setattr,

	.permission	= afs_permission,

};



const struct address_space_operations afs_fs_aops = {

	.readpage	= afs_readpage,

	.set_page_dirty	= __set_page_dirty_nobuffers,

	.set_page_dirty	= afs_set_page_dirty,

	.launder_page	= afs_launder_page,

	.releasepage	= afs_releasepage,

	.invalidatepage	= afs_invalidatepage,

	.prepare_write	= afs_prepare_write,

	.commit_write	= afs_commit_write,

	.writepage	= afs_writepage,

	.writepages	= afs_writepages,

};



/*
@@ -230,11 +241,6 @@ static void afs_invalidatepage(struct page *page, unsigned long offset) 
	BUG_ON(!PageLocked(page));



	if (PagePrivate(page)) {

#ifdef AFS_CACHING_SUPPORT

		struct afs_vnode *vnode = AFS_FS_I(page->mapping->host);

		cachefs_uncache_page(vnode->cache,page);

#endif



		/* We release buffers only if the entire page is being

		 * invalidated.

		 * The get_block cached value has been unconditionally
@@ -254,20 +260,34 @@ static void afs_invalidatepage(struct page *page, unsigned long offset) 
	_leave(" = %d", ret);

}



/*

 * write back a dirty page

 */

static int afs_launder_page(struct page *page)

{

	_enter("{%lu}", page->index);



	return 0;

}



/*

 * release a page and cleanup its private data

 */

static int afs_releasepage(struct page *page, gfp_t gfp_flags)

{

	struct afs_vnode *vnode = AFS_FS_I(page->mapping->host);

	struct afs_writeback *wb;



	_enter("{{%x:%u}[%lu],%lx},%x",

	       vnode->fid.vid, vnode->fid.vnode, page->index, page->flags,

	       gfp_flags);



	if (PagePrivate(page)) {

		wb = (struct afs_writeback *) page_private(page);

		ASSERT(wb != NULL);

		set_page_private(page, 0);

		ClearPagePrivate(page);

		afs_put_writeback(wb);

	}



	_leave(" = 0");

fs/afs/fsclient.c

+319 −13
Original line number Diff line number Diff line
@@ -33,8 +33,10 @@ static void xdr_decode_AFSFid(const __be32 **_bp, struct afs_fid *fid) 
 */

static void xdr_decode_AFSFetchStatus(const __be32 **_bp,

				      struct afs_file_status *status,

				      struct afs_vnode *vnode)

				      struct afs_vnode *vnode,

				      afs_dataversion_t *store_version)

{

	afs_dataversion_t expected_version;

	const __be32 *bp = *_bp;

	umode_t mode;

	u64 data_version, size;
@@ -101,7 +103,11 @@ static void xdr_decode_AFSFetchStatus(const __be32 **_bp, 
		vnode->vfs_inode.i_atime	= vnode->vfs_inode.i_ctime;

	}



	if (status->data_version != data_version) {

	expected_version = status->data_version;

	if (store_version)

		expected_version = *store_version;



	if (expected_version != data_version) {

		status->data_version = data_version;

		if (vnode && !test_bit(AFS_VNODE_UNSET, &vnode->flags)) {

			_debug("vnode modified %llx on {%x:%u}",
@@ -110,6 +116,8 @@ static void xdr_decode_AFSFetchStatus(const __be32 **_bp, 
			set_bit(AFS_VNODE_MODIFIED, &vnode->flags);

			set_bit(AFS_VNODE_ZAP_DATA, &vnode->flags);

		}

	} else if (store_version) {

		status->data_version = data_version;

	}

}
@@ -155,6 +163,44 @@ static void xdr_decode_AFSVolSync(const __be32 **_bp, 
	*_bp = bp;

}



/*

 * encode the requested attributes into an AFSStoreStatus block

 */

static void xdr_encode_AFS_StoreStatus(__be32 **_bp, struct iattr *attr)

{

	__be32 *bp = *_bp;

	u32 mask = 0, mtime = 0, owner = 0, group = 0, mode = 0;



	mask = 0;

	if (attr->ia_valid & ATTR_MTIME) {

		mask |= AFS_SET_MTIME;

		mtime = attr->ia_mtime.tv_sec;

	}



	if (attr->ia_valid & ATTR_UID) {

		mask |= AFS_SET_OWNER;

		owner = attr->ia_uid;

	}



	if (attr->ia_valid & ATTR_GID) {

		mask |= AFS_SET_GROUP;

		group = attr->ia_gid;

	}



	if (attr->ia_valid & ATTR_MODE) {

		mask |= AFS_SET_MODE;

		mode = attr->ia_mode & S_IALLUGO;

	}



	*bp++ = htonl(mask);

	*bp++ = htonl(mtime);

	*bp++ = htonl(owner);

	*bp++ = htonl(group);

	*bp++ = htonl(mode);

	*bp++ = 0;		/* segment size */

	*_bp = bp;

}



/*

 * deliver reply data to an FS.FetchStatus

 */
@@ -175,7 +221,7 @@ static int afs_deliver_fs_fetch_status(struct afs_call *call, 


	/* unmarshall the reply once we've received all of it */

	bp = call->buffer;

	xdr_decode_AFSFetchStatus(&bp, &vnode->status, vnode);

	xdr_decode_AFSFetchStatus(&bp, &vnode->status, vnode, NULL);

	xdr_decode_AFSCallBack(&bp, vnode);

	if (call->reply2)

		xdr_decode_AFSVolSync(&bp, call->reply2);
@@ -295,7 +341,7 @@ static int afs_deliver_fs_fetch_data(struct afs_call *call, 
		}



		bp = call->buffer;

		xdr_decode_AFSFetchStatus(&bp, &vnode->status, vnode);

		xdr_decode_AFSFetchStatus(&bp, &vnode->status, vnode, NULL);

		xdr_decode_AFSCallBack(&bp, vnode);

		if (call->reply2)

			xdr_decode_AFSVolSync(&bp, call->reply2);
@@ -479,8 +525,8 @@ static int afs_deliver_fs_create_vnode(struct afs_call *call, 
	/* unmarshall the reply once we've received all of it */

	bp = call->buffer;

	xdr_decode_AFSFid(&bp, call->reply2);

	xdr_decode_AFSFetchStatus(&bp, call->reply3, NULL);

	xdr_decode_AFSFetchStatus(&bp, &vnode->status, vnode);

	xdr_decode_AFSFetchStatus(&bp, call->reply3, NULL, NULL);

	xdr_decode_AFSFetchStatus(&bp, &vnode->status, vnode, NULL);

	xdr_decode_AFSCallBack_raw(&bp, call->reply4);

	/* xdr_decode_AFSVolSync(&bp, call->replyX); */
@@ -577,7 +623,7 @@ static int afs_deliver_fs_remove(struct afs_call *call, 


	/* unmarshall the reply once we've received all of it */

	bp = call->buffer;

	xdr_decode_AFSFetchStatus(&bp, &vnode->status, vnode);

	xdr_decode_AFSFetchStatus(&bp, &vnode->status, vnode, NULL);

	/* xdr_decode_AFSVolSync(&bp, call->replyX); */



	_leave(" = 0 [done]");
@@ -660,8 +706,8 @@ static int afs_deliver_fs_link(struct afs_call *call, 


	/* unmarshall the reply once we've received all of it */

	bp = call->buffer;

	xdr_decode_AFSFetchStatus(&bp, &vnode->status, vnode);

	xdr_decode_AFSFetchStatus(&bp, &dvnode->status, dvnode);

	xdr_decode_AFSFetchStatus(&bp, &vnode->status, vnode, NULL);

	xdr_decode_AFSFetchStatus(&bp, &dvnode->status, dvnode, NULL);

	/* xdr_decode_AFSVolSync(&bp, call->replyX); */



	_leave(" = 0 [done]");
@@ -749,8 +795,8 @@ static int afs_deliver_fs_symlink(struct afs_call *call, 
	/* unmarshall the reply once we've received all of it */

	bp = call->buffer;

	xdr_decode_AFSFid(&bp, call->reply2);

	xdr_decode_AFSFetchStatus(&bp, call->reply3, NULL);

	xdr_decode_AFSFetchStatus(&bp, &vnode->status, vnode);

	xdr_decode_AFSFetchStatus(&bp, call->reply3, NULL, NULL);

	xdr_decode_AFSFetchStatus(&bp, &vnode->status, vnode, NULL);

	/* xdr_decode_AFSVolSync(&bp, call->replyX); */



	_leave(" = 0 [done]");
@@ -855,9 +901,10 @@ static int afs_deliver_fs_rename(struct afs_call *call, 


	/* unmarshall the reply once we've received all of it */

	bp = call->buffer;

	xdr_decode_AFSFetchStatus(&bp, &orig_dvnode->status, orig_dvnode);

	xdr_decode_AFSFetchStatus(&bp, &orig_dvnode->status, orig_dvnode, NULL);

	if (new_dvnode != orig_dvnode)

		xdr_decode_AFSFetchStatus(&bp, &new_dvnode->status, new_dvnode);

		xdr_decode_AFSFetchStatus(&bp, &new_dvnode->status, new_dvnode,

					  NULL);

	/* xdr_decode_AFSVolSync(&bp, call->replyX); */



	_leave(" = 0 [done]");
@@ -939,3 +986,262 @@ int afs_fs_rename(struct afs_server *server, 


	return afs_make_call(&server->addr, call, GFP_NOFS, wait_mode);

}



/*

 * deliver reply data to an FS.StoreData

 */

static int afs_deliver_fs_store_data(struct afs_call *call,

				     struct sk_buff *skb, bool last)

{

	struct afs_vnode *vnode = call->reply;

	const __be32 *bp;



	_enter(",,%u", last);



	afs_transfer_reply(call, skb);

	if (!last) {

		_leave(" = 0 [more]");

		return 0;

	}



	if (call->reply_size != call->reply_max) {

		_leave(" = -EBADMSG [%u != %u]",

		       call->reply_size, call->reply_max);

		return -EBADMSG;

	}



	/* unmarshall the reply once we've received all of it */

	bp = call->buffer;

	xdr_decode_AFSFetchStatus(&bp, &vnode->status, vnode,

				  &call->store_version);

	/* xdr_decode_AFSVolSync(&bp, call->replyX); */



	afs_pages_written_back(vnode, call);



	_leave(" = 0 [done]");

	return 0;

}



/*

 * FS.StoreData operation type

 */

static const struct afs_call_type afs_RXFSStoreData = {

	.name		= "FS.StoreData",

	.deliver	= afs_deliver_fs_store_data,

	.abort_to_error	= afs_abort_to_error,

	.destructor	= afs_flat_call_destructor,

};



/*

 * store a set of pages

 */

int afs_fs_store_data(struct afs_server *server, struct afs_writeback *wb,

		      pgoff_t first, pgoff_t last,

		      unsigned offset, unsigned to,

		      const struct afs_wait_mode *wait_mode)

{

	struct afs_vnode *vnode = wb->vnode;

	struct afs_call *call;

	loff_t size, pos, i_size;

	__be32 *bp;



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

	       key_serial(wb->key), vnode->fid.vid, vnode->fid.vnode);



	size = to - offset;

	if (first != last)

		size += (loff_t)(last - first) << PAGE_SHIFT;

	pos = (loff_t)first << PAGE_SHIFT;

	pos += offset;



	i_size = i_size_read(&vnode->vfs_inode);

	if (pos + size > i_size)

		i_size = size + pos;



	_debug("size %llx, at %llx, i_size %llx",

	       (unsigned long long) size, (unsigned long long) pos,

	       (unsigned long long) i_size);



	BUG_ON(i_size > 0xffffffff); // TODO: use 64-bit store



	call = afs_alloc_flat_call(&afs_RXFSStoreData,

				   (4 + 6 + 3) * 4,

				   (21 + 6) * 4);

	if (!call)

		return -ENOMEM;



	call->wb = wb;

	call->key = wb->key;

	call->reply = vnode;

	call->service_id = FS_SERVICE;

	call->port = htons(AFS_FS_PORT);

	call->mapping = vnode->vfs_inode.i_mapping;

	call->first = first;

	call->last = last;

	call->first_offset = offset;

	call->last_to = to;

	call->send_pages = true;

	call->store_version = vnode->status.data_version + 1;



	/* marshall the parameters */

	bp = call->request;

	*bp++ = htonl(FSSTOREDATA);

	*bp++ = htonl(vnode->fid.vid);

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

	*bp++ = htonl(vnode->fid.unique);



	*bp++ = 0; /* mask */

	*bp++ = 0; /* mtime */

	*bp++ = 0; /* owner */

	*bp++ = 0; /* group */

	*bp++ = 0; /* unix mode */

	*bp++ = 0; /* segment size */



	*bp++ = htonl(pos);

	*bp++ = htonl(size);

	*bp++ = htonl(i_size);



	return afs_make_call(&server->addr, call, GFP_NOFS, wait_mode);

}



/*

 * deliver reply data to an FS.StoreStatus

 */

static int afs_deliver_fs_store_status(struct afs_call *call,

				       struct sk_buff *skb, bool last)

{

	afs_dataversion_t *store_version;

	struct afs_vnode *vnode = call->reply;

	const __be32 *bp;



	_enter(",,%u", last);



	afs_transfer_reply(call, skb);

	if (!last) {

		_leave(" = 0 [more]");

		return 0;

	}



	if (call->reply_size != call->reply_max) {

		_leave(" = -EBADMSG [%u != %u]",

		       call->reply_size, call->reply_max);

		return -EBADMSG;

	}



	/* unmarshall the reply once we've received all of it */

	store_version = NULL;

	if (call->operation_ID == FSSTOREDATA)

		store_version = &call->store_version;



	bp = call->buffer;

	xdr_decode_AFSFetchStatus(&bp, &vnode->status, vnode, store_version);

	/* xdr_decode_AFSVolSync(&bp, call->replyX); */



	_leave(" = 0 [done]");

	return 0;

}



/*

 * FS.StoreStatus operation type

 */

static const struct afs_call_type afs_RXFSStoreStatus = {

	.name		= "FS.StoreStatus",

	.deliver	= afs_deliver_fs_store_status,

	.abort_to_error	= afs_abort_to_error,

	.destructor	= afs_flat_call_destructor,

};



static const struct afs_call_type afs_RXFSStoreData_as_Status = {

	.name		= "FS.StoreData",

	.deliver	= afs_deliver_fs_store_status,

	.abort_to_error	= afs_abort_to_error,

	.destructor	= afs_flat_call_destructor,

};



/*

 * set the attributes on a file, using FS.StoreData rather than FS.StoreStatus

 * so as to alter the file size also

 */

static int afs_fs_setattr_size(struct afs_server *server, struct key *key,

			       struct afs_vnode *vnode, struct iattr *attr,

			       const struct afs_wait_mode *wait_mode)

{

	struct afs_call *call;

	__be32 *bp;



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

	       key_serial(key), vnode->fid.vid, vnode->fid.vnode);



	ASSERT(attr->ia_valid & ATTR_SIZE);

	ASSERTCMP(attr->ia_size, <=, 0xffffffff); // TODO: use 64-bit store



	call = afs_alloc_flat_call(&afs_RXFSStoreData_as_Status,

				   (4 + 6 + 3) * 4,

				   (21 + 6) * 4);

	if (!call)

		return -ENOMEM;



	call->key = key;

	call->reply = vnode;

	call->service_id = FS_SERVICE;

	call->port = htons(AFS_FS_PORT);

	call->store_version = vnode->status.data_version + 1;

	call->operation_ID = FSSTOREDATA;



	/* marshall the parameters */

	bp = call->request;

	*bp++ = htonl(FSSTOREDATA);

	*bp++ = htonl(vnode->fid.vid);

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

	*bp++ = htonl(vnode->fid.unique);



	xdr_encode_AFS_StoreStatus(&bp, attr);



	*bp++ = 0;				/* position of start of write */

	*bp++ = 0;				/* size of write */

	*bp++ = htonl(attr->ia_size);		/* new file length */



	return afs_make_call(&server->addr, call, GFP_NOFS, wait_mode);

}



/*

 * set the attributes on a file, using FS.StoreData if there's a change in file

 * size, and FS.StoreStatus otherwise

 */

int afs_fs_setattr(struct afs_server *server, struct key *key,

		   struct afs_vnode *vnode, struct iattr *attr,

		   const struct afs_wait_mode *wait_mode)

{

	struct afs_call *call;

	__be32 *bp;



	if (attr->ia_valid & ATTR_SIZE)

		return afs_fs_setattr_size(server, key, vnode, attr,

					   wait_mode);



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

	       key_serial(key), vnode->fid.vid, vnode->fid.vnode);



	call = afs_alloc_flat_call(&afs_RXFSStoreStatus,

				   (4 + 6) * 4,

				   (21 + 6) * 4);

	if (!call)

		return -ENOMEM;



	call->key = key;

	call->reply = vnode;

	call->service_id = FS_SERVICE;

	call->port = htons(AFS_FS_PORT);

	call->operation_ID = FSSTORESTATUS;



	/* marshall the parameters */

	bp = call->request;

	*bp++ = htonl(FSSTORESTATUS);

	*bp++ = htonl(vnode->fid.vid);

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

	*bp++ = htonl(vnode->fid.unique);



	xdr_encode_AFS_StoreStatus(&bp, attr);



	return afs_make_call(&server->addr, call, GFP_NOFS, wait_mode);

}