#include <linux/compat.h>
#include <linux/aio.h>
#include <lustre_compat.h>
+#include <lustre_crypto.h>
+
+#ifndef VM_FAULT_RETRY
+#include <linux/mm_types.h>
+#endif
#include "vvp_internal.h"
#include "range_lock.h"
#define LL_MAX_BLKSIZE_BITS 22
#define LL_IT2STR(it) ((it) ? ldlm_it2str((it)->it_op) : "0")
-#define LUSTRE_FPRIVATE(file) ((file)->private_data)
+
+#define TIMES_SET_FLAGS (ATTR_MTIME_SET | ATTR_ATIME_SET | ATTR_TIMES_SET)
struct ll_dentry_data {
- struct lookup_intent *lld_it;
unsigned int lld_sa_generation;
unsigned int lld_invalid:1;
unsigned int lld_nfs_dentry:1;
s64 lli_atime;
s64 lli_mtime;
s64 lli_ctime;
+ s64 lli_btime;
spinlock_t lli_agl_lock;
/* Try to make the d::member and f::member are aligned. Before using
char *lli_symlink_name;
struct ll_trunc_sem lli_trunc_sem;
struct range_lock_tree lli_write_tree;
+ struct mutex lli_setattr_mutex;
struct rw_semaphore lli_glimpse_sem;
ktime_t lli_glimpse_time;
struct mutex lli_group_mutex;
__u64 lli_group_users;
unsigned long lli_group_gid;
+
+ __u64 lli_attr_valid;
+ __u64 lli_lazysize;
+ __u64 lli_lazyblocks;
};
};
wake_up_var(&sem->ll_trunc_readers);
}
+#ifdef CONFIG_LUSTRE_FS_POSIX_ACL
+static inline void lli_clear_acl(struct ll_inode_info *lli)
+{
+ if (lli->lli_posix_acl) {
+ posix_acl_release(lli->lli_posix_acl);
+ lli->lli_posix_acl = NULL;
+ }
+}
+
+static inline void lli_replace_acl(struct ll_inode_info *lli,
+ struct lustre_md *md)
+{
+ spin_lock(&lli->lli_lock);
+ if (lli->lli_posix_acl)
+ posix_acl_release(lli->lli_posix_acl);
+ lli->lli_posix_acl = md->posix_acl;
+ spin_unlock(&lli->lli_lock);
+}
+#else
+static inline void lli_clear_acl(struct ll_inode_info *lli)
+{
+}
+
+static inline void lli_replace_acl(struct ll_inode_info *lli,
+ struct lustre_md *md)
+{
+}
+#endif
+
static inline __u32 ll_layout_version_get(struct ll_inode_info *lli)
{
__u32 gen;
static inline bool obd_connect_has_secctx(struct obd_connect_data *data)
{
-#if defined(HAVE_SECURITY_DENTRY_INIT_SECURITY) && defined(CONFIG_SECURITY)
+#ifdef 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 */
+#endif
}
static inline void obd_connect_set_secctx(struct obd_connect_data *data)
{
-#if defined(HAVE_SECURITY_DENTRY_INIT_SECURITY) && defined(CONFIG_SECURITY)
+#ifdef CONFIG_SECURITY
data->ocd_connect_flags2 |= OBD_CONNECT2_FILE_SECCTX;
-#endif /* HAVE_SECURITY_DENTRY_INIT_SECURITY */
+#endif
}
int ll_dentry_init_security(struct dentry *dentry, int mode, struct qstr *name,
int ll_listsecurity(struct inode *inode, char *secctx_name,
size_t secctx_name_size);
+static inline bool obd_connect_has_enc(struct obd_connect_data *data)
+{
+#ifdef HAVE_LUSTRE_CRYPTO
+ return data->ocd_connect_flags & OBD_CONNECT_FLAGS2 &&
+ data->ocd_connect_flags2 & OBD_CONNECT2_ENCRYPT;
+#else
+ return false;
+#endif
+}
+
+static inline void obd_connect_set_enc(struct obd_connect_data *data)
+{
+#ifdef HAVE_LUSTRE_CRYPTO
+ data->ocd_connect_flags2 |= OBD_CONNECT2_ENCRYPT;
+#endif
+}
+
/*
* Locking to guarantee consistency of non-atomic updates to long long i_size,
* consistency between file size and KMS.
/* 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 MiB_TO_PAGES(64UL)
+/* default readahead on a given system. */
+#define SBI_DEFAULT_READ_AHEAD_MAX MiB_TO_PAGES(64UL)
-/* default to read-ahead full files smaller than 2MB on the second read */
-#define SBI_DEFAULT_READAHEAD_WHOLE_MAX MiB_TO_PAGES(2UL)
+/* default read-ahead full files smaller than limit on the second read */
+#define SBI_DEFAULT_READ_AHEAD_WHOLE_MAX MiB_TO_PAGES(2UL)
enum ra_stat {
RA_STAT_HIT = 0,
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.
+ * Max number of active works could be triggered
+ * for async readahead.
*/
unsigned int ra_async_max_active;
+ /* how many async readahead triggered in flight */
+ atomic_t ra_async_inflight;
/* Threshold to control when to trigger async readahead */
unsigned long ra_async_pages_per_file_threshold;
};
* counted by page index.
*/
struct ra_io_arg {
- pgoff_t ria_start; /* start offset of read-ahead*/
- pgoff_t ria_end; /* end offset of read-ahead*/
- unsigned long ria_reserved; /* reserved pages for read-ahead */
- pgoff_t ria_end_min; /* minimum end to cover current read */
- bool ria_eof; /* reach end of file */
- /* If stride read pattern is detected, ria_stoff means where
- * stride read is started. Note: for normal read-ahead, the
+ pgoff_t ria_start_idx; /* start offset of read-ahead*/
+ pgoff_t ria_end_idx; /* end offset of read-ahead*/
+ unsigned long ria_reserved; /* reserved pages for read-ahead */
+ pgoff_t ria_end_idx_min;/* minimum end to cover current read */
+ bool ria_eof; /* reach end of file */
+ /* If stride read pattern is detected, ria_stoff is the byte offset
+ * where stride read is started. Note: for normal read-ahead, the
* value here is meaningless, and also it will not be accessed*/
- unsigned long ria_stoff;
+ loff_t ria_stoff;
/* ria_length and ria_bytes are the length and pages length in the
* stride I/O mode. And they will also be used to check whether
* it is stride I/O read-ahead in the read-ahead pages*/
- unsigned long ria_length;
- unsigned long ria_bytes;
+ loff_t ria_length;
+ loff_t ria_bytes;
};
/* LL_HIST_MAX=32 causes an overflow */
2.10, abandoned */
#define LL_SBI_TINY_WRITE 0x2000000 /* tiny write support */
#define LL_SBI_FILE_HEAT 0x4000000 /* file heat support */
+#define LL_SBI_TEST_DUMMY_ENCRYPTION 0x8000000 /* test dummy encryption */
+#define LL_SBI_ENCRYPT 0x10000000 /* client side encryption */
#define LL_SBI_FLAGS { \
"nolck", \
"checksum", \
"pio", \
"tiny_write", \
"file_heat", \
+ "test_dummy_encryption", \
+ "noencrypt", \
}
/* This is embedded into llite super-blocks to keep track of connect
* per file-descriptor read-ahead data.
*/
struct ll_readahead_state {
- spinlock_t ras_lock;
+ spinlock_t ras_lock;
/* End byte that read(2) try to read. */
- unsigned long ras_last_read_end;
+ loff_t ras_last_read_end_bytes;
/*
* number of bytes read after last read-ahead window reset. As window
* is reset on each seek, this is effectively a number of consecutive
* case, it probably doesn't make sense to expand window to
* PTLRPC_MAX_BRW_PAGES on the third access.
*/
- unsigned long ras_consecutive_bytes;
+ loff_t ras_consecutive_bytes;
/*
* number of read requests after the last read-ahead window reset
* As window is reset on each seek, this is effectively the number
* on consecutive read request and is used to trigger read-ahead.
*/
- unsigned long ras_consecutive_requests;
+ unsigned long ras_consecutive_requests;
/*
* Parameters of current read-ahead window. Handled by
* ras_update(). On the initial access to the file or after a seek,
* expanded to PTLRPC_MAX_BRW_PAGES. Afterwards, window is enlarged by
* PTLRPC_MAX_BRW_PAGES chunks up to ->ra_max_pages.
*/
- pgoff_t ras_window_start, ras_window_len;
+ pgoff_t ras_window_start_idx;
+ pgoff_t ras_window_pages;
/*
- * Optimal RPC size. It decides how many pages will be sent
- * for each read-ahead.
+ * Optimal RPC size in pages.
+ * It decides how many pages will be sent for each read-ahead.
*/
- unsigned long ras_rpc_size;
+ unsigned long ras_rpc_pages;
/*
* Where next read-ahead should start at. This lies within read-ahead
* window. Read-ahead window is read in pieces rather than at once
* ->ra_max_pages (see ll_ra_count_get()), 2. client cannot read pages
* not covered by DLM lock.
*/
- pgoff_t ras_next_readahead;
+ pgoff_t ras_next_readahead_idx;
/*
* Total number of ll_file_read requests issued, reads originating
* due to mmap are not counted in this total. This value is used to
* trigger full file read-ahead after multiple reads to a small file.
*/
- unsigned long ras_requests;
+ unsigned long ras_requests;
/*
* The following 3 items are used for detecting the stride I/O
* mode.
* ras_stride_bytes = stride_bytes;
* Note: all these three items are counted by bytes.
*/
- unsigned long ras_stride_length;
- unsigned long ras_stride_bytes;
- unsigned long ras_stride_offset;
+ loff_t ras_stride_offset;
+ loff_t ras_stride_length;
+ loff_t ras_stride_bytes;
/*
* number of consecutive stride request count, and it is similar as
* ras_consecutive_requests, but used for stride I/O mode.
* Note: only more than 2 consecutive stride request are detected,
* stride read-ahead will be enable
*/
- unsigned long ras_consecutive_stride_requests;
+ unsigned long ras_consecutive_stride_requests;
/* index of the last page that async readahead starts */
- pgoff_t ras_async_last_readpage;
+ pgoff_t ras_async_last_readpage_idx;
/* whether we should increase readahead window */
- bool ras_need_increase_window;
+ bool ras_need_increase_window;
/* whether ra miss check should be skipped */
- bool ras_no_miss_check;
+ bool ras_no_miss_check;
};
struct ll_readahead_work {
/** File to readahead */
struct file *lrw_file;
- /** Start bytes */
- unsigned long lrw_start;
- /** End bytes */
- unsigned long lrw_end;
+ pgoff_t lrw_start_idx;
+ pgoff_t lrw_end_idx;
/* async worker to handler read */
struct work_struct lrw_readahead_work;
+ char lrw_jobid[LUSTRE_JOBID_SIZE];
};
extern struct kmem_cache *ll_file_data_slab;
return !!(sbi->ll_flags & LL_SBI_FILE_HEAT);
}
-void ll_ras_enter(struct file *f, unsigned long pos, unsigned long count);
+void ll_ras_enter(struct file *f, loff_t pos, size_t count);
/* llite/lcommon_misc.c */
int cl_ocd_update(struct obd_device *host, struct obd_device *watched,
LPROC_LL_LISTXATTR,
LPROC_LL_REMOVEXATTR,
LPROC_LL_INODE_PERM,
+ LPROC_LL_FALLOCATE,
LPROC_LL_FILE_OPCODES
};
#else
int ll_getattr(struct vfsmount *mnt, struct dentry *de, struct kstat *stat);
#endif
-int ll_getattr_dentry(struct dentry *de, struct kstat *stat);
+int ll_getattr_dentry(struct dentry *de, struct kstat *stat, u32 request_mask,
+ unsigned int flags);
struct posix_acl *ll_get_acl(struct inode *inode, int type);
#ifdef HAVE_IOP_SET_ACL
#ifdef CONFIG_LUSTRE_FS_POSIX_ACL
#endif /* CONFIG_LUSTRE_FS_POSIX_ACL */
#endif
+
+static inline int ll_xflags_to_inode_flags(int xflags)
+{
+ return ((xflags & FS_XFLAG_SYNC) ? S_SYNC : 0) |
+ ((xflags & FS_XFLAG_NOATIME) ? S_NOATIME : 0) |
+ ((xflags & FS_XFLAG_APPEND) ? S_APPEND : 0) |
+ ((xflags & FS_XFLAG_IMMUTABLE) ? S_IMMUTABLE : 0);
+}
+
+static inline int ll_inode_flags_to_xflags(int flags)
+{
+ return ((flags & S_SYNC) ? FS_XFLAG_SYNC : 0) |
+ ((flags & S_NOATIME) ? FS_XFLAG_NOATIME : 0) |
+ ((flags & S_APPEND) ? FS_XFLAG_APPEND : 0) |
+ ((flags & S_IMMUTABLE) ? FS_XFLAG_IMMUTABLE : 0);
+}
+
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 ll_flush_ctx(struct inode *inode);
void ll_umount_begin(struct super_block *sb);
int ll_remount_fs(struct super_block *sb, int *flags, char *data);
-#ifdef HAVE_SUPEROPS_USE_DENTRY
int ll_show_options(struct seq_file *seq, struct dentry *dentry);
-#else
-int ll_show_options(struct seq_file *seq, struct vfsmount *vfs);
-#endif
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 *);
sai_agl_valid:1,/* AGL is valid for the dir */
sai_in_readpage:1;/* statahead is in readdir()*/
wait_queue_head_t sai_waitq; /* stat-ahead wait queue */
- struct ptlrpc_thread sai_thread; /* stat-ahead thread */
- struct ptlrpc_thread sai_agl_thread; /* AGL thread */
+ struct task_struct *sai_task; /* stat-ahead thread */
+ struct task_struct *sai_agl_task; /* AGL thread */
struct list_head sai_interim_entries; /* entries which got async
* stat reply, but not
* instantiated */
atomic_t sai_cache_count; /* entry count in cache */
};
-int ll_statahead(struct inode *dir, struct dentry **dentry, bool unplug);
+int ll_revalidate_statahead(struct inode *dir, struct dentry **dentry,
+ bool unplug);
+int ll_start_statahead(struct inode *dir, struct dentry *dentry, bool agl);
void ll_authorize_statahead(struct inode *dir, void *key);
void ll_deauthorize_statahead(struct inode *dir, void *key);
return false;
/* not the same process, don't statahead */
- if (lli->lli_opendir_pid != current_pid())
+ if (lli->lli_opendir_pid != current->pid)
return false;
/*
* 'lld_sa_generation == lli->lli_sa_generation'.
*/
ldd = ll_d2d(dentry);
- if (ldd != NULL && ldd->lld_sa_generation == lli->lli_sa_generation)
+ if (ldd != NULL && lli->lli_sa_generation &&
+ ldd->lld_sa_generation == lli->lli_sa_generation)
return false;
return true;
static inline int ll_file_nolock(const struct file *file)
{
- struct ll_file_data *fd = LUSTRE_FPRIVATE(file);
+ struct ll_file_data *fd = file->private_data;
struct inode *inode = file_inode((struct file *)file);
- LASSERT(fd != NULL);
- return ((fd->fd_flags & LL_FILE_IGNORE_LOCK) ||
- (ll_i2sbi(inode)->ll_flags & LL_SBI_NOLCK));
+ LASSERT(fd != NULL);
+ return ((fd->fd_flags & LL_FILE_IGNORE_LOCK) ||
+ (ll_i2sbi(inode)->ll_flags & LL_SBI_NOLCK));
}
static inline void ll_set_lock_data(struct obd_export *exp, struct inode *inode,
*/
static inline void d_lustre_invalidate(struct dentry *dentry, int nested)
{
- CDEBUG(D_DENTRY, "invalidate dentry %.*s (%p) parent %p inode %p "
- "refc %d\n", dentry->d_name.len, dentry->d_name.name, dentry,
+ CDEBUG(D_DENTRY, "invalidate dentry %pd (%p) parent %p inode %p refc %d\n",
+ dentry, dentry,
dentry->d_parent, dentry->d_inode, ll_d_count(dentry));
spin_lock_nested(&dentry->d_lock,
return ll_i2pccs(ll_info2i(lli));
}
+#ifdef HAVE_LUSTRE_CRYPTO
+/* crypto.c */
+extern const struct llcrypt_operations lustre_cryptops;
+#endif
+
#endif /* LLITE_INTERNAL_H */