*
* You should have received a copy of the GNU General Public License
* version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
*
* GPL HEADER END
*/
* Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
* Use is subject to license terms.
*
- * Copyright (c) 2011, 2015, Intel Corporation.
+ * Copyright (c) 2011, 2017, Intel Corporation.
*/
/*
* This file is part of Lustre, http://www.lustre.org/
#ifndef LLITE_INTERNAL_H
#define LLITE_INTERNAL_H
#include <lustre_debug.h>
-#include <lustre_ver.h>
#include <lustre_disk.h> /* for s2sbi */
#include <lustre_eacl.h>
#include <lustre_linkea.h>
#include <lustre_intent.h>
#include <linux/compat.h>
#include <linux/aio.h>
+#include <lustre_compat.h>
#include "vvp_internal.h"
#include "range_lock.h"
+#include "pcc.h"
#ifndef FMODE_EXEC
#define FMODE_EXEC 0
/* master inode fid for stripe directory */
struct lu_fid lli_pfid;
- /* open count currently used by capability only, indicate whether
- * capability needs renewal */
- atomic_t lli_open_count;
-
/* We need all three because every inode may be opened in different
* modes */
struct obd_client_handle *lli_mds_read_och;
s64 lli_ctime;
spinlock_t lli_agl_lock;
+ /* update atime from MDS no matter if it's older than
+ * local inode atime. */
+ unsigned int lli_update_atime:1;
+
/* Try to make the d::member and f::member are aligned. Before using
* these members, make clear whether it is directory or not. */
union {
/* for directory */
struct {
- /* serialize normal readdir and statahead-readdir. */
- struct mutex lli_readdir_mutex;
-
/* metadata statahead */
/* since parent-child threads can share the same @file
* struct, "opendir_key" is the token when dir close for
unsigned int lli_sa_enabled:1;
/* generation for statahead */
unsigned int lli_sa_generation;
+ /* rw lock protects lli_lsm_md */
+ struct rw_semaphore lli_lsm_sem;
/* directory stripe information */
struct lmv_stripe_md *lli_lsm_md;
- /* default directory stripe offset. This is extracted
- * from the "dmv" xattr in order to decide which MDT to
- * create a subdirectory on. The MDS itself fetches
- * "dmv" and gets the rest of the default layout itself
- * (count, hash, etc). */
- __u32 lli_def_stripe_offset;
+ /* directory default LMV */
+ struct lmv_stripe_md *lli_default_lsm_md;
};
/* for non-directory */
struct {
- struct mutex lli_size_mutex;
- char *lli_symlink_name;
+ struct mutex lli_size_mutex;
+ char *lli_symlink_name;
/*
* struct rw_semaphore {
* signed long count; // align d.d_def_acl
* struct list_head wait_list;
* }
*/
- struct rw_semaphore lli_trunc_sem;
- struct range_lock_tree lli_write_tree;
+ struct rw_semaphore lli_trunc_sem;
+ struct range_lock_tree lli_write_tree;
- struct rw_semaphore lli_glimpse_sem;
- cfs_time_t lli_glimpse_time;
- struct list_head lli_agl_list;
- __u64 lli_agl_index;
+ struct rw_semaphore lli_glimpse_sem;
+ ktime_t lli_glimpse_time;
+ struct list_head lli_agl_list;
+ __u64 lli_agl_index;
/* for writepage() only to communicate to fsync */
- int lli_async_rc;
+ int lli_async_rc;
+
+ /* protect the file heat fields */
+ spinlock_t lli_heat_lock;
+ __u32 lli_heat_flags;
+ struct obd_heat_instance lli_heat_instances[OBD_HEAT_COUNT];
/*
- * whenever a process try to read/write the file, the
+ * Whenever a process try to read/write the file, the
* jobid of the process will be saved here, and it'll
* be packed into the write PRC when flush later.
*
- * so the read/write statistics for jobid will not be
+ * So the read/write statistics for jobid will not be
* accurate if the file is shared by different jobs.
*/
char lli_jobid[LUSTRE_JOBID_SIZE];
+
+ struct mutex lli_pcc_lock;
+ enum lu_pcc_state_flags lli_pcc_state;
+ struct pcc_inode *lli_pcc_inode;
+ struct mutex lli_group_mutex;
+ __u64 lli_group_users;
+ unsigned long lli_group_gid;
};
};
__u32 lli_layout_gen;
spinlock_t lli_layout_lock;
+ __u32 lli_projid; /* project id */
+
struct rw_semaphore lli_xattrs_list_rwsem;
struct mutex lli_xattrs_enq_lock;
struct list_head lli_xattrs; /* ll_xattr_entry->xe_list */
LLIF_FILE_RESTORING = 1,
/* Xattr cache is attached to the file */
LLIF_XATTR_CACHE = 2,
+ /* Project inherit */
+ LLIF_PROJECT_INHERIT = 3,
};
static inline void ll_file_set_flag(struct ll_inode_info *lli,
size_t size,
__u64 valid);
-int ll_init_security(struct dentry *dentry,
- struct inode *inode,
- struct inode *dir);
+static inline bool obd_connect_has_secctx(struct obd_connect_data *data)
+{
+#if defined(HAVE_SECURITY_DENTRY_INIT_SECURITY) && defined(CONFIG_SECURITY)
+ return data->ocd_connect_flags & OBD_CONNECT_FLAGS2 &&
+ data->ocd_connect_flags2 & OBD_CONNECT2_FILE_SECCTX;
+#else
+ return false;
+#endif /* HAVE_SECURITY_DENTRY_INIT_SECURITY */
+}
+
+static inline void obd_connect_set_secctx(struct obd_connect_data *data)
+{
+#if defined(HAVE_SECURITY_DENTRY_INIT_SECURITY) && defined(CONFIG_SECURITY)
+ data->ocd_connect_flags2 |= OBD_CONNECT2_FILE_SECCTX;
+#endif /* HAVE_SECURITY_DENTRY_INIT_SECURITY */
+}
+
+int ll_dentry_init_security(struct dentry *dentry, int mode, struct qstr *name,
+ const char **secctx_name, void **secctx,
+ __u32 *secctx_size);
+int ll_inode_init_security(struct dentry *dentry, struct inode *inode,
+ struct inode *dir);
+
+int ll_listsecurity(struct inode *inode, char *secctx_name,
+ size_t secctx_name_size);
/*
* Locking to guarantee consistency of non-atomic updates to long long i_size,
void ll_inode_size_lock(struct inode *inode);
void ll_inode_size_unlock(struct inode *inode);
-// FIXME: replace the name of this with LL_I to conform to kernel stuff
-// static inline struct ll_inode_info *LL_I(struct inode *inode)
static inline struct ll_inode_info *ll_i2info(struct inode *inode)
{
- return container_of(inode, struct ll_inode_info, lli_vfs_inode);
+ return container_of(inode, struct ll_inode_info, lli_vfs_inode);
}
+static inline struct pcc_inode *ll_i2pcci(struct inode *inode)
+{
+ return ll_i2info(inode)->lli_pcc_inode;
+}
+
+/* default to use at least 16M for fast read if possible */
+#define RA_REMAIN_WINDOW_MIN MiB_TO_PAGES(16UL)
+
/* default to about 64M of readahead on a given system. */
-#define SBI_DEFAULT_READAHEAD_MAX (64UL << (20 - PAGE_CACHE_SHIFT))
+#define SBI_DEFAULT_READAHEAD_MAX MiB_TO_PAGES(64UL)
/* default to read-ahead full files smaller than 2MB on the second read */
-#define SBI_DEFAULT_READAHEAD_WHOLE_MAX (2UL << (20 - PAGE_CACHE_SHIFT))
+#define SBI_DEFAULT_READAHEAD_WHOLE_MAX MiB_TO_PAGES(2UL)
enum ra_stat {
RA_STAT_HIT = 0,
RA_STAT_MAX_IN_FLIGHT,
RA_STAT_WRONG_GRAB_PAGE,
RA_STAT_FAILED_REACH_END,
+ RA_STAT_ASYNC,
+ RA_STAT_FAILED_FAST_READ,
_NR_RA_STAT,
};
unsigned long ra_max_pages;
unsigned long ra_max_pages_per_file;
unsigned long ra_max_read_ahead_whole_pages;
+ struct workqueue_struct *ll_readahead_wq;
+ /*
+ * Max number of active works for readahead workqueue,
+ * default is 0 which make workqueue init number itself,
+ * unless there is a specific need for throttling the
+ * number of active work items, specifying '0' is recommended.
+ */
+ unsigned int ra_async_max_active;
+ /* Threshold to control when to trigger async readahead */
+ unsigned long ra_async_pages_per_file_threshold;
};
/* ra_io_arg will be filled in the beginning of ll_readahead with
#define LL_SBI_ALWAYS_PING 0x200000 /* always ping even if server
* suppress_pings */
#define LL_SBI_FAST_READ 0x400000 /* fast read support */
-
+#define LL_SBI_FILE_SECCTX 0x800000 /* set file security context at create */
+/* LL_SBI_PIO 0x1000000 parallel IO support, introduced in
+ 2.10, abandoned */
+#define LL_SBI_TINY_WRITE 0x2000000 /* tiny write support */
+#define LL_SBI_FILE_HEAT 0x4000000 /* file heat support */
#define LL_SBI_FLAGS { \
"nolck", \
"checksum", \
"norootsquash", \
"always_ping", \
"fast_read", \
+ "file_secctx", \
+ "pio", \
+ "tiny_write", \
+ "file_heat", \
}
/* This is embedded into llite super-blocks to keep track of connect
struct ll_sb_info {
/* this protects pglist and ra_info. It isn't safe to
* grab from interrupt contexts */
- spinlock_t ll_lock;
- spinlock_t ll_pp_extent_lock; /* pp_extent entry*/
- spinlock_t ll_process_lock; /* ll_rw_process_info */
- struct obd_uuid ll_sb_uuid;
- struct obd_export *ll_md_exp;
- struct obd_export *ll_dt_exp;
- struct proc_dir_entry* ll_proc_root;
- struct lu_fid ll_root_fid; /* root object fid */
+ spinlock_t ll_lock;
+ spinlock_t ll_pp_extent_lock; /* pp_extent entry*/
+ spinlock_t ll_process_lock; /* ll_rw_process_info */
+ struct obd_uuid ll_sb_uuid;
+ struct obd_export *ll_md_exp;
+ struct obd_export *ll_dt_exp;
+ struct obd_device *ll_md_obd;
+ struct obd_device *ll_dt_obd;
+ struct dentry *ll_debugfs_entry;
+ struct lu_fid ll_root_fid; /* root object fid */
int ll_flags;
- unsigned int ll_umounting:1,
- ll_xattr_cache_enabled:1,
- ll_client_common_fill_super_succeeded:1;
+ unsigned int ll_xattr_cache_enabled:1,
+ ll_xattr_cache_set:1, /* already set to 0/1 */
+ ll_client_common_fill_super_succeeded:1,
+ ll_checksum_set:1;
struct lustre_client_ocd ll_lco;
unsigned int ll_namelen;
struct file_operations *ll_fop;
- unsigned int ll_md_brw_pages; /* readdir pages per RPC */
-
struct lu_site *ll_site;
struct cl_device *ll_cl;
/* Statistics */
int ll_rw_stats_on;
/* metadata stat-ahead */
+ unsigned int ll_sa_running_max;/* max concurrent
+ * statahead instances */
unsigned int ll_sa_max; /* max statahead RPCs */
atomic_t ll_sa_total; /* statahead thread started
* count */
* clustred nfs */
/* root squash */
struct root_squash_info ll_squash;
+ struct path ll_mnt;
+
+ /* st_blksize returned by stat(2), when non-zero */
+ unsigned int ll_stat_blksize;
+
+ /* maximum relative age of cached statfs results */
+ unsigned int ll_statfs_max_age;
+
+ struct kset ll_kset; /* sysfs object */
+ struct completion ll_kobj_unregister;
+
+ /* File heat */
+ unsigned int ll_heat_decay_weight;
+ unsigned int ll_heat_period_second;
+
+ /* filesystem fsname */
+ char ll_fsname[LUSTRE_MAXFSNAME + 1];
+
+ /* Persistent Client Cache */
+ struct pcc_super ll_pcc_super;
};
+#define SBI_DEFAULT_HEAT_DECAY_WEIGHT ((80 * 256 + 50) / 100)
+#define SBI_DEFAULT_HEAT_PERIOD_SECOND (60)
/*
* per file-descriptor read-ahead data.
*/
* stride read-ahead will be enable
*/
unsigned long ras_consecutive_stride_requests;
+ /* index of the last page that async readahead starts */
+ unsigned long ras_async_last_readpage;
+};
+
+struct ll_readahead_work {
+ /** File to readahead */
+ struct file *lrw_file;
+ /** Start bytes */
+ unsigned long lrw_start;
+ /** End bytes */
+ unsigned long lrw_end;
+
+ /* async worker to handler read */
+ struct work_struct lrw_readahead_work;
};
extern struct kmem_cache *ll_file_data_slab;
* true: failure is known, not report again.
* false: unknown failure, should report. */
bool fd_write_failed;
+ bool ll_lock_no_expand;
rwlock_t fd_lock; /* protect lcc list */
struct list_head fd_lccs; /* list of ll_cl_context */
+ /* Used by mirrored file to lead IOs to a specific mirror, usually
+ * for mirror resync. 0 means default. */
+ __u32 fd_designated_mirror;
+ /* The layout version when resync starts. Resync I/O should carry this
+ * layout version for verification to OST objects */
+ __u32 fd_layout_version;
+ struct pcc_file fd_pcc_file;
};
-extern spinlock_t inode_lock;
-
-extern struct proc_dir_entry *proc_lustre_fs_root;
+void llite_tunables_unregister(void);
+int llite_tunables_register(void);
static inline struct inode *ll_info2i(struct ll_inode_info *lli)
{
#if BITS_PER_LONG == 32
return 1;
#elif defined(CONFIG_COMPAT)
- return unlikely(is_compat_task() || (sbi->ll_flags & LL_SBI_32BIT_API));
+ if (unlikely(sbi->ll_flags & LL_SBI_32BIT_API))
+ return true;
+
+# ifdef CONFIG_X86_X32
+ /* in_compat_syscall() returns true when called from a kthread
+ * and CONFIG_X86_X32 is enabled, which is wrong. So check
+ * whether the caller comes from a syscall (ie. not a kthread)
+ * before calling in_compat_syscall(). */
+ if (current->flags & PF_KTHREAD)
+ return false;
+# endif
+
+ return unlikely(in_compat_syscall());
#else
return unlikely(sbi->ll_flags & LL_SBI_32BIT_API);
#endif
return !!(sbi->ll_flags & LL_SBI_FAST_READ);
}
+static inline bool ll_sbi_has_tiny_write(struct ll_sb_info *sbi)
+{
+ return !!(sbi->ll_flags & LL_SBI_TINY_WRITE);
+}
+
+static inline bool ll_sbi_has_file_heat(struct ll_sb_info *sbi)
+{
+ return !!(sbi->ll_flags & LL_SBI_FILE_HEAT);
+}
+
void ll_ras_enter(struct file *f);
/* llite/lcommon_misc.c */
int cl_ocd_update(struct obd_device *host, struct obd_device *watched,
- enum obd_notify_event ev, void *owner, void *data);
+ enum obd_notify_event ev, void *owner);
int cl_get_grouplock(struct cl_object *obj, unsigned long gid, int nonblock,
struct ll_grouplock *lg);
void cl_put_grouplock(struct ll_grouplock *lg);
/* llite/lproc_llite.c */
-#ifdef CONFIG_PROC_FS
-int lprocfs_register_mountpoint(struct proc_dir_entry *parent,
- struct super_block *sb, char *osc, char *mdc);
-void lprocfs_unregister_mountpoint(struct ll_sb_info *sbi);
+int ll_debugfs_register_super(struct super_block *sb, const char *name);
+void ll_debugfs_unregister_super(struct super_block *sb);
void ll_stats_ops_tally(struct ll_sb_info *sbi, int op, int count);
-extern struct lprocfs_vars lprocfs_llite_obd_vars[];
-#else
-static inline int lprocfs_register_mountpoint(struct proc_dir_entry *parent,
- struct super_block *sb, char *osc, char *mdc){return 0;}
-static inline void lprocfs_unregister_mountpoint(struct ll_sb_info *sbi) {}
-static void ll_stats_ops_tally(struct ll_sb_info *sbi, int op, int count) {}
-#endif
enum {
- LPROC_LL_DIRTY_HITS,
- LPROC_LL_DIRTY_MISSES,
LPROC_LL_READ_BYTES,
LPROC_LL_WRITE_BYTES,
- LPROC_LL_BRW_READ,
- LPROC_LL_BRW_WRITE,
LPROC_LL_IOCTL,
LPROC_LL_OPEN,
LPROC_LL_RELEASE,
LPROC_LL_RMDIR,
LPROC_LL_MKNOD,
LPROC_LL_RENAME,
- LPROC_LL_STAFS,
+ LPROC_LL_STATFS,
LPROC_LL_ALLOC_INODE,
LPROC_LL_SETXATTR,
LPROC_LL_GETXATTR,
int ll_writepage(struct page *page, struct writeback_control *wbc);
int ll_writepages(struct address_space *, struct writeback_control *wbc);
int ll_readpage(struct file *file, struct page *page);
+int ll_io_read_page(const struct lu_env *env, struct cl_io *io,
+ struct cl_page *page, struct file *file);
void ll_readahead_init(struct inode *inode, struct ll_readahead_state *ras);
int vvp_io_write_commit(const struct lu_env *env, struct cl_io *io);
extern void ll_rw_stats_tally(struct ll_sb_info *sbi, pid_t pid,
struct ll_file_data *file, loff_t pos,
size_t count, int rw);
+#ifdef HAVE_INODEOPS_ENHANCED_GETATTR
+int ll_getattr(const struct path *path, struct kstat *stat,
+ u32 request_mask, unsigned int flags);
+#else
int ll_getattr(struct vfsmount *mnt, struct dentry *de, struct kstat *stat);
+#endif
+int ll_getattr_dentry(struct dentry *de, struct kstat *stat);
struct posix_acl *ll_get_acl(struct inode *inode, int type);
-int ll_migrate(struct inode *parent, struct file *file, int mdtidx,
- const char *name, int namelen);
+#ifdef HAVE_IOP_SET_ACL
+#ifdef CONFIG_FS_POSIX_ACL
+int ll_set_acl(struct inode *inode, struct posix_acl *acl, int type);
+#else /* !CONFIG_FS_POSIX_ACL */
+#define ll_set_acl NULL
+#endif /* CONFIG_FS_POSIX_ACL */
+
+#endif
+int ll_migrate(struct inode *parent, struct file *file,
+ struct lmv_user_md *lum, const char *name);
int ll_get_fid_by_name(struct inode *parent, const char *name,
int namelen, struct lu_fid *fid, struct inode **inode);
-#ifdef HAVE_GENERIC_PERMISSION_4ARGS
-int ll_inode_permission(struct inode *inode, int mask, unsigned int flags);
-#else
-# ifndef HAVE_INODE_PERMISION_2ARGS
-int ll_inode_permission(struct inode *inode, int mask, struct nameidata *nd);
-# else
int ll_inode_permission(struct inode *inode, int mask);
-# endif
-#endif
-
-int ll_lov_setstripe_ea_info(struct inode *inode, struct file *file,
- __u64 flags, struct lov_user_md *lum,
+int ll_ioctl_check_project(struct inode *inode, struct fsxattr *fa);
+int ll_ioctl_fsgetxattr(struct inode *inode, unsigned int cmd,
+ unsigned long arg);
+int ll_ioctl_fssetxattr(struct inode *inode, unsigned int cmd,
+ unsigned long arg);
+
+int ll_lov_setstripe_ea_info(struct inode *inode, struct dentry *dentry,
+ __u64 flags, struct lov_user_md *lum,
int lum_size);
int ll_lov_getstripe_ea_info(struct inode *inode, const char *filename,
struct lov_mds_md **lmm, int *lmm_size,
int ll_dir_getstripe(struct inode *inode, void **lmmp,
int *lmm_size, struct ptlrpc_request **request,
u64 valid);
-#ifdef HAVE_FILE_FSYNC_4ARGS
int ll_fsync(struct file *file, loff_t start, loff_t end, int data);
-#elif defined(HAVE_FILE_FSYNC_2ARGS)
-int ll_fsync(struct file *file, int data);
-#else
-int ll_fsync(struct file *file, struct dentry *dentry, int data);
-#endif
int ll_merge_attr(const struct lu_env *env, struct inode *inode);
int ll_fid2path(struct inode *inode, void __user *arg);
int ll_data_version(struct inode *inode, __u64 *data_version, int flags);
int ll_hsm_release(struct inode *inode);
int ll_hsm_state_set(struct inode *inode, struct hsm_state_set *hss);
+void ll_io_set_mirror(struct cl_io *io, const struct file *file);
/* llite/dcache.c */
struct inode *ll_inode_from_resource_lock(struct ldlm_lock *lock);
void ll_dir_clear_lsm_md(struct inode *inode);
void ll_clear_inode(struct inode *inode);
-int ll_setattr_raw(struct dentry *dentry, struct iattr *attr, bool hsm_import);
+int ll_setattr_raw(struct dentry *dentry, struct iattr *attr,
+ enum op_xvalid xvalid, bool hsm_import);
int ll_setattr(struct dentry *de, struct iattr *attr);
int ll_statfs(struct dentry *de, struct kstatfs *sfs);
-int ll_statfs_internal(struct super_block *sb, struct obd_statfs *osfs,
- __u64 max_age, __u32 flags);
+int ll_statfs_internal(struct ll_sb_info *sbi, struct obd_statfs *osfs,
+ u32 flags);
int ll_update_inode(struct inode *inode, struct lustre_md *md);
+void ll_update_inode_flags(struct inode *inode, int ext_flags);
int ll_read_inode2(struct inode *inode, void *opaque);
void ll_delete_inode(struct inode *inode);
int ll_iocontrol(struct inode *inode, struct file *file,
void ll_dirty_page_discard_warn(struct page *page, int ioret);
int ll_prep_inode(struct inode **inode, struct ptlrpc_request *req,
struct super_block *, struct lookup_intent *);
-void lustre_dump_dentry(struct dentry *, int recur);
int ll_obd_statfs(struct inode *inode, void __user *arg);
int ll_get_max_mdsize(struct ll_sb_info *sbi, int *max_mdsize);
int ll_get_default_mdsize(struct ll_sb_info *sbi, int *default_mdsize);
int ll_set_default_mdsize(struct ll_sb_info *sbi, int default_mdsize);
-int ll_process_config(struct lustre_cfg *lcfg);
-
-enum {
- LUSTRE_OPC_MKDIR = 0,
- LUSTRE_OPC_SYMLINK = 1,
- LUSTRE_OPC_MKNOD = 2,
- LUSTRE_OPC_CREATE = 3,
- LUSTRE_OPC_ANY = 5,
-};
+void ll_unlock_md_op_lsm(struct md_op_data *op_data);
struct md_op_data *ll_prep_md_op_data(struct md_op_data *op_data,
struct inode *i1, struct inode *i2,
const char *name, size_t namelen,
- __u32 mode, __u32 opc, void *data);
+ __u32 mode, enum md_op_code opc,
+ void *data);
void ll_finish_md_op_data(struct md_op_data *op_data);
int ll_get_obd_name(struct inode *inode, unsigned int cmd, unsigned long arg);
-char *ll_get_fsname(struct super_block *sb, char *buf, int buflen);
void ll_compute_rootsquash_state(struct ll_sb_info *sbi);
ssize_t ll_copy_user_md(const struct lov_user_md __user *md,
struct lov_user_md **kbuf);
void ll_open_cleanup(struct super_block *sb, struct ptlrpc_request *open_req);
+void ll_dom_finish_open(struct inode *inode, struct ptlrpc_request *req,
+ struct lookup_intent *it);
+
/* Compute expected user md size when passing in a md from user space */
static inline ssize_t ll_lov_user_md_size(const struct lov_user_md *lum)
{
return lov_user_md_size(lum->lmm_stripe_count,
LOV_USER_MAGIC_SPECIFIC);
+ case LOV_USER_MAGIC_COMP_V1:
+ return ((struct lov_comp_md_v1 *)lum)->lcm_size;
+ case LOV_USER_MAGIC_FOREIGN:
+ return foreign_size(lum);
}
return -EINVAL;
};
struct ll_thread_info {
- struct iov_iter lti_iter;
struct vvp_io_args lti_args;
struct ra_io_arg lti_ria;
- struct kiocb lti_kiocb;
struct ll_cl_context lti_io_ctx;
};
return via;
}
+void ll_io_init(struct cl_io *io, struct file *file, enum cl_io_type iot,
+ struct vvp_io_args *args);
+
/* llite/llite_mmap.c */
int ll_teardown_mmaps(struct address_space *mapping, __u64 first, __u64 last);
struct vm_area_struct *our_vma(struct mm_struct *mm, unsigned long addr,
size_t count);
-static inline void ll_invalidate_page(struct page *vmpage)
-{
- struct address_space *mapping = vmpage->mapping;
- loff_t offset = vmpage->index << PAGE_CACHE_SHIFT;
-
- LASSERT(PageLocked(vmpage));
- if (mapping == NULL)
- return;
-
- /*
- * truncate_complete_page() calls
- * a_ops->invalidatepage()->cl_page_delete()->vvp_page_delete().
- */
- ll_teardown_mmaps(mapping, offset, offset + PAGE_CACHE_SIZE);
- truncate_complete_page(mapping, vmpage);
-}
-
#define ll_s2sbi(sb) (s2lsi(sb)->lsi_llsbi)
/* don't need an addref as the sb_info should be holding one */
return fid;
}
+static inline bool ll_dir_striped(struct inode *inode)
+{
+ LASSERT(inode);
+ return S_ISDIR(inode->i_mode) &&
+ lmv_dir_striped(ll_i2info(inode)->lli_lsm_md);
+}
+
static inline loff_t ll_file_maxbytes(struct inode *inode)
{
struct cl_object *obj = ll_i2info(inode)->lli_clob;
}
/* llite/xattr.c */
-int ll_setxattr(struct dentry *dentry, const char *name,
- const void *value, size_t size, int flags);
-ssize_t ll_getxattr(struct dentry *dentry, const char *name,
- void *buffer, size_t size);
+extern const struct xattr_handler *ll_xattr_handlers[];
+
+#define XATTR_USER_T 1
+#define XATTR_TRUSTED_T 2
+#define XATTR_SECURITY_T 3
+#define XATTR_ACL_ACCESS_T 4
+#define XATTR_ACL_DEFAULT_T 5
+#define XATTR_LUSTRE_T 6
+#define XATTR_OTHER_T 7
+
ssize_t ll_listxattr(struct dentry *dentry, char *buffer, size_t size);
-int ll_removexattr(struct dentry *dentry, const char *name);
+int ll_xattr_list(struct inode *inode, const char *name, int type,
+ void *buffer, size_t size, u64 valid);
+const struct xattr_handler *get_xattr_type(const char *name);
/**
* Common IO arguments for various VFS I/O interfaces.
#define LL_SA_RPC_MIN 2
#define LL_SA_RPC_DEF 32
-#define LL_SA_RPC_MAX 8192
+#define LL_SA_RPC_MAX 512
+
+/* XXX: If want to support more concurrent statahead instances,
+ * please consider to decentralize the RPC lists attached
+ * on related import, such as imp_{sending,delayed}_list.
+ * LU-11079 */
+#define LL_SA_RUNNING_MAX 256
+#define LL_SA_RUNNING_DEF 16
#define LL_SA_CACHE_BIT 5
#define LL_SA_CACHE_SIZE (1 << LL_SA_CACHE_BIT)
return cl_glimpse_size0(inode, 0);
}
+/* AGL is 'asychronous glimpse lock', which is a speculative lock taken as
+ * part of statahead */
static inline int cl_agl(struct inode *inode)
{
return cl_glimpse_size0(inode, 1);
}
+int ll_file_lock_ahead(struct file *file, struct llapi_lu_ladvise *ladvise);
+
+int cl_io_get(struct inode *inode, struct lu_env **envout,
+ struct cl_io **ioout, __u16 *refcheck);
+
static inline int ll_glimpse_size(struct inode *inode)
{
struct ll_inode_info *lli = ll_i2info(inode);
down_read(&lli->lli_glimpse_sem);
rc = cl_glimpse_size(inode);
- lli->lli_glimpse_time = cfs_time_current();
+ lli->lli_glimpse_time = ktime_get();
up_read(&lli->lli_glimpse_sem);
return rc;
}
return true;
}
-/* llite ioctl register support rountine */
-enum llioc_iter {
- LLIOC_CONT = 0,
- LLIOC_STOP
-};
-
-#define LLIOC_MAX_CMD 256
-
-/*
- * Rules to write a callback function:
- *
- * Parameters:
- * @magic: Dynamic ioctl call routine will feed this vaule with the pointer
- * returned to ll_iocontrol_register. Callback functions should use this
- * data to check the potential collasion of ioctl cmd. If collasion is
- * found, callback function should return LLIOC_CONT.
- * @rcp: The result of ioctl command.
- *
- * Return values:
- * If @magic matches the pointer returned by ll_iocontrol_data, the
- * callback should return LLIOC_STOP; return LLIOC_STOP otherwise.
- */
-typedef enum llioc_iter (*llioc_callback_t)(struct inode *inode,
- struct file *file, unsigned int cmd, unsigned long arg,
- void *magic, int *rcp);
-
-/* export functions */
-/* Register ioctl block dynamatically for a regular file.
- *
- * @cmd: the array of ioctl command set
- * @count: number of commands in the @cmd
- * @cb: callback function, it will be called if an ioctl command is found to
- * belong to the command list @cmd.
- *
- * Return vaule:
- * A magic pointer will be returned if success;
- * otherwise, NULL will be returned.
- * */
-void *ll_iocontrol_register(llioc_callback_t cb, int count, unsigned int *cmd);
-void ll_iocontrol_unregister(void *magic);
-
int cl_sync_file_range(struct inode *inode, loff_t start, loff_t end,
enum cl_fsync_mode mode, int ignore_layout);
-/** direct write pages */
-struct ll_dio_pages {
- /** page array to be written. we don't support
- * partial pages except the last one. */
- struct page **ldp_pages;
- /* offset of each page */
- loff_t *ldp_offsets;
- /** if ldp_offsets is NULL, it means a sequential
- * pages to be written, then this is the file offset
- * of the * first page. */
- loff_t ldp_start_offset;
- /** how many bytes are to be written. */
- size_t ldp_size;
- /** # of pages in the array. */
- int ldp_nr;
-};
-
-extern ssize_t ll_direct_rw_pages(const struct lu_env *env, struct cl_io *io,
- int rw, struct inode *inode,
- struct ll_dio_pages *pv);
-
static inline int ll_file_nolock(const struct file *file)
{
struct ll_file_data *fd = LUSTRE_FPRIVATE(file);
- struct inode *inode = file->f_path.dentry->d_inode;
+ struct inode *inode = file_inode((struct file *)file);
LASSERT(fd != NULL);
return ((fd->fd_flags & LL_FILE_IGNORE_LOCK) ||
if (it->it_remote_lock_mode) {
handle.cookie = it->it_remote_lock_handle;
CDEBUG(D_DLMTRACE, "setting l_data to inode "DFID
- "(%p) for remote lock "LPX64"\n",
+ "(%p) for remote lock %#llx\n",
PFID(ll_inode2fid(inode)), inode,
handle.cookie);
md_set_lock_data(exp, &handle, inode, NULL);
handle.cookie = it->it_lock_handle;
CDEBUG(D_DLMTRACE, "setting l_data to inode "DFID"(%p)"
- " for lock "LPX64"\n",
+ " for lock %#llx\n",
PFID(ll_inode2fid(inode)), inode, handle.cookie);
md_set_lock_data(exp, &handle, inode, &it->it_lock_bits);
*bits = it->it_lock_bits;
}
-static inline void ll_lock_dcache(struct inode *inode)
-{
-#ifdef HAVE_DCACHE_LOCK
- spin_lock(&dcache_lock);
-#else
- spin_lock(&inode->i_lock);
-#endif
-}
-
-static inline void ll_unlock_dcache(struct inode *inode)
-{
-#ifdef HAVE_DCACHE_LOCK
- spin_unlock(&dcache_lock);
-#else
- spin_unlock(&inode->i_lock);
-#endif
-}
-
static inline int d_lustre_invalid(const struct dentry *dentry)
{
struct ll_dentry_data *lld = ll_d2d(dentry);
spin_unlock(&dentry->d_lock);
}
+static inline dev_t ll_compat_encode_dev(dev_t dev)
+{
+ /* The compat_sys_*stat*() syscalls will fail unless the
+ * device majors and minors are both less than 256. Note that
+ * the value returned here will be passed through
+ * old_encode_dev() in cp_compat_stat(). And so we are not
+ * trying to return a valid compat (u16) device number, just
+ * one that will pass the old_valid_dev() check. */
+
+ return MKDEV(MAJOR(dev) & 0xff, MINOR(dev) & 0xff);
+}
+
int ll_layout_conf(struct inode *inode, const struct cl_object_conf *conf);
int ll_layout_refresh(struct inode *inode, __u32 *gen);
int ll_layout_restore(struct inode *inode, loff_t start, __u64 length);
+int ll_layout_write_intent(struct inode *inode, enum layout_intent_opc opc,
+ struct lu_extent *ext);
int ll_xattr_init(void);
void ll_xattr_fini(void);
-int ll_getxattr_common(struct inode *inode, const char *name,
- void *buffer, size_t size, __u64 valid);
int ll_page_sync_io(const struct lu_env *env, struct cl_io *io,
struct cl_page *page, enum cl_req_type crt);
/* lcommon_cl.c */
int cl_setattr_ost(struct cl_object *obj, const struct iattr *attr,
- unsigned int attr_flags);
+ enum op_xvalid xvalid, unsigned int attr_flags);
extern struct lu_env *cl_inode_fini_env;
extern __u16 cl_inode_fini_refcheck;
u64 cl_fid_build_ino(const struct lu_fid *fid, int api32);
u32 cl_fid_build_gen(const struct lu_fid *fid);
-#ifndef HAVE_FILE_INODE
-static inline struct inode *file_inode(struct file *file)
-{
- return file->f_path.dentry->d_inode;
-}
-#endif
-
-#ifndef HAVE_IOV_ITER_TRUNCATE
-static inline void iov_iter_truncate(struct iov_iter *i, u64 count)
-{
- if (i->count > count)
- i->count = count;
-}
-#endif
-
-#ifndef HAVE_FILE_OPERATIONS_READ_WRITE_ITER
-static inline void iov_iter_reexpand(struct iov_iter *i, size_t count)
-{
- i->count = count;
-}
-
-static inline struct iovec iov_iter_iovec(const struct iov_iter *iter)
-{
- return (struct iovec) {
- .iov_base = iter->iov->iov_base + iter->iov_offset,
- .iov_len = min(iter->count,
- iter->iov->iov_len - iter->iov_offset),
- };
-}
-
-#define iov_for_each(iov, iter, start) \
- for (iter = (start); \
- (iter).count && ((iov = iov_iter_iovec(&(iter))), 1); \
- iov_iter_advance(&(iter), (iov).iov_len))
-
-static inline ssize_t
-generic_file_read_iter(struct kiocb *iocb, struct iov_iter *iter)
-{
- struct iovec iov;
- struct iov_iter i;
- ssize_t bytes = 0;
-
- iov_for_each(iov, i, *iter) {
- ssize_t res;
-
- res = generic_file_aio_read(iocb, &iov, 1, iocb->ki_pos);
- if (res <= 0) {
- if (bytes == 0)
- bytes = res;
- break;
- }
-
- bytes += res;
- if (res < iov.iov_len)
- break;
- }
-
- if (bytes > 0)
- iov_iter_advance(iter, bytes);
- return bytes;
-}
-
-static inline ssize_t
-generic_file_write_iter(struct kiocb *iocb, struct iov_iter *iter)
-{
- struct iovec iov;
- struct iov_iter i;
- ssize_t bytes = 0;
-
- iov_for_each(iov, i, *iter) {
- ssize_t res;
-
- res = __generic_file_aio_write(iocb, &iov, 1, &iocb->ki_pos);
- if (res <= 0) {
- if (bytes == 0)
- bytes = res;
- break;
- }
-
- bytes += res;
- if (res < iov.iov_len)
- break;
- }
-
- if (bytes > 0)
- iov_iter_advance(iter, bytes);
- return bytes;
-}
-#endif /* HAVE_FILE_OPERATIONS_READ_WRITE_ITER */
#endif /* LLITE_INTERNAL_H */
git://git.whamcloud.com / fs / lustre-release.git / blobdiff