#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>
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;
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 */
};
static inline void ll_trunc_sem_init(struct ll_trunc_sem *sem)
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_FOREIGN_REMOVABLE = 5,
/* setting encryption context in progress */
LLIF_SET_ENC_CTX = 6,
+ /* Xattr cache is filled */
+ LLIF_XATTR_CACHE_FILLED = 7,
};
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,
};
/* 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_FOREIGN_SYMLINK 0x20000000 /* foreign fake-symlink support */
-/* foreign fake-symlink upcall registered */
-#define LL_SBI_FOREIGN_SYMLINK_UPCALL 0x40000000
-#define LL_SBI_PARALLEL_DIO 0x80000000 /* parallel (async) submission of
- RPCs for DIO */
-#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", \
- "foreign_symlink", \
- "foreign_symlink_upcall", \
- "parallel_dio", \
-}
+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_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 dentry *ll_debugfs_entry;
struct lu_fid ll_root_fid; /* root object fid */
- 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;
- struct lustre_client_ocd ll_lco;
+ struct lustre_client_ocd ll_lco;
struct lprocfs_stats *ll_stats; /* lprocfs stats counter */
* 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;
#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 !!(sbi->ll_flags & LL_SBI_FOREIGN_SYMLINK);
+ return test_bit(LL_SBI_FOREIGN_SYMLINK, sbi->ll_flags);
}
static inline bool ll_sbi_has_parallel_dio(struct ll_sb_info *sbi)
{
- return !!(sbi->ll_flags & LL_SBI_PARALLEL_DIO);
+ return test_bit(LL_SBI_PARALLEL_DIO, sbi->ll_flags);
}
void ll_ras_enter(struct file *f, loff_t pos, size_t count);
struct page *ll_get_dir_page(struct inode *dir, struct md_op_data *op_data,
__u64 offset);
void ll_release_page(struct inode *inode, struct page *page, bool remove);
-int quotactl_ioctl(struct ll_sb_info *sbi, struct if_quotactl *qctl);
+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/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 cl_io *lcc_io;
struct cl_page *lcc_page;
enum lcc_type lcc_type;
+ /**
+ * Get encryption context operation in progress,
+ * allow getxattr of LL_XATTR_NAME_ENCRYPTION_CONTEXT xattr
+ */
+ unsigned lcc_getencctx:1;
};
struct ll_thread_info {
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[LLCRYPT_FNAME_DIGEST_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);
+#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);