2015-07-17 14:38:12 +00:00
|
|
|
/*
|
|
|
|
* (C) 2001 Clemson University and The University of Chicago
|
|
|
|
*
|
|
|
|
* See COPYING in top-level directory.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Linux VFS inode operations.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "protocol.h"
|
2015-12-04 17:56:14 +00:00
|
|
|
#include "orangefs-kernel.h"
|
|
|
|
#include "orangefs-bufmap.h"
|
2015-07-17 14:38:12 +00:00
|
|
|
|
|
|
|
static int read_one_page(struct page *page)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
int max_block;
|
|
|
|
ssize_t bytes_read = 0;
|
|
|
|
struct inode *inode = page->mapping->host;
|
mm, fs: get rid of PAGE_CACHE_* and page_cache_{get,release} macros
PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} macros were introduced *long* time
ago with promise that one day it will be possible to implement page
cache with bigger chunks than PAGE_SIZE.
This promise never materialized. And unlikely will.
We have many places where PAGE_CACHE_SIZE assumed to be equal to
PAGE_SIZE. And it's constant source of confusion on whether
PAGE_CACHE_* or PAGE_* constant should be used in a particular case,
especially on the border between fs and mm.
Global switching to PAGE_CACHE_SIZE != PAGE_SIZE would cause to much
breakage to be doable.
Let's stop pretending that pages in page cache are special. They are
not.
The changes are pretty straight-forward:
- <foo> << (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- <foo> >> (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} -> PAGE_{SIZE,SHIFT,MASK,ALIGN};
- page_cache_get() -> get_page();
- page_cache_release() -> put_page();
This patch contains automated changes generated with coccinelle using
script below. For some reason, coccinelle doesn't patch header files.
I've called spatch for them manually.
The only adjustment after coccinelle is revert of changes to
PAGE_CAHCE_ALIGN definition: we are going to drop it later.
There are few places in the code where coccinelle didn't reach. I'll
fix them manually in a separate patch. Comments and documentation also
will be addressed with the separate patch.
virtual patch
@@
expression E;
@@
- E << (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
expression E;
@@
- E >> (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
@@
- PAGE_CACHE_SHIFT
+ PAGE_SHIFT
@@
@@
- PAGE_CACHE_SIZE
+ PAGE_SIZE
@@
@@
- PAGE_CACHE_MASK
+ PAGE_MASK
@@
expression E;
@@
- PAGE_CACHE_ALIGN(E)
+ PAGE_ALIGN(E)
@@
expression E;
@@
- page_cache_get(E)
+ get_page(E)
@@
expression E;
@@
- page_cache_release(E)
+ put_page(E)
Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-04-01 12:29:47 +00:00
|
|
|
const __u32 blocksize = PAGE_SIZE; /* inode->i_blksize */
|
|
|
|
const __u32 blockbits = PAGE_SHIFT; /* inode->i_blkbits */
|
2015-10-08 22:31:05 +00:00
|
|
|
struct iov_iter to;
|
|
|
|
struct bio_vec bv = {.bv_page = page, .bv_len = PAGE_SIZE};
|
|
|
|
|
|
|
|
iov_iter_bvec(&to, ITER_BVEC | READ, &bv, 1, PAGE_SIZE);
|
2015-07-17 14:38:12 +00:00
|
|
|
|
|
|
|
gossip_debug(GOSSIP_INODE_DEBUG,
|
2015-11-24 20:12:14 +00:00
|
|
|
"orangefs_readpage called with page %p\n",
|
2015-07-17 14:38:12 +00:00
|
|
|
page);
|
|
|
|
|
|
|
|
max_block = ((inode->i_size / blocksize) + 1);
|
|
|
|
|
|
|
|
if (page->index < max_block) {
|
|
|
|
loff_t blockptr_offset = (((loff_t) page->index) << blockbits);
|
|
|
|
|
2015-11-24 20:12:14 +00:00
|
|
|
bytes_read = orangefs_inode_read(inode,
|
|
|
|
&to,
|
|
|
|
&blockptr_offset,
|
|
|
|
inode->i_size);
|
2015-07-17 14:38:12 +00:00
|
|
|
}
|
2015-10-08 22:31:05 +00:00
|
|
|
/* this will only zero remaining unread portions of the page data */
|
|
|
|
iov_iter_zero(~0U, &to);
|
2015-07-17 14:38:12 +00:00
|
|
|
/* takes care of potential aliasing */
|
|
|
|
flush_dcache_page(page);
|
|
|
|
if (bytes_read < 0) {
|
|
|
|
ret = bytes_read;
|
|
|
|
SetPageError(page);
|
|
|
|
} else {
|
|
|
|
SetPageUptodate(page);
|
|
|
|
if (PageError(page))
|
|
|
|
ClearPageError(page);
|
|
|
|
ret = 0;
|
|
|
|
}
|
|
|
|
/* unlock the page after the ->readpage() routine completes */
|
|
|
|
unlock_page(page);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2015-11-24 20:12:14 +00:00
|
|
|
static int orangefs_readpage(struct file *file, struct page *page)
|
2015-07-17 14:38:12 +00:00
|
|
|
{
|
|
|
|
return read_one_page(page);
|
|
|
|
}
|
|
|
|
|
2015-11-24 20:12:14 +00:00
|
|
|
static int orangefs_readpages(struct file *file,
|
2015-07-17 14:38:12 +00:00
|
|
|
struct address_space *mapping,
|
|
|
|
struct list_head *pages,
|
|
|
|
unsigned nr_pages)
|
|
|
|
{
|
|
|
|
int page_idx;
|
|
|
|
int ret;
|
|
|
|
|
2015-11-24 20:12:14 +00:00
|
|
|
gossip_debug(GOSSIP_INODE_DEBUG, "orangefs_readpages called\n");
|
2015-07-17 14:38:12 +00:00
|
|
|
|
|
|
|
for (page_idx = 0; page_idx < nr_pages; page_idx++) {
|
|
|
|
struct page *page;
|
|
|
|
|
|
|
|
page = list_entry(pages->prev, struct page, lru);
|
|
|
|
list_del(&page->lru);
|
|
|
|
if (!add_to_page_cache(page,
|
|
|
|
mapping,
|
|
|
|
page->index,
|
2016-07-26 22:24:53 +00:00
|
|
|
readahead_gfp_mask(mapping))) {
|
2015-07-17 14:38:12 +00:00
|
|
|
ret = read_one_page(page);
|
|
|
|
gossip_debug(GOSSIP_INODE_DEBUG,
|
|
|
|
"failure adding page to cache, read_one_page returned: %d\n",
|
|
|
|
ret);
|
|
|
|
} else {
|
mm, fs: get rid of PAGE_CACHE_* and page_cache_{get,release} macros
PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} macros were introduced *long* time
ago with promise that one day it will be possible to implement page
cache with bigger chunks than PAGE_SIZE.
This promise never materialized. And unlikely will.
We have many places where PAGE_CACHE_SIZE assumed to be equal to
PAGE_SIZE. And it's constant source of confusion on whether
PAGE_CACHE_* or PAGE_* constant should be used in a particular case,
especially on the border between fs and mm.
Global switching to PAGE_CACHE_SIZE != PAGE_SIZE would cause to much
breakage to be doable.
Let's stop pretending that pages in page cache are special. They are
not.
The changes are pretty straight-forward:
- <foo> << (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- <foo> >> (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} -> PAGE_{SIZE,SHIFT,MASK,ALIGN};
- page_cache_get() -> get_page();
- page_cache_release() -> put_page();
This patch contains automated changes generated with coccinelle using
script below. For some reason, coccinelle doesn't patch header files.
I've called spatch for them manually.
The only adjustment after coccinelle is revert of changes to
PAGE_CAHCE_ALIGN definition: we are going to drop it later.
There are few places in the code where coccinelle didn't reach. I'll
fix them manually in a separate patch. Comments and documentation also
will be addressed with the separate patch.
virtual patch
@@
expression E;
@@
- E << (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
expression E;
@@
- E >> (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
@@
- PAGE_CACHE_SHIFT
+ PAGE_SHIFT
@@
@@
- PAGE_CACHE_SIZE
+ PAGE_SIZE
@@
@@
- PAGE_CACHE_MASK
+ PAGE_MASK
@@
expression E;
@@
- PAGE_CACHE_ALIGN(E)
+ PAGE_ALIGN(E)
@@
expression E;
@@
- page_cache_get(E)
+ get_page(E)
@@
expression E;
@@
- page_cache_release(E)
+ put_page(E)
Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-04-01 12:29:47 +00:00
|
|
|
put_page(page);
|
2015-07-17 14:38:12 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
BUG_ON(!list_empty(pages));
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-11-24 20:12:14 +00:00
|
|
|
static void orangefs_invalidatepage(struct page *page,
|
2015-07-17 14:38:12 +00:00
|
|
|
unsigned int offset,
|
|
|
|
unsigned int length)
|
|
|
|
{
|
|
|
|
gossip_debug(GOSSIP_INODE_DEBUG,
|
2015-11-24 20:12:14 +00:00
|
|
|
"orangefs_invalidatepage called on page %p "
|
2015-07-17 14:38:12 +00:00
|
|
|
"(offset is %u)\n",
|
|
|
|
page,
|
|
|
|
offset);
|
|
|
|
|
|
|
|
ClearPageUptodate(page);
|
|
|
|
ClearPageMappedToDisk(page);
|
|
|
|
return;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2015-11-24 20:12:14 +00:00
|
|
|
static int orangefs_releasepage(struct page *page, gfp_t foo)
|
2015-07-17 14:38:12 +00:00
|
|
|
{
|
|
|
|
gossip_debug(GOSSIP_INODE_DEBUG,
|
2015-11-24 20:12:14 +00:00
|
|
|
"orangefs_releasepage called on page %p\n",
|
2015-07-17 14:38:12 +00:00
|
|
|
page);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Having a direct_IO entry point in the address_space_operations
|
|
|
|
* struct causes the kernel to allows us to use O_DIRECT on
|
|
|
|
* open. Nothing will ever call this thing, but in the future we
|
|
|
|
* will need to be able to use O_DIRECT on open in order to support
|
|
|
|
* AIO. Modeled after NFS, they do this too.
|
|
|
|
*/
|
2016-06-09 19:38:03 +00:00
|
|
|
|
|
|
|
static ssize_t orangefs_direct_IO(struct kiocb *iocb,
|
|
|
|
struct iov_iter *iter)
|
|
|
|
{
|
|
|
|
gossip_debug(GOSSIP_INODE_DEBUG,
|
|
|
|
"orangefs_direct_IO: %s\n",
|
|
|
|
iocb->ki_filp->f_path.dentry->d_name.name);
|
|
|
|
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2015-07-17 14:38:12 +00:00
|
|
|
|
2015-11-24 20:12:14 +00:00
|
|
|
struct backing_dev_info orangefs_backing_dev_info = {
|
|
|
|
.name = "orangefs",
|
2015-07-17 14:38:12 +00:00
|
|
|
.ra_pages = 0,
|
|
|
|
.capabilities = BDI_CAP_NO_ACCT_DIRTY | BDI_CAP_NO_WRITEBACK,
|
|
|
|
};
|
|
|
|
|
2015-11-24 20:12:14 +00:00
|
|
|
/** ORANGEFS2 implementation of address space operations */
|
|
|
|
const struct address_space_operations orangefs_address_operations = {
|
|
|
|
.readpage = orangefs_readpage,
|
|
|
|
.readpages = orangefs_readpages,
|
|
|
|
.invalidatepage = orangefs_invalidatepage,
|
|
|
|
.releasepage = orangefs_releasepage,
|
2016-06-09 19:38:03 +00:00
|
|
|
.direct_IO = orangefs_direct_IO,
|
2015-07-17 14:38:12 +00:00
|
|
|
};
|
|
|
|
|
2015-11-24 20:12:14 +00:00
|
|
|
static int orangefs_setattr_size(struct inode *inode, struct iattr *iattr)
|
2015-07-17 14:38:12 +00:00
|
|
|
{
|
2015-11-24 20:12:14 +00:00
|
|
|
struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode);
|
|
|
|
struct orangefs_kernel_op_s *new_op;
|
2016-03-23 21:06:25 +00:00
|
|
|
loff_t orig_size;
|
2015-07-17 14:38:12 +00:00
|
|
|
int ret = -EINVAL;
|
|
|
|
|
|
|
|
gossip_debug(GOSSIP_INODE_DEBUG,
|
|
|
|
"%s: %pU: Handle is %pU | fs_id %d | size is %llu\n",
|
|
|
|
__func__,
|
|
|
|
get_khandle_from_ino(inode),
|
2015-11-24 20:12:14 +00:00
|
|
|
&orangefs_inode->refn.khandle,
|
|
|
|
orangefs_inode->refn.fs_id,
|
2015-07-17 14:38:12 +00:00
|
|
|
iattr->ia_size);
|
|
|
|
|
2016-03-23 21:06:25 +00:00
|
|
|
/* Ensure that we have a up to date size, so we know if it changed. */
|
|
|
|
ret = orangefs_inode_getattr(inode, 0, 1);
|
|
|
|
if (ret == -ESTALE)
|
|
|
|
ret = -EIO;
|
|
|
|
if (ret) {
|
|
|
|
gossip_err("%s: orangefs_inode_getattr failed, ret:%d:.\n",
|
|
|
|
__func__, ret);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
orig_size = i_size_read(inode);
|
|
|
|
|
2015-07-17 14:38:12 +00:00
|
|
|
truncate_setsize(inode, iattr->ia_size);
|
|
|
|
|
2015-11-24 20:12:14 +00:00
|
|
|
new_op = op_alloc(ORANGEFS_VFS_OP_TRUNCATE);
|
2015-07-17 14:38:12 +00:00
|
|
|
if (!new_op)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2015-11-24 20:12:14 +00:00
|
|
|
new_op->upcall.req.truncate.refn = orangefs_inode->refn;
|
2015-07-17 14:38:12 +00:00
|
|
|
new_op->upcall.req.truncate.size = (__s64) iattr->ia_size;
|
|
|
|
|
|
|
|
ret = service_operation(new_op, __func__,
|
|
|
|
get_interruptible_flag(inode));
|
|
|
|
|
|
|
|
/*
|
|
|
|
* the truncate has no downcall members to retrieve, but
|
|
|
|
* the status value tells us if it went through ok or not
|
|
|
|
*/
|
|
|
|
gossip_debug(GOSSIP_INODE_DEBUG,
|
2015-11-24 20:12:14 +00:00
|
|
|
"orangefs: orangefs_truncate got return value of %d\n",
|
2015-07-17 14:38:12 +00:00
|
|
|
ret);
|
|
|
|
|
|
|
|
op_release(new_op);
|
|
|
|
|
|
|
|
if (ret != 0)
|
|
|
|
return ret;
|
|
|
|
|
2016-04-04 20:26:36 +00:00
|
|
|
if (orig_size != i_size_read(inode))
|
2015-07-17 14:38:12 +00:00
|
|
|
iattr->ia_valid |= ATTR_CTIME | ATTR_MTIME;
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Change attributes of an object referenced by dentry.
|
|
|
|
*/
|
2015-11-24 20:12:14 +00:00
|
|
|
int orangefs_setattr(struct dentry *dentry, struct iattr *iattr)
|
2015-07-17 14:38:12 +00:00
|
|
|
{
|
|
|
|
int ret = -EINVAL;
|
|
|
|
struct inode *inode = dentry->d_inode;
|
|
|
|
|
|
|
|
gossip_debug(GOSSIP_INODE_DEBUG,
|
2015-11-24 20:12:14 +00:00
|
|
|
"orangefs_setattr: called on %s\n",
|
2015-07-17 14:38:12 +00:00
|
|
|
dentry->d_name.name);
|
|
|
|
|
|
|
|
ret = inode_change_ok(inode, iattr);
|
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
if ((iattr->ia_valid & ATTR_SIZE) &&
|
|
|
|
iattr->ia_size != i_size_read(inode)) {
|
2015-11-24 20:12:14 +00:00
|
|
|
ret = orangefs_setattr_size(inode, iattr);
|
2015-07-17 14:38:12 +00:00
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
setattr_copy(inode, iattr);
|
|
|
|
mark_inode_dirty(inode);
|
|
|
|
|
2015-11-24 20:12:14 +00:00
|
|
|
ret = orangefs_inode_setattr(inode, iattr);
|
2015-07-17 14:38:12 +00:00
|
|
|
gossip_debug(GOSSIP_INODE_DEBUG,
|
2015-11-24 20:12:14 +00:00
|
|
|
"orangefs_setattr: inode_setattr returned %d\n",
|
2015-07-17 14:38:12 +00:00
|
|
|
ret);
|
|
|
|
|
|
|
|
if (!ret && (iattr->ia_valid & ATTR_MODE))
|
|
|
|
/* change mod on a file that has ACLs */
|
|
|
|
ret = posix_acl_chmod(inode, inode->i_mode);
|
|
|
|
|
|
|
|
out:
|
2015-11-24 20:12:14 +00:00
|
|
|
gossip_debug(GOSSIP_INODE_DEBUG, "orangefs_setattr: returning %d\n", ret);
|
2015-07-17 14:38:12 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Obtain attributes of an object given a dentry
|
|
|
|
*/
|
2015-11-24 20:12:14 +00:00
|
|
|
int orangefs_getattr(struct vfsmount *mnt,
|
2015-07-17 14:38:12 +00:00
|
|
|
struct dentry *dentry,
|
|
|
|
struct kstat *kstat)
|
|
|
|
{
|
|
|
|
int ret = -ENOENT;
|
|
|
|
struct inode *inode = dentry->d_inode;
|
2015-11-24 20:12:14 +00:00
|
|
|
struct orangefs_inode_s *orangefs_inode = NULL;
|
2015-07-17 14:38:12 +00:00
|
|
|
|
|
|
|
gossip_debug(GOSSIP_INODE_DEBUG,
|
2015-11-24 20:12:14 +00:00
|
|
|
"orangefs_getattr: called on %s\n",
|
2015-07-17 14:38:12 +00:00
|
|
|
dentry->d_name.name);
|
|
|
|
|
2016-06-09 20:32:38 +00:00
|
|
|
ret = orangefs_inode_getattr(inode, 0, 0);
|
2015-07-17 14:38:12 +00:00
|
|
|
if (ret == 0) {
|
|
|
|
generic_fillattr(inode, kstat);
|
2016-03-14 19:30:03 +00:00
|
|
|
|
2015-07-17 14:38:12 +00:00
|
|
|
/* override block size reported to stat */
|
2015-11-24 20:12:14 +00:00
|
|
|
orangefs_inode = ORANGEFS_I(inode);
|
|
|
|
kstat->blksize = orangefs_inode->blksize;
|
2015-07-17 14:38:12 +00:00
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2016-01-30 18:46:54 +00:00
|
|
|
int orangefs_permission(struct inode *inode, int mask)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (mask & MAY_NOT_BLOCK)
|
|
|
|
return -ECHILD;
|
|
|
|
|
|
|
|
gossip_debug(GOSSIP_INODE_DEBUG, "%s: refreshing\n", __func__);
|
|
|
|
|
|
|
|
/* Make sure the permission (and other common attrs) are up to date. */
|
2016-03-15 16:36:29 +00:00
|
|
|
ret = orangefs_inode_getattr(inode, 0, 0);
|
2016-01-30 18:46:54 +00:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
return generic_permission(inode, mask);
|
|
|
|
}
|
|
|
|
|
2015-11-24 20:12:14 +00:00
|
|
|
/* ORANGEDS2 implementation of VFS inode operations for files */
|
2016-05-14 22:46:32 +00:00
|
|
|
const struct inode_operations orangefs_file_inode_operations = {
|
2015-11-24 20:12:14 +00:00
|
|
|
.get_acl = orangefs_get_acl,
|
|
|
|
.set_acl = orangefs_set_acl,
|
|
|
|
.setattr = orangefs_setattr,
|
|
|
|
.getattr = orangefs_getattr,
|
2015-07-17 14:38:12 +00:00
|
|
|
.setxattr = generic_setxattr,
|
|
|
|
.getxattr = generic_getxattr,
|
2015-11-24 20:12:14 +00:00
|
|
|
.listxattr = orangefs_listxattr,
|
2015-07-17 14:38:12 +00:00
|
|
|
.removexattr = generic_removexattr,
|
2016-01-30 18:46:54 +00:00
|
|
|
.permission = orangefs_permission,
|
2015-07-17 14:38:12 +00:00
|
|
|
};
|
|
|
|
|
2015-11-24 20:12:14 +00:00
|
|
|
static int orangefs_init_iops(struct inode *inode)
|
2015-07-17 14:38:12 +00:00
|
|
|
{
|
2015-11-24 20:12:14 +00:00
|
|
|
inode->i_mapping->a_ops = &orangefs_address_operations;
|
2015-07-17 14:38:12 +00:00
|
|
|
|
|
|
|
switch (inode->i_mode & S_IFMT) {
|
|
|
|
case S_IFREG:
|
2015-11-24 20:12:14 +00:00
|
|
|
inode->i_op = &orangefs_file_inode_operations;
|
|
|
|
inode->i_fop = &orangefs_file_operations;
|
mm, fs: get rid of PAGE_CACHE_* and page_cache_{get,release} macros
PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} macros were introduced *long* time
ago with promise that one day it will be possible to implement page
cache with bigger chunks than PAGE_SIZE.
This promise never materialized. And unlikely will.
We have many places where PAGE_CACHE_SIZE assumed to be equal to
PAGE_SIZE. And it's constant source of confusion on whether
PAGE_CACHE_* or PAGE_* constant should be used in a particular case,
especially on the border between fs and mm.
Global switching to PAGE_CACHE_SIZE != PAGE_SIZE would cause to much
breakage to be doable.
Let's stop pretending that pages in page cache are special. They are
not.
The changes are pretty straight-forward:
- <foo> << (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- <foo> >> (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} -> PAGE_{SIZE,SHIFT,MASK,ALIGN};
- page_cache_get() -> get_page();
- page_cache_release() -> put_page();
This patch contains automated changes generated with coccinelle using
script below. For some reason, coccinelle doesn't patch header files.
I've called spatch for them manually.
The only adjustment after coccinelle is revert of changes to
PAGE_CAHCE_ALIGN definition: we are going to drop it later.
There are few places in the code where coccinelle didn't reach. I'll
fix them manually in a separate patch. Comments and documentation also
will be addressed with the separate patch.
virtual patch
@@
expression E;
@@
- E << (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
expression E;
@@
- E >> (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
@@
- PAGE_CACHE_SHIFT
+ PAGE_SHIFT
@@
@@
- PAGE_CACHE_SIZE
+ PAGE_SIZE
@@
@@
- PAGE_CACHE_MASK
+ PAGE_MASK
@@
expression E;
@@
- PAGE_CACHE_ALIGN(E)
+ PAGE_ALIGN(E)
@@
expression E;
@@
- page_cache_get(E)
+ get_page(E)
@@
expression E;
@@
- page_cache_release(E)
+ put_page(E)
Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-04-01 12:29:47 +00:00
|
|
|
inode->i_blkbits = PAGE_SHIFT;
|
2015-07-17 14:38:12 +00:00
|
|
|
break;
|
|
|
|
case S_IFLNK:
|
2015-11-24 20:12:14 +00:00
|
|
|
inode->i_op = &orangefs_symlink_inode_operations;
|
2015-07-17 14:38:12 +00:00
|
|
|
break;
|
|
|
|
case S_IFDIR:
|
2015-11-24 20:12:14 +00:00
|
|
|
inode->i_op = &orangefs_dir_inode_operations;
|
|
|
|
inode->i_fop = &orangefs_dir_operations;
|
2015-07-17 14:38:12 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
gossip_debug(GOSSIP_INODE_DEBUG,
|
|
|
|
"%s: unsupported mode\n",
|
|
|
|
__func__);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2015-11-24 20:12:14 +00:00
|
|
|
* Given a ORANGEFS object identifier (fsid, handle), convert it into a ino_t type
|
2015-07-17 14:38:12 +00:00
|
|
|
* that will be used as a hash-index from where the handle will
|
|
|
|
* be searched for in the VFS hash table of inodes.
|
|
|
|
*/
|
2015-11-24 20:12:14 +00:00
|
|
|
static inline ino_t orangefs_handle_hash(struct orangefs_object_kref *ref)
|
2015-07-17 14:38:12 +00:00
|
|
|
{
|
|
|
|
if (!ref)
|
|
|
|
return 0;
|
2015-11-24 20:12:14 +00:00
|
|
|
return orangefs_khandle_to_ino(&(ref->khandle));
|
2015-07-17 14:38:12 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Called to set up an inode from iget5_locked.
|
|
|
|
*/
|
2015-11-24 20:12:14 +00:00
|
|
|
static int orangefs_set_inode(struct inode *inode, void *data)
|
2015-07-17 14:38:12 +00:00
|
|
|
{
|
2015-11-24 20:12:14 +00:00
|
|
|
struct orangefs_object_kref *ref = (struct orangefs_object_kref *) data;
|
2016-03-16 18:35:21 +00:00
|
|
|
ORANGEFS_I(inode)->refn.fs_id = ref->fs_id;
|
|
|
|
ORANGEFS_I(inode)->refn.khandle = ref->khandle;
|
2015-07-17 14:38:12 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Called to determine if handles match.
|
|
|
|
*/
|
2015-11-24 20:12:14 +00:00
|
|
|
static int orangefs_test_inode(struct inode *inode, void *data)
|
2015-07-17 14:38:12 +00:00
|
|
|
{
|
2015-11-24 20:12:14 +00:00
|
|
|
struct orangefs_object_kref *ref = (struct orangefs_object_kref *) data;
|
|
|
|
struct orangefs_inode_s *orangefs_inode = NULL;
|
2015-07-17 14:38:12 +00:00
|
|
|
|
2015-11-24 20:12:14 +00:00
|
|
|
orangefs_inode = ORANGEFS_I(inode);
|
|
|
|
return (!ORANGEFS_khandle_cmp(&(orangefs_inode->refn.khandle), &(ref->khandle))
|
|
|
|
&& orangefs_inode->refn.fs_id == ref->fs_id);
|
2015-07-17 14:38:12 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2015-11-24 20:12:14 +00:00
|
|
|
* Front-end to lookup the inode-cache maintained by the VFS using the ORANGEFS
|
2015-07-17 14:38:12 +00:00
|
|
|
* file handle.
|
|
|
|
*
|
|
|
|
* @sb: the file system super block instance.
|
2015-11-24 20:12:14 +00:00
|
|
|
* @ref: The ORANGEFS object for which we are trying to locate an inode structure.
|
2015-07-17 14:38:12 +00:00
|
|
|
*/
|
2015-11-24 20:12:14 +00:00
|
|
|
struct inode *orangefs_iget(struct super_block *sb, struct orangefs_object_kref *ref)
|
2015-07-17 14:38:12 +00:00
|
|
|
{
|
|
|
|
struct inode *inode = NULL;
|
|
|
|
unsigned long hash;
|
|
|
|
int error;
|
|
|
|
|
2015-11-24 20:12:14 +00:00
|
|
|
hash = orangefs_handle_hash(ref);
|
|
|
|
inode = iget5_locked(sb, hash, orangefs_test_inode, orangefs_set_inode, ref);
|
2015-07-17 14:38:12 +00:00
|
|
|
if (!inode || !(inode->i_state & I_NEW))
|
|
|
|
return inode;
|
|
|
|
|
2016-06-09 20:32:38 +00:00
|
|
|
error = orangefs_inode_getattr(inode, 1, 1);
|
2015-07-17 14:38:12 +00:00
|
|
|
if (error) {
|
|
|
|
iget_failed(inode);
|
|
|
|
return ERR_PTR(error);
|
|
|
|
}
|
|
|
|
|
|
|
|
inode->i_ino = hash; /* needed for stat etc */
|
2015-11-24 20:12:14 +00:00
|
|
|
orangefs_init_iops(inode);
|
2015-07-17 14:38:12 +00:00
|
|
|
unlock_new_inode(inode);
|
|
|
|
|
|
|
|
gossip_debug(GOSSIP_INODE_DEBUG,
|
|
|
|
"iget handle %pU, fsid %d hash %ld i_ino %lu\n",
|
|
|
|
&ref->khandle,
|
|
|
|
ref->fs_id,
|
|
|
|
hash,
|
|
|
|
inode->i_ino);
|
|
|
|
|
|
|
|
return inode;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Allocate an inode for a newly created file and insert it into the inode hash.
|
|
|
|
*/
|
2015-11-24 20:12:14 +00:00
|
|
|
struct inode *orangefs_new_inode(struct super_block *sb, struct inode *dir,
|
|
|
|
int mode, dev_t dev, struct orangefs_object_kref *ref)
|
2015-07-17 14:38:12 +00:00
|
|
|
{
|
2015-11-24 20:12:14 +00:00
|
|
|
unsigned long hash = orangefs_handle_hash(ref);
|
2015-07-17 14:38:12 +00:00
|
|
|
struct inode *inode;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
gossip_debug(GOSSIP_INODE_DEBUG,
|
2016-02-16 22:09:09 +00:00
|
|
|
"%s:(sb is %p | MAJOR(dev)=%u | MINOR(dev)=%u mode=%o)\n",
|
|
|
|
__func__,
|
2015-07-17 14:38:12 +00:00
|
|
|
sb,
|
|
|
|
MAJOR(dev),
|
|
|
|
MINOR(dev),
|
|
|
|
mode);
|
|
|
|
|
|
|
|
inode = new_inode(sb);
|
|
|
|
if (!inode)
|
|
|
|
return NULL;
|
|
|
|
|
2015-11-24 20:12:14 +00:00
|
|
|
orangefs_set_inode(inode, ref);
|
2015-07-17 14:38:12 +00:00
|
|
|
inode->i_ino = hash; /* needed for stat etc */
|
|
|
|
|
2016-06-09 20:32:38 +00:00
|
|
|
error = orangefs_inode_getattr(inode, 1, 1);
|
2015-07-17 14:38:12 +00:00
|
|
|
if (error)
|
|
|
|
goto out_iput;
|
|
|
|
|
2015-11-24 20:12:14 +00:00
|
|
|
orangefs_init_iops(inode);
|
2015-07-17 14:38:12 +00:00
|
|
|
|
|
|
|
inode->i_mode = mode;
|
|
|
|
inode->i_uid = current_fsuid();
|
|
|
|
inode->i_gid = current_fsgid();
|
|
|
|
inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
|
mm, fs: get rid of PAGE_CACHE_* and page_cache_{get,release} macros
PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} macros were introduced *long* time
ago with promise that one day it will be possible to implement page
cache with bigger chunks than PAGE_SIZE.
This promise never materialized. And unlikely will.
We have many places where PAGE_CACHE_SIZE assumed to be equal to
PAGE_SIZE. And it's constant source of confusion on whether
PAGE_CACHE_* or PAGE_* constant should be used in a particular case,
especially on the border between fs and mm.
Global switching to PAGE_CACHE_SIZE != PAGE_SIZE would cause to much
breakage to be doable.
Let's stop pretending that pages in page cache are special. They are
not.
The changes are pretty straight-forward:
- <foo> << (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- <foo> >> (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} -> PAGE_{SIZE,SHIFT,MASK,ALIGN};
- page_cache_get() -> get_page();
- page_cache_release() -> put_page();
This patch contains automated changes generated with coccinelle using
script below. For some reason, coccinelle doesn't patch header files.
I've called spatch for them manually.
The only adjustment after coccinelle is revert of changes to
PAGE_CAHCE_ALIGN definition: we are going to drop it later.
There are few places in the code where coccinelle didn't reach. I'll
fix them manually in a separate patch. Comments and documentation also
will be addressed with the separate patch.
virtual patch
@@
expression E;
@@
- E << (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
expression E;
@@
- E >> (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
@@
- PAGE_CACHE_SHIFT
+ PAGE_SHIFT
@@
@@
- PAGE_CACHE_SIZE
+ PAGE_SIZE
@@
@@
- PAGE_CACHE_MASK
+ PAGE_MASK
@@
expression E;
@@
- PAGE_CACHE_ALIGN(E)
+ PAGE_ALIGN(E)
@@
expression E;
@@
- page_cache_get(E)
+ get_page(E)
@@
expression E;
@@
- page_cache_release(E)
+ put_page(E)
Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-04-01 12:29:47 +00:00
|
|
|
inode->i_size = PAGE_SIZE;
|
2015-07-17 14:38:12 +00:00
|
|
|
inode->i_rdev = dev;
|
|
|
|
|
2015-11-24 20:12:14 +00:00
|
|
|
error = insert_inode_locked4(inode, hash, orangefs_test_inode, ref);
|
2015-07-17 14:38:12 +00:00
|
|
|
if (error < 0)
|
|
|
|
goto out_iput;
|
|
|
|
|
|
|
|
gossip_debug(GOSSIP_INODE_DEBUG,
|
|
|
|
"Initializing ACL's for inode %pU\n",
|
|
|
|
get_khandle_from_ino(inode));
|
2015-11-24 20:12:14 +00:00
|
|
|
orangefs_init_acl(inode, dir);
|
2015-07-17 14:38:12 +00:00
|
|
|
return inode;
|
|
|
|
|
|
|
|
out_iput:
|
|
|
|
iput(inode);
|
|
|
|
return ERR_PTR(error);
|
|
|
|
}
|