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

Commit 842cf0b9 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge branch 'for-linus-2' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs 

Pull vfs update from Al Viro:

 - misc stable fixes

 - trivial kernel-doc and comment fixups

 - remove never-used block_page_mkwrite() wrapper function, and rename
   the function that is _actually_ used to not have double underscores.

* 'for-linus-2' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs:
  fs: 9p: cache.h: Add #define of include guard
  vfs: remove stale comment in inode_operations
  vfs: remove unused wrapper block_page_mkwrite()
  binfmt_elf: Correct `arch_check_elf's description
  fs: fix writeback.c kernel-doc warnings
  fs: fix inode.c kernel-doc warning
  fs/pipe.c: return error code rather than 0 in pipe_write()
  fs/pipe.c: preserve alloc_file() error code
  binfmt_elf: Don't clobber passed executable's file header
  FS-Cache: Handle a write to the page immediately beyond the EOF marker
  cachefiles: perform test on s_blocksize when opening cache file.
  FS-Cache: Don't override netfs's primary_index if registering failed
  FS-Cache: Increase reference of parent after registering, netfs success
  debugfs: fix refcount imbalance in start_creating
parents 65d57b30 7c7afc44

fs/9p/cache.h

+1 −0
Original line number Diff line number Diff line
@@ -21,6 +21,7 @@ 
 */



#ifndef _9P_CACHE_H

#define _9P_CACHE_H

#ifdef CONFIG_9P_FSCACHE

#include <linux/fscache.h>

#include <linux/spinlock.h>

fs/binfmt_elf.c

+6 −6
Original line number Diff line number Diff line
@@ -488,7 +488,7 @@ static inline int arch_elf_pt_proc(struct elfhdr *ehdr, 
}



/**

 * arch_check_elf() - check a PT_LOPROC..PT_HIPROC ELF program header

 * arch_check_elf() - check an ELF executable

 * @ehdr:	The main ELF header

 * @has_interp:	True if the ELF has an interpreter, else false.

 * @state:	Architecture-specific state preserved throughout the process
@@ -760,16 +760,16 @@ static int load_elf_binary(struct linux_binprm *bprm) 
			 */

			would_dump(bprm, interpreter);



			retval = kernel_read(interpreter, 0, bprm->buf,

					     BINPRM_BUF_SIZE);

			if (retval != BINPRM_BUF_SIZE) {

			/* Get the exec headers */

			retval = kernel_read(interpreter, 0,

					     (void *)&loc->interp_elf_ex,

					     sizeof(loc->interp_elf_ex));

			if (retval != sizeof(loc->interp_elf_ex)) {

				if (retval >= 0)

					retval = -EIO;

				goto out_free_dentry;

			}



			/* Get the exec headers */

			loc->interp_elf_ex = *((struct elfhdr *)bprm->buf);

			break;

		}

		elf_ppnt++;

fs/buffer.c

+2 −22
Original line number Diff line number Diff line
@@ -2420,9 +2420,9 @@ EXPORT_SYMBOL(block_commit_write); 
 * unlock the page.

 *

 * Direct callers of this function should protect against filesystem freezing

 * using sb_start_write() - sb_end_write() functions.

 * using sb_start_pagefault() - sb_end_pagefault() functions.

 */

int __block_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf,

int block_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf,

			 get_block_t get_block)

{

	struct page *page = vmf->page;
@@ -2459,26 +2459,6 @@ int __block_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf, 
	unlock_page(page);

	return ret;

}

EXPORT_SYMBOL(__block_page_mkwrite);



int block_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf,

		   get_block_t get_block)

{

	int ret;

	struct super_block *sb = file_inode(vma->vm_file)->i_sb;



	sb_start_pagefault(sb);



	/*

	 * Update file times before taking page lock. We may end up failing the

	 * fault so this update may be superfluous but who really cares...

	 */

	file_update_time(vma->vm_file);



	ret = __block_page_mkwrite(vma, vmf, get_block);

	sb_end_pagefault(sb);

	return block_page_mkwrite_return(ret);

}

EXPORT_SYMBOL(block_page_mkwrite);



/*

fs/cachefiles/namei.c

+2 −0
Original line number Diff line number Diff line
@@ -655,6 +655,8 @@ int cachefiles_walk_to_object(struct cachefiles_object *parent, 
			aops = d_backing_inode(object->dentry)->i_mapping->a_ops;

			if (!aops->bmap)

				goto check_error;

			if (object->dentry->d_sb->s_blocksize > PAGE_SIZE)

				goto check_error;



			object->backer = object->dentry;

		} else {

fs/cachefiles/rdwr.c

+37 −36
Original line number Diff line number Diff line
@@ -414,9 +414,6 @@ int cachefiles_read_or_alloc_page(struct fscache_retrieval *op, 
	ASSERT(inode->i_mapping->a_ops->readpages);



	/* calculate the shift required to use bmap */

	if (inode->i_sb->s_blocksize > PAGE_SIZE)

		goto enobufs;



	shift = PAGE_SHIFT - inode->i_sb->s_blocksize_bits;



	op->op.flags &= FSCACHE_OP_KEEP_FLAGS;
@@ -711,9 +708,6 @@ int cachefiles_read_or_alloc_pages(struct fscache_retrieval *op, 
	ASSERT(inode->i_mapping->a_ops->readpages);



	/* calculate the shift required to use bmap */

	if (inode->i_sb->s_blocksize > PAGE_SIZE)

		goto all_enobufs;



	shift = PAGE_SHIFT - inode->i_sb->s_blocksize_bits;



	pagevec_init(&pagevec, 0);
@@ -905,6 +899,15 @@ int cachefiles_write_page(struct fscache_storage *op, struct page *page) 
	cache = container_of(object->fscache.cache,

			     struct cachefiles_cache, cache);



	pos = (loff_t)page->index << PAGE_SHIFT;



	/* We mustn't write more data than we have, so we have to beware of a

	 * partial page at EOF.

	 */

	eof = object->fscache.store_limit_l;

	if (pos >= eof)

		goto error;



	/* write the page to the backing filesystem and let it store it in its

	 * own time */

	path.mnt = cache->mnt;
@@ -912,15 +915,11 @@ int cachefiles_write_page(struct fscache_storage *op, struct page *page) 
	file = dentry_open(&path, O_RDWR | O_LARGEFILE, cache->cache_cred);

	if (IS_ERR(file)) {

		ret = PTR_ERR(file);

	} else {

		pos = (loff_t) page->index << PAGE_SHIFT;

		goto error_2;

	}



		/* we mustn't write more data than we have, so we have

		 * to beware of a partial page at EOF */

		eof = object->fscache.store_limit_l;

	len = PAGE_SIZE;

	if (eof & ~PAGE_MASK) {

			ASSERTCMP(pos, <, eof);

		if (eof - pos < PAGE_SIZE) {

			_debug("cut short %llx to %llx",

			       pos, eof);
@@ -932,20 +931,22 @@ int cachefiles_write_page(struct fscache_storage *op, struct page *page) 
	data = kmap(page);

	ret = __kernel_write(file, data, len, &pos);

	kunmap(page);

		if (ret != len)

			ret = -EIO;

	fput(file);

	}

	if (ret != len)

		goto error_eio;



	if (ret < 0) {

		if (ret == -EIO)

			cachefiles_io_error_obj(

				object, "Write page to backing file failed");

		ret = -ENOBUFS;

	}

	_leave(" = 0");

	return 0;



	_leave(" = %d", ret);

	return ret;

error_eio:

	ret = -EIO;

error_2:

	if (ret == -EIO)

		cachefiles_io_error_obj(object,

					"Write page to backing file failed");

error:

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

	return -ENOBUFS;

}



/*