Commit f89ce84b authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag '9p-for-5.16-rc1' of git://github.com/martinetd/linux 

Pull 9p updates from Dominique Martinet:
 "Fixes, netfs read support and checkpatch rewrite:

   - fix syzcaller uninitialized value usage after missing error check

   - add module autoloading based on transport name

   - convert cached reads to use netfs helpers

   - adjust readahead based on transport msize

   - and many, many checkpatch.pl warning fixes..."

* tag '9p-for-5.16-rc1' of git://github.com/martinetd/linux:
  9p: fix a bunch of checkpatch warnings
  9p: set readahead and io size according to maxsize
  9p p9mode2perm: remove useless strlcpy and check sscanf return code
  9p v9fs_parse_options: replace simple_strtoul with kstrtouint
  9p: fix file headers
  fs/9p: fix indentation and Add missing a blank line after declaration
  fs/9p: fix warnings found by checkpatch.pl
  9p: fix minor indentation and codestyle
  fs/9p: cleanup: opening brace at the beginning of the next line
  9p: Convert to using the netfs helper lib to do reads and caching
  fscache_cookie_enabled: check cookie is valid before accessing it
  net/9p: autoload transport modules
  9p/net: fix missing error check in p9_check_errors
parents 59a2ceee 6e195b0f

fs/9p/Kconfig

+1 −0
Original line number Diff line number Diff line
@@ -2,6 +2,7 @@ 
config 9P_FS

	tristate "Plan 9 Resource Sharing Support (9P2000)"

	depends on INET && NET_9P

	select NETFS_SUPPORT

	help

	  If you say Y here, you will get experimental support for

	  Plan 9 resource sharing via the 9P2000 protocol.

fs/9p/acl.c

+2 −9
Original line number Diff line number Diff line 
// SPDX-License-Identifier: LGPL-2.1

/*

 * Copyright IBM Corporation, 2010

 * Author Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>

 *

 * This program is free software; you can redistribute it and/or modify it

 * under the terms of version 2.1 of the GNU Lesser General Public License

 * as published by the Free Software Foundation.

 *

 * This program is distributed in the hope that it would be useful, but

 * WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

 *

 */



#include <linux/module.h>
@@ -123,6 +115,7 @@ static int v9fs_set_acl(struct p9_fid *fid, int type, struct posix_acl *acl) 
	char *name;

	size_t size;

	void *buffer;



	if (!acl)

		return 0;

fs/9p/acl.h

+10 −17
Original line number Diff line number Diff line 
/* SPDX-License-Identifier: LGPL-2.1 */

/*

 * Copyright IBM Corporation, 2010

 * Author Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>

 *

 * This program is free software; you can redistribute it and/or modify it

 * under the terms of version 2.1 of the GNU Lesser General Public License

 * as published by the Free Software Foundation.

 *

 * This program is distributed in the hope that it would be useful, but

 * WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

 *

 */

#ifndef FS_9P_ACL_H

#define FS_9P_ACL_H



#ifdef CONFIG_9P_FS_POSIX_ACL

extern int v9fs_get_acl(struct inode *, struct p9_fid *);

extern struct posix_acl *v9fs_iop_get_acl(struct inode *inode, int type, bool rcu);

extern int v9fs_acl_chmod(struct inode *, struct p9_fid *);

extern int v9fs_set_create_acl(struct inode *, struct p9_fid *,

			       struct posix_acl *, struct posix_acl *);

extern int v9fs_acl_mode(struct inode *dir, umode_t *modep,

int v9fs_get_acl(struct inode *inode, struct p9_fid *fid);

struct posix_acl *v9fs_iop_get_acl(struct inode *inode, int type,

				   bool rcu);

int v9fs_acl_chmod(struct inode *inode, struct p9_fid *fid);

int v9fs_set_create_acl(struct inode *inode, struct p9_fid *fid,

			struct posix_acl *dacl, struct posix_acl *acl);

int v9fs_acl_mode(struct inode *dir, umode_t *modep,

		  struct posix_acl **dpacl, struct posix_acl **pacl);

extern void v9fs_put_acl(struct posix_acl *dacl, struct posix_acl *acl);

void v9fs_put_acl(struct posix_acl *dacl, struct posix_acl *acl);

#else

#define v9fs_iop_get_acl NULL

static inline int v9fs_get_acl(struct inode *inode, struct p9_fid *fid)

fs/9p/cache.c

+2 −139
Original line number Diff line number Diff line
@@ -199,140 +199,3 @@ void v9fs_cache_inode_reset_cookie(struct inode *inode) 


	mutex_unlock(&v9inode->fscache_lock);

}
 


int __v9fs_fscache_release_page(struct page *page, gfp_t gfp)

{

	struct inode *inode = page->mapping->host;

	struct v9fs_inode *v9inode = V9FS_I(inode);



	BUG_ON(!v9inode->fscache);



	return fscache_maybe_release_page(v9inode->fscache, page, gfp);

}



void __v9fs_fscache_invalidate_page(struct page *page)

{

	struct inode *inode = page->mapping->host;

	struct v9fs_inode *v9inode = V9FS_I(inode);



	BUG_ON(!v9inode->fscache);



	if (PageFsCache(page)) {

		fscache_wait_on_page_write(v9inode->fscache, page);

		BUG_ON(!PageLocked(page));

		fscache_uncache_page(v9inode->fscache, page);

	}

}



static void v9fs_vfs_readpage_complete(struct page *page, void *data,

				       int error)

{

	if (!error)

		SetPageUptodate(page);



	unlock_page(page);

}



/*

 * __v9fs_readpage_from_fscache - read a page from cache

 *

 * Returns 0 if the pages are in cache and a BIO is submitted,

 * 1 if the pages are not in cache and -error otherwise.

 */



int __v9fs_readpage_from_fscache(struct inode *inode, struct page *page)

{

	int ret;

	const struct v9fs_inode *v9inode = V9FS_I(inode);



	p9_debug(P9_DEBUG_FSC, "inode %p page %p\n", inode, page);

	if (!v9inode->fscache)

		return -ENOBUFS;



	ret = fscache_read_or_alloc_page(v9inode->fscache,

					 page,

					 v9fs_vfs_readpage_complete,

					 NULL,

					 GFP_KERNEL);

	switch (ret) {

	case -ENOBUFS:

	case -ENODATA:

		p9_debug(P9_DEBUG_FSC, "page/inode not in cache %d\n", ret);

		return 1;

	case 0:

		p9_debug(P9_DEBUG_FSC, "BIO submitted\n");

		return ret;

	default:

		p9_debug(P9_DEBUG_FSC, "ret %d\n", ret);

		return ret;

	}

}



/*

 * __v9fs_readpages_from_fscache - read multiple pages from cache

 *

 * Returns 0 if the pages are in cache and a BIO is submitted,

 * 1 if the pages are not in cache and -error otherwise.

 */



int __v9fs_readpages_from_fscache(struct inode *inode,

				  struct address_space *mapping,

				  struct list_head *pages,

				  unsigned *nr_pages)

{

	int ret;

	const struct v9fs_inode *v9inode = V9FS_I(inode);



	p9_debug(P9_DEBUG_FSC, "inode %p pages %u\n", inode, *nr_pages);

	if (!v9inode->fscache)

		return -ENOBUFS;



	ret = fscache_read_or_alloc_pages(v9inode->fscache,

					  mapping, pages, nr_pages,

					  v9fs_vfs_readpage_complete,

					  NULL,

					  mapping_gfp_mask(mapping));

	switch (ret) {

	case -ENOBUFS:

	case -ENODATA:

		p9_debug(P9_DEBUG_FSC, "pages/inodes not in cache %d\n", ret);

		return 1;

	case 0:

		BUG_ON(!list_empty(pages));

		BUG_ON(*nr_pages != 0);

		p9_debug(P9_DEBUG_FSC, "BIO submitted\n");

		return ret;

	default:

		p9_debug(P9_DEBUG_FSC, "ret %d\n", ret);

		return ret;

	}

}



/*

 * __v9fs_readpage_to_fscache - write a page to the cache

 *

 */



void __v9fs_readpage_to_fscache(struct inode *inode, struct page *page)

{

	int ret;

	const struct v9fs_inode *v9inode = V9FS_I(inode);



	p9_debug(P9_DEBUG_FSC, "inode %p page %p\n", inode, page);

	ret = fscache_write_page(v9inode->fscache, page,

				 i_size_read(&v9inode->vfs_inode), GFP_KERNEL);

	p9_debug(P9_DEBUG_FSC, "ret =  %d\n", ret);

	if (ret != 0)

		v9fs_uncache_page(inode, page);

}



/*

 * wait for a page to complete writing to the cache

 */

void __v9fs_fscache_wait_on_page_write(struct inode *inode, struct page *page)

{

	const struct v9fs_inode *v9inode = V9FS_I(inode);

	p9_debug(P9_DEBUG_FSC, "inode %p page %p\n", inode, page);

	if (PageFsCache(page))

		fscache_wait_on_page_write(v9inode->fscache, page);

}

fs/9p/cache.h

+3 −94
Original line number Diff line number Diff line
@@ -7,9 +7,10 @@ 


#ifndef _9P_CACHE_H

#define _9P_CACHE_H

#ifdef CONFIG_9P_FSCACHE

#define FSCACHE_USE_NEW_IO_API

#include <linux/fscache.h>

#include <linux/spinlock.h>



#ifdef CONFIG_9P_FSCACHE



extern struct fscache_netfs v9fs_cache_netfs;

extern const struct fscache_cookie_def v9fs_cache_session_index_def;
@@ -27,64 +28,6 @@ extern void v9fs_cache_inode_reset_cookie(struct inode *inode); 
extern int __v9fs_cache_register(void);

extern void __v9fs_cache_unregister(void);



extern int __v9fs_fscache_release_page(struct page *page, gfp_t gfp);

extern void __v9fs_fscache_invalidate_page(struct page *page);

extern int __v9fs_readpage_from_fscache(struct inode *inode,

					struct page *page);

extern int __v9fs_readpages_from_fscache(struct inode *inode,

					 struct address_space *mapping,

					 struct list_head *pages,

					 unsigned *nr_pages);

extern void __v9fs_readpage_to_fscache(struct inode *inode, struct page *page);

extern void __v9fs_fscache_wait_on_page_write(struct inode *inode,

					      struct page *page);



static inline int v9fs_fscache_release_page(struct page *page,

					    gfp_t gfp)

{

	return __v9fs_fscache_release_page(page, gfp);

}



static inline void v9fs_fscache_invalidate_page(struct page *page)

{

	__v9fs_fscache_invalidate_page(page);

}



static inline int v9fs_readpage_from_fscache(struct inode *inode,

					     struct page *page)

{

	return __v9fs_readpage_from_fscache(inode, page);

}



static inline int v9fs_readpages_from_fscache(struct inode *inode,

					      struct address_space *mapping,

					      struct list_head *pages,

					      unsigned *nr_pages)

{

	return __v9fs_readpages_from_fscache(inode, mapping, pages,

					     nr_pages);

}



static inline void v9fs_readpage_to_fscache(struct inode *inode,

					    struct page *page)

{

	if (PageFsCache(page))

		__v9fs_readpage_to_fscache(inode, page);

}



static inline void v9fs_uncache_page(struct inode *inode, struct page *page)

{

	struct v9fs_inode *v9inode = V9FS_I(inode);

	fscache_uncache_page(v9inode->fscache, page);

	BUG_ON(PageFsCache(page));

}



static inline void v9fs_fscache_wait_on_page_write(struct inode *inode,

						   struct page *page)

{

	return __v9fs_fscache_wait_on_page_write(inode, page);

}



#else /* CONFIG_9P_FSCACHE */



static inline void v9fs_cache_inode_get_cookie(struct inode *inode)
@@ -99,39 +42,5 @@ static inline void v9fs_cache_inode_set_cookie(struct inode *inode, struct file 
{

}



static inline int v9fs_fscache_release_page(struct page *page,

					    gfp_t gfp) {

	return 1;

}



static inline void v9fs_fscache_invalidate_page(struct page *page) {}



static inline int v9fs_readpage_from_fscache(struct inode *inode,

					     struct page *page)

{

	return -ENOBUFS;

}



static inline int v9fs_readpages_from_fscache(struct inode *inode,

					      struct address_space *mapping,

					      struct list_head *pages,

					      unsigned *nr_pages)

{

	return -ENOBUFS;

}



static inline void v9fs_readpage_to_fscache(struct inode *inode,

					    struct page *page)

{}



static inline void v9fs_uncache_page(struct inode *inode, struct page *page)

{}



static inline void v9fs_fscache_wait_on_page_write(struct inode *inode,

						   struct page *page)

{

	return;

}



#endif /* CONFIG_9P_FSCACHE */

#endif /* _9P_CACHE_H */