return NULL;

}

bio_end_io_t end_io, struct parallel_io *par)

{

struct bio *bio;

bio = bio_alloc(GFP_NOIO, npg);

if (bio) {

bio->bi_iter.bi_sector = disk_sector;

bio_set_dev(bio, bdev);

.pc_decode = nfs4_decode_void,

.pc_encode = nfs4_encode_void,

.pc_xdrressize = 1,

},

[CB_COMPOUND] = {

.pc_func = nfs4_callback_compound,

.pc_argsize = 256,

.pc_ressize = 256,

.pc_xdrressize = NFS4_CALLBACK_BUFSIZE,

}

};

* that the operation succeeded on the server, but an error in the

* reply path made it appear to have failed.

*/

{

struct iattr attr;

int open_flags = excl ? O_CREAT | O_EXCL : O_CREAT;

* See comments for nfs_proc_create regarding failed operations.

*/

int

{

struct iattr attr;

int status;

/*

* See comments for nfs_proc_create regarding failed operations.

*/

{

struct iattr attr;

int error;

* now have a new file handle and can instantiate an in-core NFS inode

* and move the raw page into its mapping.

*/

{

struct page *page;

char *kaddr;

* If these conditions are met, we can drop the dentries before doing

* the rename.

*/

{

struct inode *old_inode = d_inode(old_dentry);

struct inode *new_inode = d_inode(new_dentry);

return ret;

}

{

const struct cred *cred = current_cred();

int res = 0;

res = nfs_revalidate_inode(NFS_SERVER(inode), inode);

if (res == 0)

goto out;

}

EXPORT_SYMBOL_GPL(nfs_permission);

return parent;

}

const struct export_operations nfs_export_ops = {

.encode_fh = nfs_encode_fh,

.fh_to_dentry = nfs_fh_to_dentry,

.get_parent = nfs_get_parent,

.flags = EXPORT_OP_NOWCC|EXPORT_OP_NOSUBTREECHK|

EXPORT_OP_CLOSE_BEFORE_UNLINK|EXPORT_OP_REMOTE_FS|

EXPORT_OP_NOATOMIC_ATTR,

EXPORT_SYMBOL_GPL(nfs_file_release);

/**

* @inode: pointer to inode struct

* @filp: pointer to struct file

*

{

struct file *file = iocb->ki_filp;

struct inode *inode = file_inode(file);

errseq_t since;

int error;

/*

* O_APPEND implies that we must revalidate the file length.

*/

result = nfs_revalidate_file_size(inode, file);

if (result)

goto out;

}

since = filemap_sample_wb_err(file->f_mapping);

nfs_start_io_write(inode);

written = result;

iocb->ki_pos += written;

result = generic_write_sync(iocb, written);

if (result < 0)

goto out;

Opt_v,

Opt_vers,

Opt_wsize,

};

enum {

{}

};

static const struct fs_parameter_spec nfs_fs_parameters[] = {

fsparam_flag_no("ac", Opt_ac),

fsparam_u32 ("acdirmax", Opt_acdirmax),

fsparam_flag ("v4.1", Opt_v),

fsparam_flag ("v4.2", Opt_v),

fsparam_string("vers", Opt_vers),

fsparam_u32 ("wsize", Opt_wsize),

{}

};

goto out_invalid_value;

}

break;

/*

* Special options

ctx->selected_flavor = RPC_AUTH_MAXFLAVOR;

ctx->minorversion = 0;

ctx->need_mount = true;

}

fc->fs_private = ctx;

fc->ops = &nfs_fs_context_ops;

if (!error) {

SetPageUptodate(page);

unlock_page(page);

}

}

}

EXPORT_SYMBOL_GPL(nfs_check_cache_invalid);

static void nfs_set_cache_invalid(struct inode *inode, unsigned long flags)

{

struct nfs_inode *nfsi = NFS_I(inode);

| NFS_INO_INVALID_XATTR);

}

if (inode->i_mapping->nrpages == 0)

flags &= ~(NFS_INO_INVALID_DATA|NFS_INO_DATA_INVAL_DEFER);

nfsi->cache_validity |= flags;

#define NFS_VALID_ATTRS (ATTR_MODE|ATTR_UID|ATTR_GID|ATTR_SIZE|ATTR_ATIME|ATTR_ATIME_SET|ATTR_MTIME|ATTR_MTIME_SET|ATTR_FILE|ATTR_OPEN)

int

{

struct inode *inode = d_inode(dentry);

struct nfs_fattr *fattr;

return false;

}

{

struct inode *inode = d_inode(path->dentry);

struct nfs_server *server = NFS_SERVER(inode);

/* Only return attributes that were revalidated. */

stat->result_mask &= request_mask;

out_no_update:

stat->ino = nfs_compat_user_ino64(NFS_FILEID(inode));

if (S_ISDIR(inode->i_mode))

stat->blksize = NFS_SERVER(inode)->dtsize;

return 0;

}

/**

* @mapping: pointer to mapping

*/

{

struct nfs_inode *nfsi = NFS_I(inode);

unsigned long *bitlock = &nfsi->flags;

int ret = 0;

/*

* We must clear NFS_INO_INVALID_DATA first to ensure that

* invalidations that come in while we're shooting down the mappings

set_bit(NFS_INO_INVALIDATING, bitlock);

smp_wmb();

spin_unlock(&inode->i_lock);

trace_nfs_invalidate_mapping_enter(inode);

ret = nfs_invalidate_mapping(inode, mapping);

return ret;

}

static bool nfs_file_has_writers(struct nfs_inode *nfsi)

{

struct inode *inode = &nfsi->vfs_inode;

extern unsigned long nfs_access_cache_scan(struct shrinker *shrink,

struct shrink_control *sc);

struct dentry *nfs_lookup(struct inode *, struct dentry *, unsigned int);

int nfs_rmdir(struct inode *, struct dentry *);

int nfs_unlink(struct inode *, struct dentry *);

int nfs_link(struct dentry *, struct inode *, struct dentry *);

struct inode *, struct dentry *, unsigned int);

/* file.c */

}

static int

{

if (NFS_FH(d_inode(path->dentry))->size != 0)

return 0;

}

static int

{

if (NFS_FH(d_inode(dentry))->size != 0)

return -EACCES;

}

*/

#ifdef CONFIG_NFS_V3_ACL

extern struct posix_acl *nfs3_get_acl(struct inode *inode, int type);

extern int nfs3_proc_setacls(struct inode *inode, struct posix_acl *acl,

struct posix_acl *dfacl);

extern ssize_t nfs3_listxattr(struct dentry *, char *, size_t);

fallthrough;

case -ENOTSUPP:

status = -EOPNOTSUPP;

default:

goto getout;

}

}

{

struct posix_acl *orig = acl, *dfacl = NULL, *alloc;

int status;

* changed. Schedule recovery!

*/

nfs4_schedule_path_down_recovery(pos);

default:

goto out;

}

*/

void nfs42_ssc_register_ops(void)

{

nfs42_ssc_register(&nfs4_ssc_clnt_ops_tbl);

}

/**

*/

void nfs42_ssc_unregister_ops(void)

{

nfs42_ssc_unregister(&nfs4_ssc_clnt_ops_tbl);

}

#endif /* CONFIG_NFS_V4_2 */

#include "nfs4trace.h"

#define NFSDBG_FACILITY NFSDBG_PROC

#define NFS4_BITMASK_SZ 3

default:

printk(KERN_ERR "NFS: %s: unhandled error "

"%d.\n", __func__, err);

case 0:

case -ENOENT:

case -EAGAIN:

if (cache_validity & NFS_INO_INVALID_ATIME)

bitmask[1] |= FATTR4_WORD1_TIME_ACCESS;

bitmask[2] |= FATTR4_WORD2_SECURITY_LABEL;

bitmask[0] |= FATTR4_WORD0_CHANGE;

if (cache_validity & NFS_INO_INVALID_MTIME)

bitmask[1] |= FATTR4_WORD1_TIME_MODIFY;

if (cache_validity & NFS_INO_INVALID_SIZE)

#define XATTR_NAME_NFSV4_ACL "system.nfs4_acl"

static int nfs4_xattr_set_nfs4_acl(const struct xattr_handler *handler,

struct dentry *unused, struct inode *inode,

const char *key, const void *buf,

size_t buflen, int flags)

#ifdef CONFIG_NFS_V4_SECURITY_LABEL

static int nfs4_xattr_set_nfs4_label(const struct xattr_handler *handler,

struct dentry *unused, struct inode *inode,

const char *key, const void *buf,

size_t buflen, int flags)

#ifdef CONFIG_NFS_V4_2

static int nfs4_xattr_set_nfs4_user(const struct xattr_handler *handler,

struct dentry *unused, struct inode *inode,

const char *key, const void *buf,

size_t buflen, int flags)

case -NFS4ERR_BADLAYOUT: /* no layout */

case -NFS4ERR_GRACE: /* loca_recalim always false */

task->tk_status = 0;

case 0:

break;

default:

" sequence-id error on an"

" unconfirmed sequence %p!\n",

seqid->sequence);

case -NFS4ERR_STALE_CLIENTID:

case -NFS4ERR_STALE_STATEID:

case -NFS4ERR_BAD_STATEID:

return NULL;

}

static void

pnfs_set_plh_return_info(struct pnfs_layout_hdr *lo, enum pnfs_iomode iomode,

u32 seq)

if (seq != 0) {

WARN_ON_ONCE(lo->plh_return_seq != 0 && lo->plh_return_seq != seq);

lo->plh_return_seq = seq;

}

}

return rv;

}

static bool

pnfs_should_free_range(const struct pnfs_layout_range *lseg_range,

const struct pnfs_layout_range *recall_range)

new_barrier = be32_to_cpu(new->seqid);

else if (new_barrier == 0)

return;

}

static bool

{

u32 seqid = be32_to_cpu(stateid->seqid);

}

/* lget is set to 1 if called from inside send_layoutget call chain */

return false;

set_bit(NFS_LAYOUT_RETURN, &lo->plh_flags);

pnfs_get_layout_hdr(lo);

if (test_bit(NFS_LAYOUT_RETURN_REQUESTED, &lo->plh_flags)) {

if (lo->plh_return_seq != 0)

stateid->seqid = cpu_to_be32(lo->plh_return_seq);

if (iomode != NULL)

*iomode = lo->plh_return_iomode;

pnfs_clear_layoutreturn_info(lo);

*iomode = IOMODE_ANY;

return true;

}

wake_up_var(&lo->plh_outstanding);

}

static void pnfs_clear_first_layoutget(struct pnfs_layout_hdr *lo)

{

unsigned long *bitlock = &lo->plh_flags;

goto out_forget;

}

/* existing state ID, make sure the sequence number matches. */

if (pnfs_layout_stateid_blocked(lo, &res->stateid)) {

dprintk("%s forget reply due to sequence\n", __func__);

goto out_forget;

}

pnfs_set_layout_stateid(lo, &res->stateid, lgp->cred, false);

/*

* We got an entirely new state ID. Mark all segments for the

* inode invalid, and retry the layoutget

*/

goto out_forget;

}

pnfs_get_lseg(lseg);

switch (trypnfs) {

case PNFS_NOT_ATTEMPTED:

pnfs_write_through_mds(desc, hdr);

case PNFS_ATTEMPTED:

break;

case PNFS_TRY_AGAIN:

switch (trypnfs) {

case PNFS_NOT_ATTEMPTED:

pnfs_read_through_mds(desc, hdr);

case PNFS_ATTEMPTED:

break;

case PNFS_TRY_AGAIN:

}

EXPORT_SYMBOL_GPL(nfs_pageio_init_read);

void nfs_pageio_reset_read_mds(struct nfs_pageio_descriptor *pgio)

{

struct nfs_pgio_mirror *mirror;

nfs_release_request(req);

}

struct nfs_pageio_descriptor pgio;

static void nfs_page_group_set_uptodate(struct nfs_page *req)

{

if (test_bit(NFS_IOHDR_EOF, &hdr->flags)) {

/* note: regions of the page not covered by a

if (bytes > hdr->good_bytes) {

/* nothing in this request was good, so zero

* the full extent of the request */

nfs_readpage_retry(task, hdr);

}

/*

* Read a page over NFS.

* We read the page synchronously in the following case:

*/

int nfs_readpage(struct file *file, struct page *page)

{

struct inode *inode = page_file_mapping(page)->host;

dprintk("NFS: nfs_readpage (%p %ld@%lu)\n",

page, PAGE_SIZE, page_index(page));

nfs_inc_stats(inode, NFSIOS_VFSREADPAGE);

/*

* Try to flush any pending writes to the file..

* be any new pending writes generated at this point

* for this page (other pages can be written to).

*/

goto out_unlock;

if (PageUptodate(page))

goto out_unlock;

if (NFS_STALE(inode))

goto out_unlock;

if (file == NULL) {

goto out_unlock;

} else

if (!IS_SYNC(inode)) {

goto out;

}

}

out:

}

struct list_head *pages, unsigned nr_pages)

{

struct inode *inode = mapping->host;

dprintk("NFS: nfs_readpages (%s/%Lu %d)\n",

inode->i_sb->s_id,

nr_pages);

nfs_inc_stats(inode, NFSIOS_VFSREADPAGES);

if (NFS_STALE(inode))

goto out;

desc.ctx = nfs_find_open_context(inode, NULL, FMODE_READ);

if (desc.ctx == NULL)

} else

/* attempt to read as many of the pages as possible from the cache

* - this returns -ENOBUFS immediately if the cookie is negative

if (ret == 0)

goto read_complete; /* all pages were read */

&nfs_async_read_completion_ops);

ret = read_cache_pages(mapping, pages, readpage_async_filler, &desc);

read_complete:

put_nfs_open_context(desc.ctx);

out:

};

EXPORT_SYMBOL_GPL(nfs_sops);

static const struct nfs_ssc_client_ops nfs_ssc_clnt_ops_tbl = {

.sco_sb_deactive = nfs_sb_deactive,

};

#if IS_ENABLED(CONFIG_NFS_V4)

static int __init register_nfs4_fs(void)

}

#endif

static void nfs_ssc_register_ops(void)

{

nfs_ssc_register(&nfs_ssc_clnt_ops_tbl);

}

static void nfs_ssc_unregister_ops(void)

{

nfs_ssc_unregister(&nfs_ssc_clnt_ops_tbl);

}

static struct shrinker acl_shrinker = {

.count_objects = nfs_access_cache_count,

ret = register_shrinker(&acl_shrinker);

if (ret < 0)

goto error_3;

nfs_ssc_register_ops();

return 0;

error_3:

nfs_unregister_sysctl();

unregister_shrinker(&acl_shrinker);

nfs_unregister_sysctl();

unregister_nfs4_fs();

nfs_ssc_unregister_ops();

unregister_filesystem(&nfs_fs_type);

}

seq_puts(m, ",local_lock=flock");

else

seq_puts(m, ",local_lock=posix");

}

/*

{

struct inode *inode = mapping->host;

struct nfs_pageio_descriptor pgio;

int err;

nfs_inc_stats(inode, NFSIOS_VFSWRITEPAGES);

&nfs_async_write_completion_ops);

pgio.pg_io_completion = ioc;

err = write_cache_pages(mapping, wbc, nfs_writepages_callback, &pgio);

* the PageUptodate() flag. In this case, we will need to turn off

* write optimisations that depend on the page contents being correct.

*/

{

struct nfs_inode *nfsi = NFS_I(inode);

if (nfs_have_delegated_attributes(inode))

goto out;

return false;

smp_rmb();

return false;

out:

return false;

return PageUptodate(page) != 0;

}

* If the file is opened for synchronous writes then we can just skip the rest

* of the checks.

*/

{

int ret;

struct file_lock_context *flctx = inode->i_flctx;

if (file->f_flags & O_DSYNC)

return 0;

return 0;

if (NFS_PROTO(inode)->have_delegation(inode, FMODE_WRITE))

return 1;

struct nfs_open_context *ctx = nfs_file_open_context(file);

struct address_space *mapping = page_file_mapping(page);

struct inode *inode = mapping->host;

int status = 0;

nfs_inc_stats(inode, NFSIOS_VFSUPDATEPAGE);

if (!count)

goto out;

offset = 0;

}