*/
/*
* This file is part of Lustre, http://www.lustre.org/
- * Lustre is a trademark of Sun Microsystems, Inc.
*/
#ifndef LLITE_INTERNAL_H
#define LLITE_INTERNAL_H
-#include <lustre_debug.h>
+#include <obd.h>
#include <lustre_disk.h> /* for s2sbi */
-#include <lustre_eacl.h>
#include <lustre_linkea.h>
/* for struct cl_lock_descr and struct cl_io */
#include <lustre_intent.h>
#include <linux/compat.h>
#include <linux/aio.h>
+#include <linux/parser.h>
#include <lustre_compat.h>
#include <lustre_crypto.h>
+#include <range_lock.h>
#include "vvp_internal.h"
-#include "range_lock.h"
#include "pcc.h"
+#include "foreign_symlink.h"
#ifndef FMODE_EXEC
#define FMODE_EXEC 0
struct ll_inode_info {
__u32 lli_inode_magic;
- spinlock_t lli_lock;
+ rwlock_t lli_lock;
volatile unsigned long lli_flags;
struct posix_acl *lli_posix_acl;
__u64 lli_open_fd_read_count;
__u64 lli_open_fd_write_count;
__u64 lli_open_fd_exec_count;
+
+ /* Number of times this inode was opened */
+ u64 lli_open_fd_count;
+ /* When last close was performed on this inode */
+ ktime_t lli_close_fd_time;
+
/* Protects access to och pointers and their usage counters */
struct mutex lli_och_mutex;
/* "opendir_pid" is the token when lookup/revalid
* -- I am the owner of dir statahead. */
pid_t lli_opendir_pid;
+ /* directory depth to ROOT */
+ unsigned short lli_dir_depth;
+ /* directory depth to ancestor whose default LMV is
+ * inherited.
+ */
+ unsigned short lli_inherit_depth;
/* stat will try to access statahead entries or start
* statahead if this flag is set, and this flag will be
* set upon dir open, and cleared when dir is closed,
* statahead hit ratio is too low, or start statahead
* thread failed. */
- unsigned int lli_sa_enabled:1;
+ unsigned short lli_sa_enabled:1;
/* generation for statahead */
unsigned int lli_sa_generation;
/* rw lock protects lli_lsm_md */
struct rw_semaphore lli_xattrs_list_rwsem;
struct mutex lli_xattrs_enq_lock;
struct list_head lli_xattrs; /* ll_xattr_entry->xe_list */
+ struct list_head lli_lccs; /* list of ll_cl_context */
};
+#ifndef HAVE_USER_NAMESPACE_ARG
+#define inode_permission(ns, inode, mask) inode_permission(inode, mask)
+#define generic_permission(ns, inode, mask) generic_permission(inode, mask)
+#define simple_setattr(ns, de, iattr) simple_setattr(de, iattr)
+#define ll_inode_permission(ns, inode, mask) ll_inode_permission(inode, mask)
+#ifdef HAVE_INODEOPS_ENHANCED_GETATTR
+#define ll_getattr(ns, path, stat, mask, fl) ll_getattr(path, stat, mask, fl)
+#endif /* HAVE_INODEOPS_ENHANCED_GETATTR */
+#define ll_setattr(ns, de, attr) ll_setattr(de, attr)
+#endif
+
static inline void ll_trunc_sem_init(struct ll_trunc_sem *sem)
{
atomic_set(&sem->ll_trunc_readers, 0);
*
* We must take lli_trunc_sem in read mode on entry in to various i/o paths
* in Lustre, in order to exclude truncates. Some of these paths then need to
- * take the mmap_sem, while still holding the trunc_sem. The problem is that
- * page faults hold the mmap_sem when calling in to Lustre, and then must also
+ * take the mmap_lock, while still holding the trunc_sem. The problem is that
+ * page faults hold the mmap_lock when calling in to Lustre, and then must also
* take the trunc_sem to exclude truncate.
*
- * This means the locking order for trunc_sem and mmap_sem is sometimes AB,
+ * This means the locking order for trunc_sem and mmap_lock is sometimes AB,
* sometimes BA. This is almost OK because in both cases, we take the trunc
* sem for read, so it doesn't block.
*
*
* So we have, on our truncate sem, in order (where 'reader' and 'writer' refer
* to the mode in which they take the semaphore):
- * reader (holding mmap_sem, needs truncate_sem)
+ * reader (holding mmap_lock, needs truncate_sem)
* writer
- * reader (holding truncate sem, waiting for mmap_sem)
+ * reader (holding truncate sem, waiting for mmap_lock)
*
* And so the readers deadlock.
*
* of the order they arrived in.
*
* down_read_nowait is only used in the page fault case, where we already hold
- * the mmap_sem. This is because otherwise repeated read and write operations
+ * the mmap_lock. This is because otherwise repeated read and write operations
* (which take the truncate sem) could prevent a truncate from ever starting.
* This could still happen with page faults, but without an even more complex
* mechanism, this is unavoidable.
static inline void trunc_sem_up_write(struct ll_trunc_sem *sem)
{
atomic_set(&sem->ll_trunc_readers, 0);
+ /* match the smp_mb() in wait_var_event()->prepare_to_wait() */
+ smp_mb();
wake_up_var(&sem->ll_trunc_readers);
}
static inline void lli_replace_acl(struct ll_inode_info *lli,
struct lustre_md *md)
{
- spin_lock(&lli->lli_lock);
+ write_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);
+ write_unlock(&lli->lli_lock);
}
#else
static inline void lli_clear_acl(struct ll_inode_info *lli)
LLIF_PROJECT_INHERIT = 3,
/* update atime from MDS even if it's older than local inode atime. */
LLIF_UPDATE_ATIME = 4,
+ /* foreign file/dir can be unlinked unconditionnaly */
+ LLIF_FOREIGN_REMOVABLE = 5,
+ /* Xattr cache is filled */
+ LLIF_XATTR_CACHE_FILLED = 7,
};
-static inline void ll_file_set_flag(struct ll_inode_info *lli,
- enum ll_file_flags flag)
-{
- set_bit(flag, &lli->lli_flags);
-}
-
-static inline void ll_file_clear_flag(struct ll_inode_info *lli,
- enum ll_file_flags flag)
-{
- clear_bit(flag, &lli->lli_flags);
-}
-
-static inline bool ll_file_test_flag(struct ll_inode_info *lli,
- enum ll_file_flags flag)
-{
- return test_bit(flag, &lli->lli_flags);
-}
-
-static inline bool ll_file_test_and_clear_flag(struct ll_inode_info *lli,
- enum ll_file_flags flag)
-{
- return test_and_clear_bit(flag, &lli->lli_flags);
-}
-
int ll_xattr_cache_destroy(struct inode *inode);
+int ll_xattr_cache_empty(struct inode *inode);
int ll_xattr_cache_get(struct inode *inode,
const char *name,
#endif
}
+static inline bool obd_connect_has_name_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_NAME;
+#else
+ return false;
+#endif
+}
+
+static inline void obd_connect_set_name_enc(struct obd_connect_data *data)
+{
+#ifdef HAVE_LUSTRE_CRYPTO
+ data->ocd_connect_flags2 |= OBD_CONNECT2_ENCRYPT_NAME;
+#endif
+}
+
/*
* Locking to guarantee consistency of non-atomic updates to long long i_size,
* consistency between file size and KMS.
/* default read-ahead full files smaller than limit on the second read */
#define SBI_DEFAULT_READ_AHEAD_WHOLE_MAX MiB_TO_PAGES(2UL)
+/* default range pages */
+#define SBI_DEFAULT_RA_RANGE_PAGES MiB_TO_PAGES(1ULL)
+
+/* Min range pages */
+#define RA_MIN_MMAP_RANGE_PAGES 16UL
+
enum ra_stat {
RA_STAT_HIT = 0,
RA_STAT_MISS,
RA_STAT_FAILED_REACH_END,
RA_STAT_ASYNC,
RA_STAT_FAILED_FAST_READ,
+ RA_STAT_MMAP_RANGE_READ,
_NR_RA_STAT,
};
atomic_t ra_cur_pages;
unsigned long ra_max_pages;
unsigned long ra_max_pages_per_file;
+ unsigned long ra_range_pages;
unsigned long ra_max_read_ahead_whole_pages;
struct workqueue_struct *ll_readahead_wq;
/*
#define LL_HIST_START 12 /* buckets start at 2^12 = 4k */
#define LL_PROCESS_HIST_MAX 10
struct per_process_info {
- pid_t pid;
- struct obd_histogram pp_r_hist;
- struct obd_histogram pp_w_hist;
+ pid_t pid;
+ struct obd_histogram pp_r_hist;
+ struct obd_histogram pp_w_hist;
};
/* pp_extents[LL_PROCESS_HIST_MAX] will hold the combined process info */
struct ll_rw_extents_info {
- struct per_process_info pp_extents[LL_PROCESS_HIST_MAX + 1];
+ ktime_t pp_init;
+ struct per_process_info pp_extents[LL_PROCESS_HIST_MAX + 1];
};
#define LL_OFFSET_HIST_MAX 100
};
/* flags for sbi->ll_flags */
-#define LL_SBI_NOLCK 0x01 /* DLM locking disabled (directio-only) */
-#define LL_SBI_CHECKSUM 0x02 /* checksum each page as it's written */
-#define LL_SBI_FLOCK 0x04
-#define LL_SBI_USER_XATTR 0x08 /* support user xattr */
-#define LL_SBI_ACL 0x10 /* support ACL */
-/* LL_SBI_RMT_CLIENT 0x40 remote client */
-#define LL_SBI_MDS_CAPA 0x80 /* support mds capa, obsolete */
-#define LL_SBI_OSS_CAPA 0x100 /* support oss capa, obsolete */
-#define LL_SBI_LOCALFLOCK 0x200 /* Local flocks support by kernel */
-#define LL_SBI_LRU_RESIZE 0x400 /* lru resize support */
-#define LL_SBI_LAZYSTATFS 0x800 /* lazystatfs mount option */
-/* LL_SBI_SOM_PREVIEW 0x1000 SOM preview mount option, obsolete */
-#define LL_SBI_32BIT_API 0x2000 /* generate 32 bit inodes. */
-#define LL_SBI_64BIT_HASH 0x4000 /* support 64-bits dir hash/offset */
-#define LL_SBI_AGL_ENABLED 0x8000 /* enable agl */
-#define LL_SBI_VERBOSE 0x10000 /* verbose mount/umount */
-#define LL_SBI_LAYOUT_LOCK 0x20000 /* layout lock support */
-#define LL_SBI_USER_FID2PATH 0x40000 /* allow fid2path by unprivileged users */
-#define LL_SBI_XATTR_CACHE 0x80000 /* support for xattr cache */
-#define LL_SBI_NOROOTSQUASH 0x100000 /* do not apply root squash */
-#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_TEST_DUMMY_ENCRYPTION 0x8000000 /* test dummy encryption */
-#define LL_SBI_ENCRYPT 0x10000000 /* client side encryption */
-#define LL_SBI_FLAGS { \
- "nolck", \
- "checksum", \
- "flock", \
- "user_xattr", \
- "acl", \
- "???", \
- "???", \
- "mds_capa", \
- "oss_capa", \
- "flock", \
- "lru_resize", \
- "lazy_statfs", \
- "som", \
- "32bit_api", \
- "64bit_hash", \
- "agl", \
- "verbose", \
- "layout", \
- "user_fid2path",\
- "xattr_cache", \
- "norootsquash", \
- "always_ping", \
- "fast_read", \
- "file_secctx", \
- "pio", \
- "tiny_write", \
- "file_heat", \
- "test_dummy_encryption", \
- "noencrypt", \
-}
+enum ll_sbi_flags {
+ LL_SBI_NOLCK, /* DLM locking disabled directio-only */
+ LL_SBI_CHECKSUM, /* checksum each page as it's written */
+ LL_SBI_LOCALFLOCK, /* local flocks instead of fs-wide */
+ LL_SBI_FLOCK, /* flock enabled */
+ LL_SBI_USER_XATTR, /* support user xattr */
+ LL_SBI_LRU_RESIZE, /* lru resize support */
+ LL_SBI_LAZYSTATFS, /* lazystatfs mount option */
+ LL_SBI_32BIT_API, /* generate 32 bit inodes. */
+ LL_SBI_USER_FID2PATH, /* fid2path by unprivileged users */
+ LL_SBI_VERBOSE, /* verbose mount/umount */
+ LL_SBI_ALWAYS_PING, /* ping even if server suppress_pings */
+ LL_SBI_TEST_DUMMY_ENCRYPTION, /* test dummy encryption */
+ LL_SBI_ENCRYPT, /* client side encryption */
+ LL_SBI_FOREIGN_SYMLINK, /* foreign fake-symlink support */
+ LL_SBI_FOREIGN_SYMLINK_UPCALL, /* foreign fake-symlink upcall set */
+ LL_SBI_NUM_MOUNT_OPT,
+
+ LL_SBI_ACL, /* support ACL */
+ LL_SBI_AGL_ENABLED, /* enable agl */
+ LL_SBI_64BIT_HASH, /* support 64-bits dir hash/offset */
+ LL_SBI_LAYOUT_LOCK, /* layout lock support */
+ LL_SBI_XATTR_CACHE, /* support for xattr cache */
+ LL_SBI_NOROOTSQUASH, /* do not apply root squash */
+ LL_SBI_FAST_READ, /* fast read support */
+ LL_SBI_FILE_SECCTX, /* file security context at create */
+ LL_SBI_TINY_WRITE, /* tiny write support */
+ LL_SBI_FILE_HEAT, /* file heat support */
+ LL_SBI_PARALLEL_DIO, /* parallel (async) O_DIRECT RPCs */
+ LL_SBI_ENCRYPT_NAME, /* name encryption */
+ LL_SBI_NUM_FLAGS
+};
+
+int ll_sbi_flags_seq_show(struct seq_file *m, void *v);
/* This is embedded into llite super-blocks to keep track of connect
* flags (capabilities) supported by all imports given mount is
struct obd_device *ll_dt_obd;
struct dentry *ll_debugfs_entry;
struct lu_fid ll_root_fid; /* root object fid */
+ struct mnt_namespace *ll_mnt_ns;
- int ll_flags;
- 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;
+ DECLARE_BITMAP(ll_flags, LL_SBI_NUM_FLAGS); /* enum ll_sbi_flags */
+ 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,
+ ll_inode_cache_enabled:1;
- struct lustre_client_ocd ll_lco;
+ struct lustre_client_ocd ll_lco;
- struct lprocfs_stats *ll_stats; /* lprocfs stats counter */
+ struct lprocfs_stats *ll_stats; /* lprocfs stats counter */
/* Used to track "unstable" pages on a client, and maintain a
* LRU list of clean pages. An "unstable" page is defined as
* but is uncommitted to stable storage. */
struct cl_client_cache *ll_cache;
- struct lprocfs_stats *ll_ra_stats;
-
- struct ll_ra_info ll_ra_info;
- unsigned int ll_namelen;
- struct file_operations *ll_fop;
-
- struct lu_site *ll_site;
- struct cl_device *ll_cl;
- /* Statistics */
- struct ll_rw_extents_info ll_rw_extents_info;
- int ll_extent_process_count;
- struct ll_rw_process_info ll_rw_process_info[LL_PROCESS_HIST_MAX];
- unsigned int ll_offset_process_count;
- struct ll_rw_process_info ll_rw_offset_info[LL_OFFSET_HIST_MAX];
- unsigned int ll_rw_offset_entry_count;
- int ll_stats_track_id;
- enum stats_track_type ll_stats_track_type;
- int ll_rw_stats_on;
+ struct lprocfs_stats *ll_ra_stats;
+
+ struct ll_ra_info ll_ra_info;
+ unsigned int ll_namelen;
+ const struct file_operations *ll_fop;
+
+ struct lu_site *ll_site;
+ struct cl_device *ll_cl;
+
+ /* Statistics */
+ struct ll_rw_extents_info *ll_rw_extents_info;
+ int ll_extent_process_count;
+ unsigned int ll_offset_process_count;
+ struct ll_rw_process_info *ll_rw_process_info;
+ struct ll_rw_process_info *ll_rw_offset_info;
+ ktime_t ll_process_stats_init;
+ unsigned int ll_rw_offset_entry_count;
+ int ll_stats_track_id;
+ enum stats_track_type ll_stats_track_type;
+ int ll_rw_stats_on;
/* metadata stat-ahead */
unsigned int ll_sa_running_max;/* max concurrent
unsigned int ll_heat_decay_weight;
unsigned int ll_heat_period_second;
+ /* Opens of the same inode before we start requesting open lock */
+ u32 ll_oc_thrsh_count;
+
+ /* Time in ms between last inode close and next open to be considered
+ * instant back to back and would trigger an open lock request
+ */
+ u32 ll_oc_thrsh_ms;
+
+ /* Time in ms after last file close that we no longer count prior opens*/
+ u32 ll_oc_max_ms;
+
/* filesystem fsname */
char ll_fsname[LUSTRE_MAXFSNAME + 1];
/* Persistent Client Cache */
struct pcc_super ll_pcc_super;
+
+ /* to protect vs updates in all following foreign symlink fields */
+ struct rw_semaphore ll_foreign_symlink_sem;
+ /* foreign symlink path prefix */
+ char *ll_foreign_symlink_prefix;
+ /* full prefix size including leading '\0' */
+ size_t ll_foreign_symlink_prefix_size;
+ /* foreign symlink path upcall */
+ char *ll_foreign_symlink_upcall;
+ /* foreign symlink path upcall infos */
+ struct ll_foreign_symlink_upcall_item *ll_foreign_symlink_upcall_items;
+ /* foreign symlink path upcall nb infos */
+ unsigned int ll_foreign_symlink_upcall_nb_items;
};
#define SBI_DEFAULT_HEAT_DECAY_WEIGHT ((80 * 256 + 50) / 100)
#define SBI_DEFAULT_HEAT_PERIOD_SECOND (60)
+
+#define SBI_DEFAULT_OPENCACHE_THRESHOLD_COUNT (5)
+#define SBI_DEFAULT_OPENCACHE_THRESHOLD_MS (100) /* 0.1 second */
+#define SBI_DEFAULT_OPENCACHE_THRESHOLD_MAX_MS (60000) /* 1 minute */
+
/*
* per file-descriptor read-ahead data.
*/
*/
pgoff_t ras_window_start_idx;
pgoff_t ras_window_pages;
+
+ /* Page index where min range read starts */
+ pgoff_t ras_range_min_start_idx;
+ /* Page index where mmap range read ends */
+ pgoff_t ras_range_max_end_idx;
+ /* number of mmap pages where last time detected */
+ pgoff_t ras_last_range_pages;
+ /* number of mmap range requests */
+ pgoff_t ras_range_requests;
+
/*
* Optimal RPC size in pages.
* It decides how many pages will be sent for each read-ahead.
struct file *lrw_file;
pgoff_t lrw_start_idx;
pgoff_t lrw_end_idx;
+ pid_t lrw_user_pid;
/* async worker to handler read */
struct work_struct lrw_readahead_work;
* 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;
* layout version for verification to OST objects */
__u32 fd_layout_version;
struct pcc_file fd_pcc_file;
+ /* striped directory may read partially if some stripe inaccessible,
+ * -errno is saved here, and will return to user in close().
+ */
+ int fd_partial_readdir_rc;
};
void llite_tunables_unregister(void);
#if BITS_PER_LONG == 32
return 1;
#elif defined(CONFIG_COMPAT)
- if (unlikely(sbi->ll_flags & LL_SBI_32BIT_API))
+ if (unlikely(test_bit(LL_SBI_32BIT_API, sbi->ll_flags)))
return true;
# ifdef CONFIG_X86_X32
return unlikely(in_compat_syscall());
#else
- return unlikely(sbi->ll_flags & LL_SBI_32BIT_API);
+ return unlikely(test_bit(LL_SBI_32BIT_API, sbi->ll_flags));
#endif
}
static inline bool ll_sbi_has_fast_read(struct ll_sb_info *sbi)
{
- return !!(sbi->ll_flags & LL_SBI_FAST_READ);
+ return test_bit(LL_SBI_FAST_READ, sbi->ll_flags);
}
static inline bool ll_sbi_has_tiny_write(struct ll_sb_info *sbi)
{
- return !!(sbi->ll_flags & LL_SBI_TINY_WRITE);
+ return test_bit(LL_SBI_TINY_WRITE, sbi->ll_flags);
}
static inline bool ll_sbi_has_file_heat(struct ll_sb_info *sbi)
{
- return !!(sbi->ll_flags & LL_SBI_FILE_HEAT);
+ return test_bit(LL_SBI_FILE_HEAT, sbi->ll_flags);
+}
+
+static inline bool ll_sbi_has_foreign_symlink(struct ll_sb_info *sbi)
+{
+ return test_bit(LL_SBI_FOREIGN_SYMLINK, sbi->ll_flags);
+}
+
+static inline bool ll_sbi_has_parallel_dio(struct ll_sb_info *sbi)
+{
+ return test_bit(LL_SBI_PARALLEL_DIO, sbi->ll_flags);
}
void ll_ras_enter(struct file *f, loff_t pos, size_t count);
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, long count);
+void ll_free_rw_stats_info(struct ll_sb_info *sbi);
enum {
LPROC_LL_READ_BYTES,
LPROC_LL_REMOVEXATTR,
LPROC_LL_INODE_PERM,
LPROC_LL_FALLOCATE,
+ LPROC_LL_INODE_OCOUNT,
+ LPROC_LL_INODE_OPCLTM,
LPROC_LL_FILE_OPCODES
};
GET_DEFAULT_LAYOUT_ROOT = 1,
};
-struct ll_dir_chain {
-};
-
-static inline void ll_dir_chain_init(struct ll_dir_chain *chain)
-{
-}
-
-static inline void ll_dir_chain_fini(struct ll_dir_chain *chain)
-{
-}
-
extern const struct file_operations ll_dir_operations;
extern const struct inode_operations ll_dir_inode_operations;
#ifdef HAVE_DIR_CONTEXT
int ll_dir_read(struct inode *inode, __u64 *pos, struct md_op_data *op_data,
- struct dir_context *ctx);
+ struct dir_context *ctx, int *partial_readdir_rc);
#else
int ll_dir_read(struct inode *inode, __u64 *pos, struct md_op_data *op_data,
- void *cookie, filldir_t filldir);
+ void *cookie, filldir_t filldir, int *partial_readdir_rc);
#endif
int ll_get_mdt_idx(struct inode *inode);
int ll_get_mdt_idx_by_fid(struct ll_sb_info *sbi, const struct lu_fid *fid);
struct page *ll_get_dir_page(struct inode *dir, struct md_op_data *op_data,
- __u64 offset, struct ll_dir_chain *chain);
+ __u64 offset, int *partial_readdir_rc);
void ll_release_page(struct inode *inode, struct page *page, bool remove);
+int quotactl_ioctl(struct super_block *sb, struct if_quotactl *qctl);
/* llite/namei.c */
extern const struct inode_operations ll_special_inode_operations;
int vvp_io_write_commit(const struct lu_env *env, struct cl_io *io);
enum lcc_type;
-void ll_cl_add(struct file *file, const struct lu_env *env, struct cl_io *io,
+void ll_cl_add(struct inode *inode, const struct lu_env *env, struct cl_io *io,
enum lcc_type type);
-void ll_cl_remove(struct file *file, const struct lu_env *env);
-struct ll_cl_context *ll_cl_find(struct file *file);
+void ll_cl_remove(struct inode *inode, const struct lu_env *env);
+struct ll_cl_context *ll_cl_find(struct inode *inode);
extern const struct address_space_operations ll_aops;
/* llite/file.c */
-extern struct file_operations ll_file_operations;
-extern struct file_operations ll_file_operations_flock;
-extern struct file_operations ll_file_operations_noflock;
-extern struct inode_operations ll_file_inode_operations;
+extern const struct inode_operations ll_file_inode_operations;
+const struct file_operations *ll_select_file_operations(struct ll_sb_info *sbi);
extern int ll_have_md_lock(struct inode *inode, __u64 *bits,
enum ldlm_mode l_req_mode);
extern enum ldlm_mode ll_take_md_lock(struct inode *inode, __u64 bits,
int ll_file_release(struct inode *inode, struct file *file);
int ll_release_openhandle(struct dentry *, struct lookup_intent *);
int ll_md_real_close(struct inode *inode, fmode_t fmode);
+void ll_track_file_opens(struct inode *inode);
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);
+#if defined(HAVE_USER_NAMESPACE_ARG) || defined(HAVE_INODEOPS_ENHANCED_GETATTR)
+int ll_getattr(struct user_namespace *mnt_userns, 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
+#endif /* HAVE_USER_NAMESPACE_ARG */
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
+ unsigned int flags, bool foreign);
#ifdef CONFIG_LUSTRE_FS_POSIX_ACL
-int ll_set_acl(struct inode *inode, struct posix_acl *acl, int type);
+struct posix_acl *ll_get_acl(struct inode *inode, int type
+#ifdef HAVE_GET_ACL_RCU_ARG
+ , bool rcu
+#endif /* HAVE_GET_ACL_RCU_ARG */
+ );
+int ll_set_acl(struct user_namespace *mnt_userns, struct inode *inode,
+ struct posix_acl *acl, int type);
#else /* !CONFIG_LUSTRE_FS_POSIX_ACL */
+#define ll_get_acl NULL
#define ll_set_acl NULL
#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_IMMUTABLE) ? S_IMMUTABLE : 0);
}
-static inline int ll_inode_flags_to_xflags(int flags)
+static inline int ll_inode_flags_to_xflags(int inode_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);
+ return ((inode_flags & S_SYNC) ? FS_XFLAG_SYNC : 0) |
+ ((inode_flags & S_NOATIME) ? FS_XFLAG_NOATIME : 0) |
+ ((inode_flags & S_APPEND) ? FS_XFLAG_APPEND : 0) |
+ ((inode_flags & S_IMMUTABLE) ? FS_XFLAG_IMMUTABLE : 0);
}
int ll_migrate(struct inode *parent, struct file *file,
- struct lmv_user_md *lum, const char *name);
+ struct lmv_user_md *lum, const char *name, __u32 flags);
int ll_get_fid_by_name(struct inode *parent, const char *name,
int namelen, struct lu_fid *fid, struct inode **inode);
-int ll_inode_permission(struct inode *inode, int mask);
-int ll_ioctl_check_project(struct inode *inode, struct fsxattr *fa);
+int ll_inode_permission(struct user_namespace *mnt_userns, struct inode *inode,
+ int mask);
+int ll_ioctl_check_project(struct inode *inode, __u32 xflags, __u32 projid);
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_ioctl_project(struct file *file, 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,
struct ptlrpc_request **request);
int ll_dir_setstripe(struct inode *inode, struct lov_user_md *lump,
int set_default);
+int ll_dir_get_default_layout(struct inode *inode, void **plmm, int *plmm_size,
+ struct ptlrpc_request **request, u64 valid,
+ enum get_default_layout_type type);
int ll_dir_getstripe_default(struct inode *inode, void **lmmp,
int *lmm_size, struct ptlrpc_request **request,
struct ptlrpc_request **root_request, u64 valid);
/* llite/dcache.c */
-int ll_d_init(struct dentry *de);
extern const struct dentry_operations ll_d_ops;
+#ifndef HAVE_D_INIT
+bool ll_d_setup(struct dentry *de, bool do_put);
+
+static inline bool lld_is_init(struct dentry *dentry)
+{
+ return ll_d2d(dentry);
+}
+#else
+#define ll_d_setup(de, do_put) (true)
+#define lld_is_init(dentry) (true)
+#endif
+
void ll_intent_drop_lock(struct lookup_intent *);
void ll_intent_release(struct lookup_intent *);
void ll_prune_aliases(struct inode *inode);
struct lookup_intent *it, struct dentry *de);
/* llite/llite_lib.c */
-extern struct super_operations lustre_super_operations;
+extern const struct super_operations lustre_super_operations;
void ll_lli_init(struct ll_inode_info *lli);
int ll_fill_super(struct super_block *sb);
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 volatile_ref_file(const char *volatile_name, int volatile_len,
+ struct file **ref_file);
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_setattr(struct user_namespace *mnt_userns, struct dentry *de,
+ struct iattr *attr);
int ll_statfs(struct dentry *de, struct kstatfs *sfs);
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);
+void ll_update_inode_flags(struct inode *inode, unsigned int ext_flags);
+void ll_update_dir_depth(struct inode *dir, struct inode *inode);
int ll_read_inode2(struct inode *inode, void *opaque);
+void ll_truncate_inode_pages_final(struct inode *inode);
void ll_delete_inode(struct inode *inode);
int ll_iocontrol(struct inode *inode, struct file *file,
unsigned int cmd, unsigned long arg);
void ll_umount_begin(struct super_block *sb);
int ll_remount_fs(struct super_block *sb, int *flags, char *data);
int ll_show_options(struct seq_file *seq, struct dentry *dentry);
-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 ll_dirty_page_discard_warn(struct inode *inode, int ioret);
+int ll_prep_inode(struct inode **inode, struct req_capsule *pill,
+ struct super_block *sb, struct lookup_intent *it);
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);
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_open_cleanup(struct super_block *sb, struct req_capsule *pill);
void ll_dom_finish_open(struct inode *inode, struct ptlrpc_request *req);
}
/* llite/llite_nfs.c */
-extern struct export_operations lustre_export_operations;
+extern const struct export_operations lustre_export_operations;
__u32 get_uuid2int(const char *name, int len);
struct inode *search_inode_for_lustre(struct super_block *sb,
const struct lu_fid *fid);
int ll_dir_get_parent_fid(struct inode *dir, struct lu_fid *parent_fid);
/* llite/symlink.c */
-extern struct inode_operations ll_fast_symlink_inode_operations;
+extern const struct inode_operations ll_fast_symlink_inode_operations;
/**
* IO arguments for various VFS I/O interfaces.
/* llite/llite_mmap.c */
-int ll_teardown_mmaps(struct address_space *mapping, __u64 first, __u64 last);
int ll_file_mmap(struct file * file, struct vm_area_struct * vma);
void policy_from_vma(union ldlm_policy_data *policy, struct vm_area_struct *vma,
unsigned long addr, size_t count);
static inline bool ll_dir_striped(struct inode *inode)
{
+ struct ll_inode_info *lli;
+ bool rc;
+
LASSERT(inode);
- return S_ISDIR(inode->i_mode) &&
- lmv_dir_striped(ll_i2info(inode)->lli_lsm_md);
+ if (!S_ISDIR(inode->i_mode))
+ return false;
+
+ lli = ll_i2info(inode);
+ if (!lli->lli_lsm_md)
+ return false;
+
+ down_read(&lli->lli_lsm_sem);
+ rc = lmv_dir_striped(lli->lli_lsm_md);
+ up_read(&lli->lli_lsm_sem);
+
+ return rc;
}
static inline loff_t ll_file_maxbytes(struct inode *inode)
#define XATTR_ACL_DEFAULT_T 5
#define XATTR_LUSTRE_T 6
#define XATTR_OTHER_T 7
+#define XATTR_ENCRYPTION_T 9
ssize_t ll_listxattr(struct dentry *dentry, char *buffer, size_t size);
int ll_xattr_list(struct inode *inode, const char *name, int type,
*/
unsigned int sai_ls_all:1, /* "ls -al", do stat-ahead for
* hidden entries */
- 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 task_struct *sai_task; /* stat-ahead thread */
LASSERT(fd != NULL);
return ((fd->fd_flags & LL_FILE_IGNORE_LOCK) ||
- (ll_i2sbi(inode)->ll_flags & LL_SBI_NOLCK));
+ test_bit(LL_SBI_NOLCK, ll_i2sbi(inode)->ll_flags));
}
static inline void ll_set_lock_data(struct obd_export *exp, struct inode *inode,
static inline int d_lustre_invalid(const struct dentry *dentry)
{
- struct ll_dentry_data *lld = ll_d2d(dentry);
-
- return (lld == NULL) || lld->lld_invalid;
-}
-
-static inline void __d_lustre_invalidate(struct dentry *dentry)
-{
- struct ll_dentry_data *lld = ll_d2d(dentry);
-
- if (lld != NULL)
- lld->lld_invalid = 1;
+ return !ll_d2d(dentry) || ll_d2d(dentry)->lld_invalid;
}
/*
dentry->d_parent, dentry->d_inode, ll_d_count(dentry));
spin_lock(&dentry->d_lock);
- __d_lustre_invalidate(dentry);
+ if (lld_is_init(dentry))
+ ll_d2d(dentry)->lld_invalid = 1;
spin_unlock(&dentry->d_lock);
}
static inline void d_lustre_revalidate(struct dentry *dentry)
{
spin_lock(&dentry->d_lock);
- LASSERT(ll_d2d(dentry) != NULL);
+ LASSERT(ll_d2d(dentry));
ll_d2d(dentry)->lld_invalid = 0;
spin_unlock(&dentry->d_lock);
}
return ll_i2pccs(ll_info2i(lli));
}
-#ifdef HAVE_LUSTRE_CRYPTO
/* crypto.c */
+/* The digested form is made of a FID (16 bytes) followed by the second-to-last
+ * ciphertext block (16 bytes), so a total length of 32 bytes.
+ * That way, llcrypt does not compute a digested form of this digest.
+ */
+struct ll_digest_filename {
+ struct lu_fid ldf_fid;
+ char ldf_excerpt[LL_CRYPTO_BLOCK_SIZE];
+};
+
+int ll_setup_filename(struct inode *dir, const struct qstr *iname,
+ int lookup, struct llcrypt_name *fname,
+ struct lu_fid *fid);
+int ll_fname_disk_to_usr(struct inode *inode,
+ u32 hash, u32 minor_hash,
+ struct llcrypt_str *iname, struct llcrypt_str *oname,
+ struct lu_fid *fid);
+int ll_revalidate_d_crypto(struct dentry *dentry, unsigned int flags);
+int ll_file_open_encrypt(struct inode *inode, struct file *filp);
+static inline char *xattr_for_enc(struct inode *inode)
+{
+ if (ll_sbi_has_name_encrypt(ll_i2sbi(inode)))
+ return LL_XATTR_NAME_ENCRYPTION_CONTEXT;
+
+ return LL_XATTR_NAME_ENCRYPTION_CONTEXT_OLD;
+}
+#ifdef HAVE_LUSTRE_CRYPTO
extern const struct llcrypt_operations lustre_cryptops;
#endif
+/* llite/llite_foreign.c */
+int ll_manage_foreign(struct inode *inode, struct lustre_md *lmd);
+bool ll_foreign_is_openable(struct dentry *dentry, unsigned int flags);
+bool ll_foreign_is_removable(struct dentry *dentry, bool unset);
+
#endif /* LLITE_INTERNAL_H */
git://git.whamcloud.com / fs / lustre-release.git / blobdiff