X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Fllite%2Fllite_internal.h;h=d9ec393b28b7712794bd1db0693ab4fb67e25958;hb=59a3d7237df82ac2ce14b6779577584163f9122b;hp=63aca4578f8d588bc4acbd36867261c0ac2f2070;hpb=c2791674260b120c596885c0356f33852cd7a685;p=fs%2Flustre-release.git diff --git a/lustre/llite/llite_internal.h b/lustre/llite/llite_internal.h index 63aca45..d9ec393 100644 --- a/lustre/llite/llite_internal.h +++ b/lustre/llite/llite_internal.h @@ -72,7 +72,8 @@ #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; @@ -103,6 +104,16 @@ struct ll_grouplock { unsigned long lg_gid; }; +/* See comment on trunc_sem_down_read_nowait */ +struct ll_trunc_sem { + /* when positive, this is a count of readers, when -1, it indicates + * the semaphore is held for write, and 0 is unlocked + */ + atomic_t ll_trunc_readers; + /* this tracks a count of waiting writers */ + atomic_t ll_trunc_waiters; +}; + struct ll_inode_info { __u32 lli_inode_magic; spinlock_t lli_lock; @@ -134,18 +145,11 @@ struct ll_inode_info { 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 @@ -178,14 +182,7 @@ struct ll_inode_info { struct { struct mutex lli_size_mutex; char *lli_symlink_name; - /* - * struct rw_semaphore { - * signed long count; // align d.d_def_acl - * spinlock_t wait_lock; // align d.d_sa_lock - * struct list_head wait_list; - * } - */ - struct rw_semaphore lli_trunc_sem; + struct ll_trunc_sem lli_trunc_sem; struct range_lock_tree lli_write_tree; struct rw_semaphore lli_glimpse_sem; @@ -213,7 +210,26 @@ struct ll_inode_info { struct mutex lli_pcc_lock; enum lu_pcc_state_flags lli_pcc_state; + /* + * @lli_pcc_generation saves the gobal PCC generation + * when the file was successfully attached into PCC. + * The flags of the PCC dataset are saved in + * @lli_pcc_dsflags. + * The gobal PCC generation will be increased when add + * or delete a PCC backend, or change the configuration + * parameters for PCC. + * If @lli_pcc_generation is same as the gobal PCC + * generation, we can use the saved flags of the PCC + * dataset to determine whether need to try auto attach + * safely. + */ + __u64 lli_pcc_generation; + enum pcc_dataset_flags lli_pcc_dsflags; struct pcc_inode *lli_pcc_inode; + + struct mutex lli_group_mutex; + __u64 lli_group_users; + unsigned long lli_group_gid; }; }; @@ -242,6 +258,87 @@ struct ll_inode_info { struct list_head lli_xattrs; /* ll_xattr_entry->xe_list */ }; +static inline void ll_trunc_sem_init(struct ll_trunc_sem *sem) +{ + atomic_set(&sem->ll_trunc_readers, 0); + atomic_set(&sem->ll_trunc_waiters, 0); +} + +/* This version of down read ignores waiting writers, meaning if the semaphore + * is already held for read, this down_read will 'join' that reader and also + * take the semaphore. + * + * This lets us avoid an unusual deadlock. + * + * 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 trunc_sem to exclude truncate. + * + * This means the locking order for trunc_sem and mmap_sem 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. + * + * However, if a write mode user (truncate, a setattr op) arrives in the + * middle of this, the second reader on the truncate_sem will wait behind that + * writer. + * + * 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) + * writer + * reader (holding truncate sem, waiting for mmap_sem) + * + * And so the readers deadlock. + * + * The solution is this modified semaphore, where this down_read ignores + * waiting write operations, and all waiters are woken up at once, so readers + * using down_read_nowait cannot get stuck behind waiting writers, regardless + * 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 + * (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. + * + * LU-12460 + */ +static inline void trunc_sem_down_read_nowait(struct ll_trunc_sem *sem) +{ + wait_var_event(&sem->ll_trunc_readers, + atomic_inc_unless_negative(&sem->ll_trunc_readers)); +} + +static inline void trunc_sem_down_read(struct ll_trunc_sem *sem) +{ + wait_var_event(&sem->ll_trunc_readers, + atomic_read(&sem->ll_trunc_waiters) == 0 && + atomic_inc_unless_negative(&sem->ll_trunc_readers)); +} + +static inline void trunc_sem_up_read(struct ll_trunc_sem *sem) +{ + if (atomic_dec_return(&sem->ll_trunc_readers) == 0 && + atomic_read(&sem->ll_trunc_waiters)) + wake_up_var(&sem->ll_trunc_readers); +} + +static inline void trunc_sem_down_write(struct ll_trunc_sem *sem) +{ + atomic_inc(&sem->ll_trunc_waiters); + wait_var_event(&sem->ll_trunc_readers, + atomic_cmpxchg(&sem->ll_trunc_readers, 0, -1) == 0); + atomic_dec(&sem->ll_trunc_waiters); +} + +static inline void trunc_sem_up_write(struct ll_trunc_sem *sem) +{ + atomic_set(&sem->ll_trunc_readers, 0); + wake_up_var(&sem->ll_trunc_readers); +} + static inline __u32 ll_layout_version_get(struct ll_inode_info *lli) { __u32 gen; @@ -269,6 +366,9 @@ enum ll_file_flags { LLIF_XATTR_CACHE = 2, /* Project inherit */ LLIF_PROJECT_INHERIT = 3, + /* update atime from MDS even if it's older than local inode atime. */ + LLIF_UPDATE_ATIME = 4, + }; static inline void ll_file_set_flag(struct ll_inode_info *lli, @@ -305,19 +405,19 @@ int ll_xattr_cache_get(struct inode *inode, 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, @@ -352,11 +452,11 @@ static inline struct pcc_inode *ll_i2pcci(struct inode *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 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, @@ -400,20 +500,20 @@ struct ll_ra_info { * counted by page index. */ struct ra_io_arg { - unsigned long ria_start; /* start offset of read-ahead*/ - unsigned long ria_end; /* end offset of read-ahead*/ - unsigned long ria_reserved; /* reserved pages for read-ahead */ - unsigned long 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*/ - pgoff_t ria_stoff; - /* ria_length and ria_pages are the length and pages length in the + 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_pages; + loff_t ria_length; + loff_t ria_bytes; }; /* LL_HIST_MAX=32 causes an overflow */ @@ -539,8 +639,7 @@ struct ll_sb_info { struct lu_fid ll_root_fid; /* root object fid */ int ll_flags; - unsigned int ll_umounting:1, - ll_xattr_cache_enabled: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; @@ -595,6 +694,9 @@ struct ll_sb_info { /* 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; @@ -615,17 +717,11 @@ struct ll_sb_info { * per file-descriptor read-ahead data. */ struct ll_readahead_state { - spinlock_t ras_lock; - /* - * index of the last page that read(2) needed and that wasn't in the - * cache. Used by ras_update() to detect seeks. - * - * XXX nikita: if access seeks into cached region, Lustre doesn't see - * this. - */ - unsigned long ras_last_readpage; + spinlock_t ras_lock; + /* End byte that read(2) try to read. */ + loff_t ras_last_read_end_bytes; /* - * number of pages read after last read-ahead window reset. As window + * number of bytes read after last read-ahead window reset. As window * is reset on each seek, this is effectively a number of consecutive * accesses. Maybe ->ras_accessed_in_window is better name. * @@ -634,13 +730,13 @@ struct ll_readahead_state { * case, it probably doesn't make sense to expand window to * PTLRPC_MAX_BRW_PAGES on the third access. */ - unsigned long ras_consecutive_pages; + 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, @@ -648,12 +744,13 @@ struct ll_readahead_state { * expanded to PTLRPC_MAX_BRW_PAGES. Afterwards, window is enlarged by * PTLRPC_MAX_BRW_PAGES chunks up to ->ra_max_pages. */ - unsigned long 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 @@ -661,50 +758,47 @@ struct ll_readahead_state { * ->ra_max_pages (see ll_ra_count_get()), 2. client cannot read pages * not covered by DLM lock. */ - unsigned long 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; - /* - * Page index with respect to the current request, these value - * will not be accurate when dealing with reads issued via mmap. - */ - unsigned long ras_request_index; + unsigned long ras_requests; /* * The following 3 items are used for detecting the stride I/O * mode. * In stride I/O mode, * ...............|-----data-----|****gap*****|--------|******|.... - * offset |-stride_pages-|-stride_gap-| + * offset |-stride_bytes-|-stride_gap-| * ras_stride_offset = offset; - * ras_stride_length = stride_pages + stride_gap; - * ras_stride_pages = stride_pages; - * Note: all these three items are counted by pages. - */ - unsigned long ras_stride_length; - unsigned long ras_stride_pages; - pgoff_t ras_stride_offset; + * ras_stride_length = stride_bytes + stride_gap; + * ras_stride_bytes = stride_bytes; + * Note: all these three items are counted by bytes. + */ + 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 */ - unsigned long ras_async_last_readpage; + pgoff_t ras_async_last_readpage_idx; + /* whether we should increase readahead window */ + bool ras_need_increase_window; + /* whether ra miss check should be skipped */ + 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; @@ -788,7 +882,7 @@ 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); +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, @@ -800,19 +894,17 @@ void cl_put_grouplock(struct ll_grouplock *lg); /* llite/lproc_llite.c */ 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); +void ll_stats_ops_tally(struct ll_sb_info *sbi, int op, long count); 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_READ, + LPROC_LL_WRITE, LPROC_LL_IOCTL, LPROC_LL_OPEN, LPROC_LL_RELEASE, - LPROC_LL_MAP, + LPROC_LL_MMAP, LPROC_LL_FAULT, LPROC_LL_MKWRITE, LPROC_LL_LLSEEK, @@ -830,8 +922,7 @@ enum { LPROC_LL_RMDIR, LPROC_LL_MKNOD, LPROC_LL_RENAME, - LPROC_LL_STAFS, - LPROC_LL_ALLOC_INODE, + LPROC_LL_STATFS, LPROC_LL_SETXATTR, LPROC_LL_GETXATTR, LPROC_LL_GETXATTR_HITS, @@ -842,6 +933,10 @@ enum { }; /* llite/dir.c */ +enum get_default_layout_type { + GET_DEFAULT_LAYOUT_ROOT = 1, +}; + struct ll_dir_chain { }; @@ -915,7 +1010,6 @@ int ll_md_real_close(struct inode *inode, fmode_t fmode); 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); -void ll_io_init(struct cl_io *io, struct file *file, enum cl_io_type iot); #ifdef HAVE_INODEOPS_ENHANCED_GETATTR int ll_getattr(const struct path *path, struct kstat *stat, u32 request_mask, unsigned int flags); @@ -925,26 +1019,18 @@ int ll_getattr(struct vfsmount *mnt, struct dentry *de, struct kstat *stat); int ll_getattr_dentry(struct dentry *de, struct kstat *stat); struct posix_acl *ll_get_acl(struct inode *inode, int type); #ifdef HAVE_IOP_SET_ACL -#ifdef CONFIG_FS_POSIX_ACL +#ifdef CONFIG_LUSTRE_FS_POSIX_ACL int ll_set_acl(struct inode *inode, struct posix_acl *acl, int type); -#else /* !CONFIG_FS_POSIX_ACL */ +#else /* !CONFIG_LUSTRE_FS_POSIX_ACL */ #define ll_set_acl NULL -#endif /* CONFIG_FS_POSIX_ACL */ +#endif /* CONFIG_LUSTRE_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_ioctl_check_project(struct inode *inode, struct fsxattr *fa); int ll_ioctl_fsgetxattr(struct inode *inode, unsigned int cmd, unsigned long arg); @@ -959,16 +1045,12 @@ int ll_lov_getstripe_ea_info(struct inode *inode, const char *filename, struct ptlrpc_request **request); int ll_dir_setstripe(struct inode *inode, struct lov_user_md *lump, int set_default); -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_dir_getstripe_default(struct inode *inode, void **lmmp, + int *lmm_size, struct ptlrpc_request **request, + struct ptlrpc_request **root_request, u64 valid); +int ll_dir_getstripe(struct inode *inode, void **plmm, int *plmm_size, + struct ptlrpc_request **request, u64 valid); 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); @@ -991,7 +1073,7 @@ int ll_revalidate_it_finish(struct ptlrpc_request *request, extern struct super_operations lustre_super_operations; void ll_lli_init(struct ll_inode_info *lli); -int ll_fill_super(struct super_block *sb, struct vfsmount *mnt); +int ll_fill_super(struct super_block *sb); void ll_put_super(struct super_block *sb); void ll_kill_super(struct super_block *sb); struct inode *ll_inode_from_resource_lock(struct ldlm_lock *lock); @@ -1012,11 +1094,7 @@ int ll_iocontrol(struct inode *inode, struct file *file, 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 *); @@ -1108,7 +1186,6 @@ struct ll_cl_context { }; struct ll_thread_info { - struct iov_iter lti_iter; struct vvp_io_args lti_args; struct ra_io_arg lti_ria; struct ll_cl_context lti_io_ctx; @@ -1136,6 +1213,9 @@ static inline struct vvp_io_args *ll_env_args(const struct lu_env *env, 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); @@ -1145,23 +1225,6 @@ void policy_from_vma(union ldlm_policy_data *policy, struct vm_area_struct *vma, 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_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_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 */ @@ -1304,8 +1367,8 @@ struct ll_statahead_info { 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 */ @@ -1406,12 +1469,12 @@ int cl_sync_file_range(struct inode *inode, loff_t start, loff_t end, 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, @@ -1450,24 +1513,6 @@ static inline void ll_set_lock_data(struct obd_export *exp, struct inode *inode, *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); @@ -1557,4 +1602,14 @@ void cl_inode_fini(struct inode *inode); u64 cl_fid_build_ino(const struct lu_fid *fid, int api32); u32 cl_fid_build_gen(const struct lu_fid *fid); +static inline struct pcc_super *ll_i2pccs(struct inode *inode) +{ + return &ll_i2sbi(inode)->ll_pcc_super; +} + +static inline struct pcc_super *ll_info2pccs(struct ll_inode_info *lli) +{ + return ll_i2pccs(ll_info2i(lli)); +} + #endif /* LLITE_INTERNAL_H */