lustre/llite/llite_internal.h

   1 /*
   2  * GPL HEADER START
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 only,
   8  * as published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License version 2 for more details (a copy is included
  14  * in the LICENSE file that accompanied this code).
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * version 2 along with this program; If not, see
  18  * http://www.gnu.org/licenses/gpl-2.0.html
  19  *
  20  * GPL HEADER END
  21  */
  22 /*
  23  * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
  24  * Use is subject to license terms.
  25  *
  26  * Copyright (c) 2011, 2017, Intel Corporation.
  27  */
  28 /*
  29  * This file is part of Lustre, http://www.lustre.org/
  30  */
  31
  32 #ifndef LLITE_INTERNAL_H
  33 #define LLITE_INTERNAL_H
  34 #include <obd.h>
  35 #include <lustre_disk.h>  /* for s2sbi */
  36 #include <lustre_linkea.h>
  37
  38 /* for struct cl_lock_descr and struct cl_io */
  39 #include <cl_object.h>
  40 #include <lustre_lmv.h>
  41 #include <lustre_mdc.h>
  42 #include <lustre_intent.h>
  43 #include <linux/compat.h>
  44 #include <linux/aio.h>
  45 #include <linux/parser.h>
  46 #include <linux/seqlock.h>
  47 #include <lustre_compat.h>
  48 #include <lustre_crypto.h>
  49 #include <range_lock.h>
  50
  51 #include "vvp_internal.h"
  52 #include "pcc.h"
  53 #include "foreign_symlink.h"
  54
  55 #ifndef FMODE_EXEC
  56 #define FMODE_EXEC 0
  57 #endif
  58
  59 #ifndef HAVE_VM_FAULT_RETRY
  60 #define VM_FAULT_RETRY 0
  61 #endif
  62
  63 /* Kernel 3.1 kills LOOKUP_CONTINUE, LOOKUP_PARENT is equivalent to it.
  64  * seem kernel commit 49084c3bb2055c401f3493c13edae14d49128ca0 */
  65 #ifndef LOOKUP_CONTINUE
  66 #define LOOKUP_CONTINUE LOOKUP_PARENT
  67 #endif
  68
  69 #ifdef HAVE_DENTRY_D_U_D_ALIAS
  70 #define d_alias                 d_u.d_alias
  71 #endif
  72
  73 /** Only used on client-side for indicating the tail of dir hash/offset. */
  74 #define LL_DIR_END_OFF          0x7fffffffffffffffULL
  75 #define LL_DIR_END_OFF_32BIT    0x7fffffffUL
  76
  77 /* 4UL * 1024 * 1024 */
  78 #define LL_MAX_BLKSIZE_BITS 22
  79
  80 #define LL_IT2STR(it) ((it) ? ldlm_it2str((it)->it_op) : "0")
  81
  82 #define TIMES_SET_FLAGS (ATTR_MTIME_SET | ATTR_ATIME_SET | ATTR_TIMES_SET)
  83
  84 struct ll_dentry_data {
  85         unsigned int                    lld_sa_generation;
  86         unsigned int                    lld_invalid:1;
  87         unsigned int                    lld_nfs_dentry:1;
  88         struct rcu_head                 lld_rcu_head;
  89 };
  90
  91 #define ll_d2d(de) ((struct ll_dentry_data*)((de)->d_fsdata))
  92
  93 #define LLI_INODE_MAGIC                 0x111d0de5
  94 #define LLI_INODE_DEAD                  0xdeadd00d
  95
  96 struct ll_getname_data {
  97 #ifdef HAVE_DIR_CONTEXT
  98         struct dir_context      ctx;
  99 #endif
 100         char            *lgd_name;      /* points to a buffer with NAME_MAX+1 size */
 101         struct lu_fid   lgd_fid;        /* target fid we are looking for */
 102         int             lgd_found;      /* inode matched? */
 103 };
 104
 105 struct ll_grouplock {
 106         struct lu_env   *lg_env;
 107         struct cl_io    *lg_io;
 108         struct cl_lock  *lg_lock;
 109         unsigned long    lg_gid;
 110 };
 111
 112 /* See comment on trunc_sem_down_read_nowait */
 113 struct ll_trunc_sem {
 114         /* when positive, this is a count of readers, when -1, it indicates
 115          * the semaphore is held for write, and 0 is unlocked
 116          */
 117         atomic_t        ll_trunc_readers;
 118         /* this tracks a count of waiting writers */
 119         atomic_t        ll_trunc_waiters;
 120 };
 121
 122 struct ll_inode_info {
 123         __u32                           lli_inode_magic;
 124         rwlock_t                        lli_lock;
 125
 126         volatile unsigned long          lli_flags;
 127         struct posix_acl                *lli_posix_acl;
 128
 129         /* identifying fields for both metadata and data stacks. */
 130         struct lu_fid                   lli_fid;
 131         /* master inode fid for stripe directory */
 132         struct lu_fid                   lli_pfid;
 133
 134         /* We need all three because every inode may be opened in different
 135          * modes */
 136         struct obd_client_handle       *lli_mds_read_och;
 137         struct obd_client_handle       *lli_mds_write_och;
 138         struct obd_client_handle       *lli_mds_exec_och;
 139         __u64                           lli_open_fd_read_count;
 140         __u64                           lli_open_fd_write_count;
 141         __u64                           lli_open_fd_exec_count;
 142
 143         /* Number of times this inode was opened */
 144         u64                             lli_open_fd_count;
 145         /* When last close was performed on this inode */
 146         ktime_t                         lli_close_fd_time;
 147
 148         /* Protects access to och pointers and their usage counters */
 149         struct mutex                    lli_och_mutex;
 150
 151         struct inode                    lli_vfs_inode;
 152
 153         /* the most recent timestamps obtained from mds */
 154         s64                             lli_atime;
 155         s64                             lli_mtime;
 156         s64                             lli_ctime;
 157         s64                             lli_btime;
 158         spinlock_t                      lli_agl_lock;
 159
 160         /* Try to make the d::member and f::member are aligned. Before using
 161          * these members, make clear whether it is directory or not. */
 162         union {
 163                 /* for directory */
 164                 struct {
 165                         /* metadata statahead */
 166                         /* since parent-child threads can share the same @file
 167                          * struct, "opendir_key" is the token when dir close for
 168                          * case of parent exit before child -- it is me should
 169                          * cleanup the dir readahead. */
 170                         void                           *lli_opendir_key;
 171                         struct ll_statahead_info       *lli_sai;
 172                         /* protect statahead stuff. */
 173                         spinlock_t                      lli_sa_lock;
 174                         /* "opendir_pid" is the token when lookup/revalid
 175                          * -- I am the owner of dir statahead. */
 176                         pid_t                           lli_opendir_pid;
 177                         /* directory depth to ROOT */
 178                         unsigned short                  lli_dir_depth;
 179                         /* directory depth to ancestor whose default LMV is
 180                          * inherited.
 181                          */
 182                         unsigned short                  lli_inherit_depth;
 183                         /* stat will try to access statahead entries or start
 184                          * statahead if this flag is set, and this flag will be
 185                          * set upon dir open, and cleared when dir is closed,
 186                          * statahead hit ratio is too low, or start statahead
 187                          * thread failed. */
 188                         unsigned short                  lli_sa_enabled:1;
 189                         /* generation for statahead */
 190                         unsigned int                    lli_sa_generation;
 191                         /* rw lock protects lli_lsm_md */
 192                         struct rw_semaphore             lli_lsm_sem;
 193                         /* directory stripe information */
 194                         struct lmv_stripe_md            *lli_lsm_md;
 195                         /* directory default LMV */
 196                         struct lmv_stripe_md            *lli_default_lsm_md;
 197                 };
 198
 199                 /* for non-directory */
 200                 struct {
 201                         struct mutex            lli_size_mutex;
 202                         char                   *lli_symlink_name;
 203                         struct ll_trunc_sem     lli_trunc_sem;
 204                         struct range_lock_tree  lli_write_tree;
 205                         struct mutex            lli_setattr_mutex;
 206
 207                         struct rw_semaphore     lli_glimpse_sem;
 208                         ktime_t                 lli_glimpse_time;
 209                         struct list_head        lli_agl_list;
 210                         __u64                   lli_agl_index;
 211
 212                         /* for writepage() only to communicate to fsync */
 213                         int                     lli_async_rc;
 214
 215                         /* protect the file heat fields */
 216                         spinlock_t                      lli_heat_lock;
 217                         __u32                           lli_heat_flags;
 218                         struct obd_heat_instance        lli_heat_instances[OBD_HEAT_COUNT];
 219
 220                         /*
 221                          * Whenever a process try to read/write the file, the
 222                          * jobid of the process will be saved here, and it'll
 223                          * be packed into the write PRC when flush later.
 224                          *
 225                          * So the read/write statistics for jobid will not be
 226                          * accurate if the file is shared by different jobs.
 227                          */
 228                         char                    lli_jobid[LUSTRE_JOBID_SIZE];
 229
 230                         struct mutex             lli_pcc_lock;
 231                         enum lu_pcc_state_flags  lli_pcc_state;
 232                         /*
 233                          * @lli_pcc_generation saves the gobal PCC generation
 234                          * when the file was successfully attached into PCC.
 235                          * The flags of the PCC dataset are saved in
 236                          * @lli_pcc_dsflags.
 237                          * The gobal PCC generation will be increased when add
 238                          * or delete a PCC backend, or change the configuration
 239                          * parameters for PCC.
 240                          * If @lli_pcc_generation is same as the gobal PCC
 241                          * generation, we can use the saved flags of the PCC
 242                          * dataset to determine whether need to try auto attach
 243                          * safely.
 244                          */
 245                         __u64                    lli_pcc_generation;
 246                         enum pcc_dataset_flags   lli_pcc_dsflags;
 247                         struct pcc_inode        *lli_pcc_inode;
 248
 249                         struct mutex             lli_group_mutex;
 250                         __u64                    lli_group_users;
 251                         unsigned long            lli_group_gid;
 252
 253                         __u64                    lli_attr_valid;
 254                         __u64                    lli_lazysize;
 255                         __u64                    lli_lazyblocks;
 256                 };
 257         };
 258
 259         /* XXX: For following frequent used members, although they maybe special
 260          *      used for non-directory object, it is some time-wasting to check
 261          *      whether the object is directory or not before using them. On the
 262          *      other hand, currently, sizeof(f) > sizeof(d), it cannot reduce
 263          *      the "ll_inode_info" size even if moving those members into u.f.
 264          *      So keep them out side.
 265          *
 266          *      In the future, if more members are added only for directory,
 267          *      some of the following members can be moved into u.f.
 268          */
 269         struct cl_object                *lli_clob;
 270
 271         /* mutex to request for layout lock exclusively. */
 272         struct mutex                    lli_layout_mutex;
 273         /* Layout version, protected by lli_layout_lock */
 274         __u32                           lli_layout_gen;
 275         spinlock_t                      lli_layout_lock;
 276
 277         __u32                           lli_projid;   /* project id */
 278
 279         struct rw_semaphore             lli_xattrs_list_rwsem;
 280         struct mutex                    lli_xattrs_enq_lock;
 281         struct list_head                lli_xattrs; /* ll_xattr_entry->xe_list */
 282         struct list_head                lli_lccs; /* list of ll_cl_context */
 283         seqlock_t                       lli_page_inv_lock;
 284 };
 285
 286 #ifndef HAVE_USER_NAMESPACE_ARG
 287 #define inode_permission(ns, inode, mask)       inode_permission(inode, mask)
 288 #define generic_permission(ns, inode, mask)     generic_permission(inode, mask)
 289 #define simple_setattr(ns, de, iattr)           simple_setattr(de, iattr)
 290 #define ll_inode_permission(ns, inode, mask)    ll_inode_permission(inode, mask)
 291 #ifdef HAVE_INODEOPS_ENHANCED_GETATTR
 292 #define ll_getattr(ns, path, stat, mask, fl)    ll_getattr(path, stat, mask, fl)
 293 #endif /* HAVE_INODEOPS_ENHANCED_GETATTR */
 294 #define ll_setattr(ns, de, attr)                ll_setattr(de, attr)
 295 #endif
 296
 297 static inline void ll_trunc_sem_init(struct ll_trunc_sem *sem)
 298 {
 299         atomic_set(&sem->ll_trunc_readers, 0);
 300         atomic_set(&sem->ll_trunc_waiters, 0);
 301 }
 302
 303 /* This version of down read ignores waiting writers, meaning if the semaphore
 304  * is already held for read, this down_read will 'join' that reader and also
 305  * take the semaphore.
 306  *
 307  * This lets us avoid an unusual deadlock.
 308  *
 309  * We must take lli_trunc_sem in read mode on entry in to various i/o paths
 310  * in Lustre, in order to exclude truncates.  Some of these paths then need to
 311  * take the mmap_lock, while still holding the trunc_sem.  The problem is that
 312  * page faults hold the mmap_lock when calling in to Lustre, and then must also
 313  * take the trunc_sem to exclude truncate.
 314  *
 315  * This means the locking order for trunc_sem and mmap_lock is sometimes AB,
 316  * sometimes BA.  This is almost OK because in both cases, we take the trunc
 317  * sem for read, so it doesn't block.
 318  *
 319  * However, if a write mode user (truncate, a setattr op) arrives in the
 320  * middle of this, the second reader on the truncate_sem will wait behind that
 321  * writer.
 322  *
 323  * So we have, on our truncate sem, in order (where 'reader' and 'writer' refer
 324  * to the mode in which they take the semaphore):
 325  * reader (holding mmap_lock, needs truncate_sem)
 326  * writer
 327  * reader (holding truncate sem, waiting for mmap_lock)
 328  *
 329  * And so the readers deadlock.
 330  *
 331  * The solution is this modified semaphore, where this down_read ignores
 332  * waiting write operations, and all waiters are woken up at once, so readers
 333  * using down_read_nowait cannot get stuck behind waiting writers, regardless
 334  * of the order they arrived in.
 335  *
 336  * down_read_nowait is only used in the page fault case, where we already hold
 337  * the mmap_lock.  This is because otherwise repeated read and write operations
 338  * (which take the truncate sem) could prevent a truncate from ever starting.
 339  * This could still happen with page faults, but without an even more complex
 340  * mechanism, this is unavoidable.
 341  *
 342  * LU-12460
 343  */
 344 static inline void trunc_sem_down_read_nowait(struct ll_trunc_sem *sem)
 345 {
 346         wait_var_event(&sem->ll_trunc_readers,
 347                        atomic_inc_unless_negative(&sem->ll_trunc_readers));
 348 }
 349
 350 static inline void trunc_sem_down_read(struct ll_trunc_sem *sem)
 351 {
 352         wait_var_event(&sem->ll_trunc_readers,
 353                        atomic_read(&sem->ll_trunc_waiters) == 0 &&
 354                        atomic_inc_unless_negative(&sem->ll_trunc_readers));
 355 }
 356
 357 static inline void trunc_sem_up_read(struct ll_trunc_sem *sem)
 358 {
 359         if (atomic_dec_return(&sem->ll_trunc_readers) == 0 &&
 360             atomic_read(&sem->ll_trunc_waiters))
 361                 wake_up_var(&sem->ll_trunc_readers);
 362 }
 363
 364 static inline void trunc_sem_down_write(struct ll_trunc_sem *sem)
 365 {
 366         atomic_inc(&sem->ll_trunc_waiters);
 367         wait_var_event(&sem->ll_trunc_readers,
 368                        atomic_cmpxchg(&sem->ll_trunc_readers, 0, -1) == 0);
 369         atomic_dec(&sem->ll_trunc_waiters);
 370 }
 371
 372 static inline void trunc_sem_up_write(struct ll_trunc_sem *sem)
 373 {
 374         atomic_set(&sem->ll_trunc_readers, 0);
 375         /* match the smp_mb() in wait_var_event()->prepare_to_wait() */
 376         smp_mb();
 377         wake_up_var(&sem->ll_trunc_readers);
 378 }
 379
 380 #ifdef CONFIG_LUSTRE_FS_POSIX_ACL
 381 static inline void lli_clear_acl(struct ll_inode_info *lli)
 382 {
 383         if (lli->lli_posix_acl) {
 384                 posix_acl_release(lli->lli_posix_acl);
 385                 lli->lli_posix_acl = NULL;
 386         }
 387 }
 388
 389 static inline void lli_replace_acl(struct ll_inode_info *lli,
 390                                    struct lustre_md *md)
 391 {
 392         write_lock(&lli->lli_lock);
 393         if (lli->lli_posix_acl)
 394                 posix_acl_release(lli->lli_posix_acl);
 395         lli->lli_posix_acl = md->posix_acl;
 396         write_unlock(&lli->lli_lock);
 397 }
 398 #else
 399 static inline void lli_clear_acl(struct ll_inode_info *lli)
 400 {
 401 }
 402
 403 static inline void lli_replace_acl(struct ll_inode_info *lli,
 404                                    struct lustre_md *md)
 405 {
 406 }
 407 #endif
 408
 409 static inline __u32 ll_layout_version_get(struct ll_inode_info *lli)
 410 {
 411         __u32 gen;
 412
 413         spin_lock(&lli->lli_layout_lock);
 414         gen = lli->lli_layout_gen;
 415         spin_unlock(&lli->lli_layout_lock);
 416
 417         return gen;
 418 }
 419
 420 static inline void ll_layout_version_set(struct ll_inode_info *lli, __u32 gen)
 421 {
 422         spin_lock(&lli->lli_layout_lock);
 423         lli->lli_layout_gen = gen;
 424         spin_unlock(&lli->lli_layout_lock);
 425 }
 426
 427 enum ll_file_flags {
 428         /* File data is modified. */
 429         LLIF_DATA_MODIFIED      = 0,
 430         /* File is being restored */
 431         LLIF_FILE_RESTORING     = 1,
 432         /* Xattr cache is attached to the file */
 433         LLIF_XATTR_CACHE        = 2,
 434         /* Project inherit */
 435         LLIF_PROJECT_INHERIT    = 3,
 436         /* update atime from MDS even if it's older than local inode atime. */
 437         LLIF_UPDATE_ATIME       = 4,
 438         /* foreign file/dir can be unlinked unconditionnaly */
 439         LLIF_FOREIGN_REMOVABLE  = 5,
 440         /* Xattr cache is filled */
 441         LLIF_XATTR_CACHE_FILLED = 7,
 442
 443 };
 444
 445 int ll_xattr_cache_destroy(struct inode *inode);
 446 int ll_xattr_cache_empty(struct inode *inode);
 447
 448 int ll_xattr_cache_get(struct inode *inode,
 449                        const char *name,
 450                        char *buffer,
 451                        size_t size,
 452                        __u64 valid);
 453
 454 int ll_xattr_cache_insert(struct inode *inode,
 455                           const char *name,
 456                           char *buffer,
 457                           size_t size);
 458
 459 static inline bool obd_connect_has_secctx(struct obd_connect_data *data)
 460 {
 461 #ifdef CONFIG_SECURITY
 462         return data->ocd_connect_flags & OBD_CONNECT_FLAGS2 &&
 463                 data->ocd_connect_flags2 & OBD_CONNECT2_FILE_SECCTX;
 464 #else
 465         return false;
 466 #endif
 467 }
 468
 469 static inline void obd_connect_set_secctx(struct obd_connect_data *data)
 470 {
 471 #ifdef CONFIG_SECURITY
 472         data->ocd_connect_flags2 |= OBD_CONNECT2_FILE_SECCTX;
 473 #endif
 474 }
 475
 476 /* Only smack and selinux is known to use security contexts */
 477 static inline bool ll_xattr_is_seclabel(const char *name)
 478 {
 479         return !strcmp(name, XATTR_NAME_SELINUX) ||
 480                 !strcmp(name, XATTR_NAME_SMACK);
 481 }
 482
 483 static inline bool ll_xattr_suffix_is_seclabel(const char *suffix)
 484 {
 485         return !strcmp(suffix, XATTR_SELINUX_SUFFIX) ||
 486                 !strcmp(suffix, XATTR_SMACK_SUFFIX);
 487 }
 488
 489 int ll_dentry_init_security(struct dentry *dentry, int mode, struct qstr *name,
 490                             const char **secctx_name, __u32 *secctx_name_size,
 491                             void **secctx, __u32 *secctx_size);
 492 int ll_inode_init_security(struct dentry *dentry, struct inode *inode,
 493                            struct inode *dir);
 494
 495 int ll_inode_notifysecctx(struct inode *inode,
 496                           void *secctx, __u32 secctxlen);
 497
 498 void ll_secctx_name_free(struct ll_sb_info *sbi);
 499
 500 int ll_secctx_name_store(struct inode *in);
 501
 502 __u32 ll_secctx_name_get(struct ll_sb_info *sbi, const char **secctx_name);
 503
 504 int ll_security_secctx_name_filter(struct ll_sb_info *sbi, int xattr_type,
 505                                    const char *suffix);
 506
 507 static inline bool obd_connect_has_enc(struct obd_connect_data *data)
 508 {
 509 #ifdef HAVE_LUSTRE_CRYPTO
 510         return data->ocd_connect_flags & OBD_CONNECT_FLAGS2 &&
 511                 data->ocd_connect_flags2 & OBD_CONNECT2_ENCRYPT;
 512 #else
 513         return false;
 514 #endif
 515 }
 516
 517 static inline void obd_connect_set_enc(struct obd_connect_data *data)
 518 {
 519 #ifdef HAVE_LUSTRE_CRYPTO
 520         data->ocd_connect_flags2 |= OBD_CONNECT2_ENCRYPT;
 521 #endif
 522 }
 523
 524 static inline bool obd_connect_has_name_enc(struct obd_connect_data *data)
 525 {
 526 #ifdef HAVE_LUSTRE_CRYPTO
 527         return data->ocd_connect_flags & OBD_CONNECT_FLAGS2 &&
 528                 data->ocd_connect_flags2 & OBD_CONNECT2_ENCRYPT_NAME;
 529 #else
 530         return false;
 531 #endif
 532 }
 533
 534 static inline void obd_connect_set_name_enc(struct obd_connect_data *data)
 535 {
 536 #ifdef HAVE_LUSTRE_CRYPTO
 537         data->ocd_connect_flags2 |= OBD_CONNECT2_ENCRYPT_NAME;
 538 #endif
 539 }
 540
 541 /*
 542  * Locking to guarantee consistency of non-atomic updates to long long i_size,
 543  * consistency between file size and KMS.
 544  *
 545  * Implemented by ->lli_size_mutex and ->lsm_lock, nested in that order.
 546  */
 547
 548 void ll_inode_size_lock(struct inode *inode);
 549 void ll_inode_size_unlock(struct inode *inode);
 550
 551 static inline struct ll_inode_info *ll_i2info(struct inode *inode)
 552 {
 553         return container_of(inode, struct ll_inode_info, lli_vfs_inode);
 554 }
 555
 556 static inline struct pcc_inode *ll_i2pcci(struct inode *inode)
 557 {
 558         return ll_i2info(inode)->lli_pcc_inode;
 559 }
 560
 561 /* default to use at least 16M for fast read if possible */
 562 #define RA_REMAIN_WINDOW_MIN                    MiB_TO_PAGES(16UL)
 563
 564 /* default read-ahead on a given client mountpoint. */
 565 #define SBI_DEFAULT_READ_AHEAD_MAX              MiB_TO_PAGES(1024UL)
 566
 567 /* default read-ahead for a single file descriptor */
 568 #define SBI_DEFAULT_READ_AHEAD_PER_FILE_MAX     MiB_TO_PAGES(256UL)
 569
 570 /* default read-ahead full files smaller than limit on the second read */
 571 #define SBI_DEFAULT_READ_AHEAD_WHOLE_MAX        MiB_TO_PAGES(2UL)
 572
 573 /* default range pages */
 574 #define SBI_DEFAULT_RA_RANGE_PAGES              MiB_TO_PAGES(1ULL)
 575
 576 /* Min range pages */
 577 #define RA_MIN_MMAP_RANGE_PAGES                 16UL
 578
 579 enum ra_stat {
 580         RA_STAT_HIT = 0,
 581         RA_STAT_MISS,
 582         RA_STAT_DISTANT_READPAGE,
 583         RA_STAT_MISS_IN_WINDOW,
 584         RA_STAT_FAILED_GRAB_PAGE,
 585         RA_STAT_FAILED_MATCH,
 586         RA_STAT_DISCARDED,
 587         RA_STAT_ZERO_LEN,
 588         RA_STAT_ZERO_WINDOW,
 589         RA_STAT_EOF,
 590         RA_STAT_MAX_IN_FLIGHT,
 591         RA_STAT_WRONG_GRAB_PAGE,
 592         RA_STAT_FAILED_REACH_END,
 593         RA_STAT_ASYNC,
 594         RA_STAT_FAILED_FAST_READ,
 595         RA_STAT_MMAP_RANGE_READ,
 596         RA_STAT_READAHEAD_PAGES,
 597         _NR_RA_STAT,
 598 };
 599
 600 struct ll_ra_info {
 601         atomic_t        ra_cur_pages;
 602         unsigned long   ra_max_pages;
 603         unsigned long   ra_max_pages_per_file;
 604         unsigned long   ra_range_pages;
 605         unsigned long   ra_max_read_ahead_whole_pages;
 606         struct workqueue_struct  *ll_readahead_wq;
 607         /*
 608          * Max number of active works could be triggered
 609          * for async readahead.
 610          */
 611         unsigned int ra_async_max_active;
 612         /* how many async readahead triggered in flight */
 613         atomic_t ra_async_inflight;
 614         /* Threshold to control when to trigger async readahead */
 615         unsigned long ra_async_pages_per_file_threshold;
 616 };
 617
 618 /* ra_io_arg will be filled in the beginning of ll_readahead with
 619  * ras_lock, then the following ll_read_ahead_pages will read RA
 620  * pages according to this arg, all the items in this structure are
 621  * counted by page index.
 622  */
 623 struct ra_io_arg {
 624         pgoff_t         ria_start_idx;  /* start offset of read-ahead*/
 625         pgoff_t         ria_end_idx;    /* end offset of read-ahead*/
 626         unsigned long   ria_reserved;   /* reserved pages for read-ahead */
 627         pgoff_t         ria_end_idx_min;/* minimum end to cover current read */
 628         bool            ria_eof;        /* reach end of file */
 629         /* If stride read pattern is detected, ria_stoff is the byte offset
 630          * where stride read is started. Note: for normal read-ahead, the
 631          * value here is meaningless, and also it will not be accessed*/
 632         loff_t          ria_stoff;
 633         /* ria_length and ria_bytes are the length and pages length in the
 634          * stride I/O mode. And they will also be used to check whether
 635          * it is stride I/O read-ahead in the read-ahead pages*/
 636         loff_t          ria_length;
 637         loff_t          ria_bytes;
 638 };
 639
 640 /* LL_HIST_MAX=32 causes an overflow */
 641 #define LL_HIST_MAX 28
 642 #define LL_HIST_START 12 /* buckets start at 2^12 = 4k */
 643 #define LL_PROCESS_HIST_MAX 10
 644 struct per_process_info {
 645         pid_t pid;
 646         struct obd_histogram pp_r_hist;
 647         struct obd_histogram pp_w_hist;
 648 };
 649
 650 /* pp_extents[LL_PROCESS_HIST_MAX] will hold the combined process info */
 651 struct ll_rw_extents_info {
 652         ktime_t pp_init;
 653         struct per_process_info pp_extents[LL_PROCESS_HIST_MAX + 1];
 654 };
 655
 656 #define LL_OFFSET_HIST_MAX 100
 657 struct ll_rw_process_info {
 658         pid_t                     rw_pid;
 659         int                       rw_op;
 660         loff_t                    rw_range_start;
 661         loff_t                    rw_range_end;
 662         loff_t                    rw_last_file_pos;
 663         loff_t                    rw_offset;
 664         size_t                    rw_smallest_extent;
 665         size_t                    rw_largest_extent;
 666         struct ll_file_data      *rw_last_file;
 667 };
 668
 669 enum stats_track_type {
 670         STATS_TRACK_ALL = 0,  /* track all processes */
 671         STATS_TRACK_PID,      /* track process with this pid */
 672         STATS_TRACK_PPID,     /* track processes with this ppid */
 673         STATS_TRACK_GID,      /* track processes with this gid */
 674         STATS_TRACK_LAST,
 675 };
 676
 677 /* flags for sbi->ll_flags */
 678 enum ll_sbi_flags {
 679         LL_SBI_NOLCK,                   /* DLM locking disabled directio-only */
 680         LL_SBI_CHECKSUM,                /* checksum each page as it's written */
 681         LL_SBI_LOCALFLOCK,              /* local flocks instead of fs-wide */
 682         LL_SBI_FLOCK,                   /* flock enabled */
 683         LL_SBI_USER_XATTR,              /* support user xattr */
 684         LL_SBI_LRU_RESIZE,              /* lru resize support */
 685         LL_SBI_LAZYSTATFS,              /* lazystatfs mount option */
 686         LL_SBI_32BIT_API,               /* generate 32 bit inodes. */
 687         LL_SBI_USER_FID2PATH,           /* fid2path by unprivileged users */
 688         LL_SBI_VERBOSE,                 /* verbose mount/umount */
 689         LL_SBI_ALWAYS_PING,             /* ping even if server suppress_pings */
 690         LL_SBI_TEST_DUMMY_ENCRYPTION,   /* test dummy encryption */
 691         LL_SBI_ENCRYPT,                 /* client side encryption */
 692         LL_SBI_FOREIGN_SYMLINK,         /* foreign fake-symlink support */
 693         LL_SBI_FOREIGN_SYMLINK_UPCALL,  /* foreign fake-symlink upcall set */
 694         LL_SBI_NUM_MOUNT_OPT,
 695
 696         LL_SBI_ACL,                     /* support ACL */
 697         LL_SBI_AGL_ENABLED,             /* enable agl */
 698         LL_SBI_64BIT_HASH,              /* support 64-bits dir hash/offset */
 699         LL_SBI_LAYOUT_LOCK,             /* layout lock support */
 700         LL_SBI_XATTR_CACHE,             /* support for xattr cache */
 701         LL_SBI_NOROOTSQUASH,            /* do not apply root squash */
 702         LL_SBI_FAST_READ,               /* fast read support */
 703         LL_SBI_FILE_SECCTX,             /* file security context at create */
 704         LL_SBI_TINY_WRITE,              /* tiny write support */
 705         LL_SBI_FILE_HEAT,               /* file heat support */
 706         LL_SBI_PARALLEL_DIO,            /* parallel (async) O_DIRECT RPCs */
 707         LL_SBI_ENCRYPT_NAME,            /* name encryption */
 708         LL_SBI_NUM_FLAGS
 709 };
 710
 711 int ll_sbi_flags_seq_show(struct seq_file *m, void *v);
 712
 713 /* This is embedded into llite super-blocks to keep track of connect
 714  * flags (capabilities) supported by all imports given mount is
 715  * connected to. */
 716 struct lustre_client_ocd {
 717         /* This is conjunction of connect_flags across all imports
 718          * (LOVs) this mount is connected to. This field is updated by
 719          * cl_ocd_update() under ->lco_lock. */
 720         __u64                    lco_flags;
 721         struct mutex             lco_lock;
 722         struct obd_export       *lco_md_exp;
 723         struct obd_export       *lco_dt_exp;
 724 };
 725
 726 struct ll_sb_info {
 727         /* this protects pglist and ra_info.  It isn't safe to
 728          * grab from interrupt contexts */
 729         spinlock_t               ll_lock;
 730         spinlock_t               ll_pp_extent_lock; /* pp_extent entry*/
 731         spinlock_t               ll_process_lock; /* ll_rw_process_info */
 732         struct obd_uuid          ll_sb_uuid;
 733         struct obd_export       *ll_md_exp;
 734         struct obd_export       *ll_dt_exp;
 735         struct obd_device       *ll_md_obd;
 736         struct obd_device       *ll_dt_obd;
 737         struct dentry           *ll_debugfs_entry;
 738         struct lu_fid            ll_root_fid; /* root object fid */
 739         struct mnt_namespace    *ll_mnt_ns;
 740
 741         DECLARE_BITMAP(ll_flags, LL_SBI_NUM_FLAGS); /* enum ll_sbi_flags */
 742         unsigned int             ll_xattr_cache_enabled:1,
 743                                  ll_xattr_cache_set:1, /* already set to 0/1 */
 744                                  ll_client_common_fill_super_succeeded:1,
 745                                  ll_checksum_set:1,
 746                                  ll_inode_cache_enabled:1;
 747
 748         struct lustre_client_ocd ll_lco;
 749
 750         struct lprocfs_stats     *ll_stats; /* lprocfs stats counter */
 751
 752         /* Used to track "unstable" pages on a client, and maintain a
 753          * LRU list of clean pages. An "unstable" page is defined as
 754          * any page which is sent to a server as part of a bulk request,
 755          * but is uncommitted to stable storage. */
 756         struct cl_client_cache   *ll_cache;
 757
 758         struct lprocfs_stats     *ll_ra_stats;
 759
 760         struct ll_ra_info         ll_ra_info;
 761         unsigned int              ll_namelen;
 762         const struct file_operations *ll_fop;
 763
 764         struct lu_site           *ll_site;
 765         struct cl_device         *ll_cl;
 766
 767         /* Statistics */
 768         struct ll_rw_extents_info *ll_rw_extents_info;
 769         int                       ll_extent_process_count;
 770         unsigned int              ll_offset_process_count;
 771         struct ll_rw_process_info *ll_rw_process_info;
 772         struct ll_rw_process_info *ll_rw_offset_info;
 773         ktime_t                   ll_process_stats_init;
 774         unsigned int              ll_rw_offset_entry_count;
 775         int                       ll_stats_track_id;
 776         enum stats_track_type     ll_stats_track_type;
 777         int                       ll_rw_stats_on;
 778
 779         /* metadata stat-ahead */
 780         unsigned int              ll_sa_running_max;/* max concurrent
 781                                                      * statahead instances */
 782         unsigned int              ll_sa_max;     /* max statahead RPCs */
 783         atomic_t                  ll_sa_total;   /* statahead thread started
 784                                                   * count */
 785         atomic_t                  ll_sa_wrong;   /* statahead thread stopped for
 786                                                   * low hit ratio */
 787         atomic_t                  ll_sa_running; /* running statahead thread
 788                                                   * count */
 789         atomic_t                  ll_agl_total;  /* AGL thread started count */
 790         atomic_t                  ll_sa_hit_total;  /* total hit count */
 791         atomic_t                  ll_sa_miss_total; /* total miss count */
 792
 793         dev_t                     ll_sdev_orig; /* save s_dev before assign for
 794                                                  * clustred nfs */
 795         /* root squash */
 796         struct root_squash_info   ll_squash;
 797         struct path               ll_mnt;
 798
 799         /* st_blksize returned by stat(2), when non-zero */
 800         unsigned int              ll_stat_blksize;
 801
 802         /* maximum relative age of cached statfs results */
 803         unsigned int              ll_statfs_max_age;
 804
 805         struct kset               ll_kset;      /* sysfs object */
 806         struct completion         ll_kobj_unregister;
 807
 808         /* File heat */
 809         unsigned int              ll_heat_decay_weight;
 810         unsigned int              ll_heat_period_second;
 811
 812         /* Opens of the same inode before we start requesting open lock */
 813         u32                       ll_oc_thrsh_count;
 814
 815         /* Time in ms between last inode close and next open to be considered
 816          * instant back to back and would trigger an open lock request
 817          */
 818         u32                       ll_oc_thrsh_ms;
 819
 820         /* Time in ms after last file close that we no longer count prior opens*/
 821         u32                       ll_oc_max_ms;
 822
 823         /* filesystem fsname */
 824         char                      ll_fsname[LUSTRE_MAXFSNAME + 1];
 825
 826         /* Persistent Client Cache */
 827         struct pcc_super          ll_pcc_super;
 828
 829         /* to protect vs updates in all following foreign symlink fields */
 830         struct rw_semaphore       ll_foreign_symlink_sem;
 831         /* foreign symlink path prefix */
 832         char                     *ll_foreign_symlink_prefix;
 833         /* full prefix size including leading '\0' */
 834         size_t                    ll_foreign_symlink_prefix_size;
 835         /* foreign symlink path upcall */
 836         char                     *ll_foreign_symlink_upcall;
 837         /* foreign symlink path upcall infos */
 838         struct ll_foreign_symlink_upcall_item *ll_foreign_symlink_upcall_items;
 839         /* foreign symlink path upcall nb infos */
 840         unsigned int              ll_foreign_symlink_upcall_nb_items;
 841
 842         /* cached file security context xattr name. e.g: security.selinux */
 843         char *ll_secctx_name;
 844         __u32 ll_secctx_name_size;
 845 };
 846
 847 #define SBI_DEFAULT_HEAT_DECAY_WEIGHT   ((80 * 256 + 50) / 100)
 848 #define SBI_DEFAULT_HEAT_PERIOD_SECOND  (60)
 849
 850 #define SBI_DEFAULT_OPENCACHE_THRESHOLD_COUNT   (5)
 851 #define SBI_DEFAULT_OPENCACHE_THRESHOLD_MS      (100) /* 0.1 second */
 852 #define SBI_DEFAULT_OPENCACHE_THRESHOLD_MAX_MS  (60000) /* 1 minute */
 853
 854 /*
 855  * per file-descriptor read-ahead data.
 856  */
 857 struct ll_readahead_state {
 858         spinlock_t      ras_lock;
 859         /* End byte that read(2) try to read.  */
 860         loff_t          ras_last_read_end_bytes;
 861         /*
 862          * number of bytes read after last read-ahead window reset. As window
 863          * is reset on each seek, this is effectively a number of consecutive
 864          * accesses. Maybe ->ras_accessed_in_window is better name.
 865          *
 866          * XXX nikita: window is also reset (by ras_update()) when Lustre
 867          * believes that memory pressure evicts read-ahead pages. In that
 868          * case, it probably doesn't make sense to expand window to
 869          * PTLRPC_MAX_BRW_PAGES on the third access.
 870          */
 871         loff_t          ras_consecutive_bytes;
 872         /*
 873          * number of read requests after the last read-ahead window reset
 874          * As window is reset on each seek, this is effectively the number
 875          * on consecutive read request and is used to trigger read-ahead.
 876          */
 877         unsigned long   ras_consecutive_requests;
 878         /*
 879          * Parameters of current read-ahead window. Handled by
 880          * ras_update(). On the initial access to the file or after a seek,
 881          * window is reset to 0. After 3 consecutive accesses, window is
 882          * expanded to PTLRPC_MAX_BRW_PAGES. Afterwards, window is enlarged by
 883          * PTLRPC_MAX_BRW_PAGES chunks up to ->ra_max_pages.
 884          */
 885         pgoff_t         ras_window_start_idx;
 886         pgoff_t         ras_window_pages;
 887
 888         /* Page index where min range read starts */
 889         pgoff_t         ras_range_min_start_idx;
 890         /* Page index where mmap range read ends */
 891         pgoff_t         ras_range_max_end_idx;
 892         /* number of mmap pages where last time detected */
 893         pgoff_t         ras_last_range_pages;
 894         /* number of mmap range requests */
 895         pgoff_t         ras_range_requests;
 896
 897         /*
 898          * Optimal RPC size in pages.
 899          * It decides how many pages will be sent for each read-ahead.
 900          */
 901         unsigned long   ras_rpc_pages;
 902         /*
 903          * Where next read-ahead should start at. This lies within read-ahead
 904          * window. Read-ahead window is read in pieces rather than at once
 905          * because: 1. lustre limits total number of pages under read-ahead by
 906          * ->ra_max_pages (see ll_ra_count_get()), 2. client cannot read pages
 907          * not covered by DLM lock.
 908          */
 909         pgoff_t         ras_next_readahead_idx;
 910         /*
 911          * Total number of ll_file_read requests issued, reads originating
 912          * due to mmap are not counted in this total.  This value is used to
 913          * trigger full file read-ahead after multiple reads to a small file.
 914          */
 915         unsigned long   ras_requests;
 916         /*
 917          * The following 3 items are used for detecting the stride I/O
 918          * mode.
 919          * In stride I/O mode,
 920          * ...............|-----data-----|****gap*****|--------|******|....
 921          *    offset      |-stride_bytes-|-stride_gap-|
 922          * ras_stride_offset = offset;
 923          * ras_stride_length = stride_bytes + stride_gap;
 924          * ras_stride_bytes = stride_bytes;
 925          * Note: all these three items are counted by bytes.
 926          */
 927         loff_t          ras_stride_offset;
 928         loff_t          ras_stride_length;
 929         loff_t          ras_stride_bytes;
 930         /*
 931          * number of consecutive stride request count, and it is similar as
 932          * ras_consecutive_requests, but used for stride I/O mode.
 933          * Note: only more than 2 consecutive stride request are detected,
 934          * stride read-ahead will be enable
 935          */
 936         unsigned long   ras_consecutive_stride_requests;
 937         /* index of the last page that async readahead starts */
 938         pgoff_t         ras_async_last_readpage_idx;
 939         /* whether we should increase readahead window */
 940         bool            ras_need_increase_window;
 941         /* whether ra miss check should be skipped */
 942         bool            ras_no_miss_check;
 943 };
 944
 945 struct ll_readahead_work {
 946         /** File to readahead */
 947         struct file                     *lrw_file;
 948         pgoff_t                          lrw_start_idx;
 949         pgoff_t                          lrw_end_idx;
 950         pid_t                            lrw_user_pid;
 951
 952         /* async worker to handler read */
 953         struct work_struct               lrw_readahead_work;
 954         char                             lrw_jobid[LUSTRE_JOBID_SIZE];
 955 };
 956
 957 extern struct kmem_cache *ll_file_data_slab;
 958 struct lustre_handle;
 959 struct ll_file_data {
 960         struct ll_readahead_state fd_ras;
 961         struct ll_grouplock fd_grouplock;
 962         __u64 lfd_pos;
 963         __u32 fd_flags;
 964         fmode_t fd_omode;
 965         /* openhandle if lease exists for this file.
 966          * Borrow lli->lli_och_mutex to protect assignment */
 967         struct obd_client_handle *fd_lease_och;
 968         struct obd_client_handle *fd_och;
 969         struct file *fd_file;
 970         /* Indicate whether need to report failure when close.
 971          * true: failure is known, not report again.
 972          * false: unknown failure, should report. */
 973         bool fd_write_failed;
 974         bool ll_lock_no_expand;
 975         /* Used by mirrored file to lead IOs to a specific mirror, usually
 976          * for mirror resync. 0 means default. */
 977         __u32 fd_designated_mirror;
 978         /* The layout version when resync starts. Resync I/O should carry this
 979          * layout version for verification to OST objects */
 980         __u32 fd_layout_version;
 981         struct pcc_file fd_pcc_file;
 982         /* striped directory may read partially if some stripe inaccessible,
 983          * -errno is saved here, and will return to user in close().
 984          */
 985         int fd_partial_readdir_rc;
 986 };
 987
 988 void llite_tunables_unregister(void);
 989 int llite_tunables_register(void);
 990
 991 static inline struct inode *ll_info2i(struct ll_inode_info *lli)
 992 {
 993         return &lli->lli_vfs_inode;
 994 }
 995
 996 __u32 ll_i2suppgid(struct inode *i);
 997 void ll_i2gids(__u32 *suppgids, struct inode *i1,struct inode *i2);
 998
 999 static inline int ll_need_32bit_api(struct ll_sb_info *sbi)
1000 {
1001 #if BITS_PER_LONG == 32
1002         return 1;
1003 #elif defined(CONFIG_COMPAT)
1004         if (unlikely(test_bit(LL_SBI_32BIT_API, sbi->ll_flags)))
1005                 return true;
1006
1007 # ifdef CONFIG_X86_X32
1008         /* in_compat_syscall() returns true when called from a kthread
1009          * and CONFIG_X86_X32 is enabled, which is wrong. So check
1010          * whether the caller comes from a syscall (ie. not a kthread)
1011          * before calling in_compat_syscall(). */
1012         if (current->flags & PF_KTHREAD)
1013                 return false;
1014 # endif
1015
1016         return unlikely(in_compat_syscall());
1017 #else
1018         return unlikely(test_bit(LL_SBI_32BIT_API, sbi->ll_flags));
1019 #endif
1020 }
1021
1022 static inline bool ll_sbi_has_fast_read(struct ll_sb_info *sbi)
1023 {
1024         return test_bit(LL_SBI_FAST_READ, sbi->ll_flags);
1025 }
1026
1027 static inline bool ll_sbi_has_tiny_write(struct ll_sb_info *sbi)
1028 {
1029         return test_bit(LL_SBI_TINY_WRITE, sbi->ll_flags);
1030 }
1031
1032 static inline bool ll_sbi_has_file_heat(struct ll_sb_info *sbi)
1033 {
1034         return test_bit(LL_SBI_FILE_HEAT, sbi->ll_flags);
1035 }
1036
1037 static inline bool ll_sbi_has_foreign_symlink(struct ll_sb_info *sbi)
1038 {
1039         return test_bit(LL_SBI_FOREIGN_SYMLINK, sbi->ll_flags);
1040 }
1041
1042 static inline bool ll_sbi_has_parallel_dio(struct ll_sb_info *sbi)
1043 {
1044         return test_bit(LL_SBI_PARALLEL_DIO, sbi->ll_flags);
1045 }
1046
1047 void ll_ras_enter(struct file *f, loff_t pos, size_t count);
1048
1049 /* llite/lcommon_misc.c */
1050 int cl_ocd_update(struct obd_device *host, struct obd_device *watched,
1051                   enum obd_notify_event ev, void *owner);
1052 int cl_get_grouplock(struct cl_object *obj, unsigned long gid, int nonblock,
1053                      struct ll_grouplock *lg);
1054 void cl_put_grouplock(struct ll_grouplock *lg);
1055
1056 /* llite/lproc_llite.c */
1057 int ll_debugfs_register_super(struct super_block *sb, const char *name);
1058 void ll_debugfs_unregister_super(struct super_block *sb);
1059 void ll_stats_ops_tally(struct ll_sb_info *sbi, int op, long count);
1060 void ll_free_rw_stats_info(struct ll_sb_info *sbi);
1061
1062 enum {
1063         LPROC_LL_READ_BYTES,
1064         LPROC_LL_WRITE_BYTES,
1065         LPROC_LL_READ,
1066         LPROC_LL_WRITE,
1067         LPROC_LL_IOCTL,
1068         LPROC_LL_OPEN,
1069         LPROC_LL_RELEASE,
1070         LPROC_LL_MMAP,
1071         LPROC_LL_FAULT,
1072         LPROC_LL_MKWRITE,
1073         LPROC_LL_LLSEEK,
1074         LPROC_LL_FSYNC,
1075         LPROC_LL_READDIR,
1076         LPROC_LL_SETATTR,
1077         LPROC_LL_TRUNC,
1078         LPROC_LL_FLOCK,
1079         LPROC_LL_GETATTR,
1080         LPROC_LL_CREATE,
1081         LPROC_LL_LINK,
1082         LPROC_LL_UNLINK,
1083         LPROC_LL_SYMLINK,
1084         LPROC_LL_MKDIR,
1085         LPROC_LL_RMDIR,
1086         LPROC_LL_MKNOD,
1087         LPROC_LL_RENAME,
1088         LPROC_LL_STATFS,
1089         LPROC_LL_SETXATTR,
1090         LPROC_LL_GETXATTR,
1091         LPROC_LL_GETXATTR_HITS,
1092         LPROC_LL_LISTXATTR,
1093         LPROC_LL_REMOVEXATTR,
1094         LPROC_LL_INODE_PERM,
1095         LPROC_LL_FALLOCATE,
1096         LPROC_LL_INODE_OCOUNT,
1097         LPROC_LL_INODE_OPCLTM,
1098         LPROC_LL_FILE_OPCODES
1099 };
1100
1101 /* llite/dir.c */
1102 enum get_default_layout_type {
1103         GET_DEFAULT_LAYOUT_ROOT = 1,
1104 };
1105
1106 extern const struct file_operations ll_dir_operations;
1107 extern const struct inode_operations ll_dir_inode_operations;
1108 #ifdef HAVE_DIR_CONTEXT
1109 int ll_dir_read(struct inode *inode, __u64 *pos, struct md_op_data *op_data,
1110                 struct dir_context *ctx, int *partial_readdir_rc);
1111 #else
1112 int ll_dir_read(struct inode *inode, __u64 *pos, struct md_op_data *op_data,
1113                 void *cookie, filldir_t filldir, int *partial_readdir_rc);
1114 #endif
1115 int ll_get_mdt_idx(struct inode *inode);
1116 int ll_get_mdt_idx_by_fid(struct ll_sb_info *sbi, const struct lu_fid *fid);
1117 struct page *ll_get_dir_page(struct inode *dir, struct md_op_data *op_data,
1118                               __u64 offset, int *partial_readdir_rc);
1119 void ll_release_page(struct inode *inode, struct page *page, bool remove);
1120 int quotactl_ioctl(struct super_block *sb, struct if_quotactl *qctl);
1121
1122 /* llite/namei.c */
1123 extern const struct inode_operations ll_special_inode_operations;
1124
1125 struct inode *ll_iget(struct super_block *sb, ino_t hash,
1126                       struct lustre_md *lic);
1127 int ll_test_inode_by_fid(struct inode *inode, void *opaque);
1128 int ll_md_blocking_ast(struct ldlm_lock *, struct ldlm_lock_desc *,
1129                        void *data, int flag);
1130 struct dentry *ll_splice_alias(struct inode *inode, struct dentry *de);
1131 int ll_rmdir_entry(struct inode *dir, char *name, int namelen);
1132 void ll_update_times(struct ptlrpc_request *request, struct inode *inode);
1133
1134 /* llite/rw.c */
1135 int ll_writepage(struct page *page, struct writeback_control *wbc);
1136 int ll_writepages(struct address_space *, struct writeback_control *wbc);
1137 int ll_readpage(struct file *file, struct page *page);
1138 int ll_io_read_page(const struct lu_env *env, struct cl_io *io,
1139                            struct cl_page *page, struct file *file);
1140 void ll_readahead_init(struct inode *inode, struct ll_readahead_state *ras);
1141 int vvp_io_write_commit(const struct lu_env *env, struct cl_io *io);
1142
1143 enum lcc_type;
1144 void ll_cl_add(struct inode *inode, const struct lu_env *env, struct cl_io *io,
1145                enum lcc_type type);
1146 void ll_cl_remove(struct inode *inode, const struct lu_env *env);
1147 struct ll_cl_context *ll_cl_find(struct inode *inode);
1148
1149 extern const struct address_space_operations ll_aops;
1150
1151 /* llite/file.c */
1152 extern const struct inode_operations ll_file_inode_operations;
1153 const struct file_operations *ll_select_file_operations(struct ll_sb_info *sbi);
1154 extern int ll_have_md_lock(struct inode *inode, __u64 *bits,
1155                            enum ldlm_mode l_req_mode);
1156 extern enum ldlm_mode ll_take_md_lock(struct inode *inode, __u64 bits,
1157                                       struct lustre_handle *lockh, __u64 flags,
1158                                       enum ldlm_mode mode);
1159
1160 int ll_file_open(struct inode *inode, struct file *file);
1161 int ll_file_release(struct inode *inode, struct file *file);
1162 int ll_release_openhandle(struct dentry *, struct lookup_intent *);
1163 int ll_md_real_close(struct inode *inode, fmode_t fmode);
1164 void ll_track_file_opens(struct inode *inode);
1165 extern void ll_rw_stats_tally(struct ll_sb_info *sbi, pid_t pid,
1166                               struct ll_file_data *file, loff_t pos,
1167                               size_t count, int rw);
1168 #if defined(HAVE_USER_NAMESPACE_ARG) || defined(HAVE_INODEOPS_ENHANCED_GETATTR)
1169 int ll_getattr(struct user_namespace *mnt_userns, const struct path *path,
1170                struct kstat *stat, u32 request_mask, unsigned int flags);
1171 #else
1172 int ll_getattr(struct vfsmount *mnt, struct dentry *de, struct kstat *stat);
1173 #endif /* HAVE_USER_NAMESPACE_ARG */
1174 int ll_getattr_dentry(struct dentry *de, struct kstat *stat, u32 request_mask,
1175                       unsigned int flags, bool foreign);
1176 #ifdef CONFIG_LUSTRE_FS_POSIX_ACL
1177 struct posix_acl *ll_get_acl(struct inode *inode, int type
1178 #ifdef HAVE_GET_ACL_RCU_ARG
1179                              , bool rcu
1180 #endif /* HAVE_GET_ACL_RCU_ARG */
1181                              );
1182 int ll_set_acl(struct user_namespace *mnt_userns, struct inode *inode,
1183                struct posix_acl *acl, int type);
1184 #else  /* !CONFIG_LUSTRE_FS_POSIX_ACL */
1185 #define ll_get_acl NULL
1186 #define ll_set_acl NULL
1187 #endif /* CONFIG_LUSTRE_FS_POSIX_ACL */
1188
1189 static inline int ll_xflags_to_inode_flags(int xflags)
1190 {
1191         return ((xflags & FS_XFLAG_SYNC)      ? S_SYNC      : 0) |
1192                ((xflags & FS_XFLAG_NOATIME)   ? S_NOATIME   : 0) |
1193                ((xflags & FS_XFLAG_APPEND)    ? S_APPEND    : 0) |
1194                ((xflags & FS_XFLAG_IMMUTABLE) ? S_IMMUTABLE : 0);
1195 }
1196
1197 static inline int ll_inode_flags_to_xflags(int inode_flags)
1198 {
1199         return ((inode_flags & S_SYNC)      ? FS_XFLAG_SYNC      : 0) |
1200                ((inode_flags & S_NOATIME)   ? FS_XFLAG_NOATIME   : 0) |
1201                ((inode_flags & S_APPEND)    ? FS_XFLAG_APPEND    : 0) |
1202                ((inode_flags & S_IMMUTABLE) ? FS_XFLAG_IMMUTABLE : 0);
1203 }
1204
1205 int ll_migrate(struct inode *parent, struct file *file,
1206                struct lmv_user_md *lum, const char *name, __u32 flags);
1207 int ll_get_fid_by_name(struct inode *parent, const char *name,
1208                        int namelen, struct lu_fid *fid, struct inode **inode);
1209 int ll_inode_permission(struct user_namespace *mnt_userns, struct inode *inode,
1210                         int mask);
1211 int ll_ioctl_check_project(struct inode *inode, __u32 xflags, __u32 projid);
1212 int ll_ioctl_fsgetxattr(struct inode *inode, unsigned int cmd,
1213                         unsigned long arg);
1214 int ll_ioctl_fssetxattr(struct inode *inode, unsigned int cmd,
1215                         unsigned long arg);
1216 int ll_ioctl_project(struct file *file, unsigned int cmd,
1217                      unsigned long arg);
1218
1219 int ll_lov_setstripe_ea_info(struct inode *inode, struct dentry *dentry,
1220                              __u64 flags, struct lov_user_md *lum,
1221                              int lum_size);
1222 int ll_lov_getstripe_ea_info(struct inode *inode, const char *filename,
1223                              struct lov_mds_md **lmm, int *lmm_size,
1224                              struct ptlrpc_request **request);
1225 int ll_dir_setstripe(struct inode *inode, struct lov_user_md *lump,
1226                      int set_default);
1227 int ll_dir_get_default_layout(struct inode *inode, void **plmm, int *plmm_size,
1228                               struct ptlrpc_request **request, u64 valid,
1229                               enum get_default_layout_type type);
1230 int ll_dir_getstripe_default(struct inode *inode, void **lmmp,
1231                              int *lmm_size, struct ptlrpc_request **request,
1232                              struct ptlrpc_request **root_request, u64 valid);
1233 int ll_dir_getstripe(struct inode *inode, void **plmm, int *plmm_size,
1234                      struct ptlrpc_request **request, u64 valid);
1235 int ll_fsync(struct file *file, loff_t start, loff_t end, int data);
1236 int ll_merge_attr(const struct lu_env *env, struct inode *inode);
1237 int ll_fid2path(struct inode *inode, void __user *arg);
1238 int ll_data_version(struct inode *inode, __u64 *data_version, int flags);
1239 int ll_hsm_release(struct inode *inode);
1240 int ll_hsm_state_set(struct inode *inode, struct hsm_state_set *hss);
1241 void ll_io_set_mirror(struct cl_io *io, const struct file *file);
1242
1243 /* llite/dcache.c */
1244
1245 extern const struct dentry_operations ll_d_ops;
1246 #ifndef HAVE_D_INIT
1247 bool ll_d_setup(struct dentry *de, bool do_put);
1248
1249 static inline bool lld_is_init(struct dentry *dentry)
1250 {
1251         return ll_d2d(dentry);
1252 }
1253 #else
1254 #define ll_d_setup(de, do_put) (true)
1255 #define lld_is_init(dentry) (true)
1256 #endif
1257
1258 void ll_intent_drop_lock(struct lookup_intent *);
1259 void ll_intent_release(struct lookup_intent *);
1260 void ll_prune_aliases(struct inode *inode);
1261 void ll_lookup_finish_locks(struct lookup_intent *it, struct dentry *dentry);
1262 int ll_revalidate_it_finish(struct ptlrpc_request *request,
1263                             struct lookup_intent *it, struct dentry *de);
1264
1265 /* llite/llite_lib.c */
1266 extern const struct super_operations lustre_super_operations;
1267
1268 void ll_lli_init(struct ll_inode_info *lli);
1269 int ll_fill_super(struct super_block *sb);
1270 void ll_put_super(struct super_block *sb);
1271 void ll_kill_super(struct super_block *sb);
1272 struct inode *ll_inode_from_resource_lock(struct ldlm_lock *lock);
1273 void ll_dir_clear_lsm_md(struct inode *inode);
1274 void ll_clear_inode(struct inode *inode);
1275 int volatile_ref_file(const char *volatile_name, int volatile_len,
1276                       struct file **ref_file);
1277 int ll_setattr_raw(struct dentry *dentry, struct iattr *attr,
1278                    enum op_xvalid xvalid, bool hsm_import);
1279 int ll_setattr(struct user_namespace *mnt_userns, struct dentry *de,
1280                struct iattr *attr);
1281 int ll_statfs(struct dentry *de, struct kstatfs *sfs);
1282 int ll_statfs_internal(struct ll_sb_info *sbi, struct obd_statfs *osfs,
1283                        u32 flags);
1284 int ll_update_inode(struct inode *inode, struct lustre_md *md);
1285 void ll_update_inode_flags(struct inode *inode, unsigned int ext_flags);
1286 void ll_update_dir_depth(struct inode *dir, struct inode *inode);
1287 int ll_read_inode2(struct inode *inode, void *opaque);
1288 void ll_truncate_inode_pages_final(struct inode *inode);
1289 void ll_delete_inode(struct inode *inode);
1290 int ll_iocontrol(struct inode *inode, struct file *file,
1291                  unsigned int cmd, unsigned long arg);
1292 int ll_flush_ctx(struct inode *inode);
1293 void ll_umount_begin(struct super_block *sb);
1294 int ll_remount_fs(struct super_block *sb, int *flags, char *data);
1295 int ll_show_options(struct seq_file *seq, struct dentry *dentry);
1296 void ll_dirty_page_discard_warn(struct inode *inode, int ioret);
1297 int ll_prep_inode(struct inode **inode, struct req_capsule *pill,
1298                   struct super_block *sb, struct lookup_intent *it);
1299 int ll_obd_statfs(struct inode *inode, void __user *arg);
1300 int ll_get_max_mdsize(struct ll_sb_info *sbi, int *max_mdsize);
1301 int ll_get_default_mdsize(struct ll_sb_info *sbi, int *default_mdsize);
1302 int ll_set_default_mdsize(struct ll_sb_info *sbi, int default_mdsize);
1303
1304 void ll_unlock_md_op_lsm(struct md_op_data *op_data);
1305 struct md_op_data *ll_prep_md_op_data(struct md_op_data *op_data,
1306                                       struct inode *i1, struct inode *i2,
1307                                       const char *name, size_t namelen,
1308                                       __u32 mode, enum md_op_code opc,
1309                                       void *data);
1310 void ll_finish_md_op_data(struct md_op_data *op_data);
1311 int ll_get_obd_name(struct inode *inode, unsigned int cmd, unsigned long arg);
1312 void ll_compute_rootsquash_state(struct ll_sb_info *sbi);
1313 ssize_t ll_copy_user_md(const struct lov_user_md __user *md,
1314                         struct lov_user_md **kbuf);
1315 void ll_open_cleanup(struct super_block *sb, struct req_capsule *pill);
1316
1317 void ll_dom_finish_open(struct inode *inode, struct ptlrpc_request *req);
1318
1319 /* Compute expected user md size when passing in a md from user space */
1320 static inline ssize_t ll_lov_user_md_size(const struct lov_user_md *lum)
1321 {
1322         switch (lum->lmm_magic) {
1323         case LOV_USER_MAGIC_V1:
1324                 return sizeof(struct lov_user_md_v1);
1325         case LOV_USER_MAGIC_V3:
1326                 return sizeof(struct lov_user_md_v3);
1327         case LOV_USER_MAGIC_SPECIFIC:
1328                 if (lum->lmm_stripe_count > LOV_MAX_STRIPE_COUNT)
1329                         return -EINVAL;
1330
1331                 return lov_user_md_size(lum->lmm_stripe_count,
1332                                         LOV_USER_MAGIC_SPECIFIC);
1333         case LOV_USER_MAGIC_COMP_V1:
1334                 return ((struct lov_comp_md_v1 *)lum)->lcm_size;
1335         case LOV_USER_MAGIC_FOREIGN:
1336                 return foreign_size(lum);
1337         }
1338
1339         return -EINVAL;
1340 }
1341
1342 /* llite/llite_nfs.c */
1343 extern const struct export_operations lustre_export_operations;
1344 __u32 get_uuid2int(const char *name, int len);
1345 struct inode *search_inode_for_lustre(struct super_block *sb,
1346                                       const struct lu_fid *fid);
1347 int ll_dir_get_parent_fid(struct inode *dir, struct lu_fid *parent_fid);
1348
1349 /* llite/symlink.c */
1350 extern const struct inode_operations ll_fast_symlink_inode_operations;
1351
1352 /**
1353  * IO arguments for various VFS I/O interfaces.
1354  */
1355 struct vvp_io_args {
1356         /** normal/sendfile/splice */
1357         union {
1358                 struct {
1359                         struct kiocb      *via_iocb;
1360                         struct iov_iter   *via_iter;
1361                 } normal;
1362         } u;
1363 };
1364
1365 enum lcc_type {
1366         LCC_RW = 1,
1367         LCC_MMAP
1368 };
1369
1370 struct ll_cl_context {
1371         struct list_head         lcc_list;
1372         void                    *lcc_cookie;
1373         const struct lu_env     *lcc_env;
1374         struct cl_io            *lcc_io;
1375         struct cl_page          *lcc_page;
1376         enum lcc_type            lcc_type;
1377 };
1378
1379 struct ll_thread_info {
1380         struct vvp_io_args      lti_args;
1381         struct ra_io_arg        lti_ria;
1382         struct ll_cl_context    lti_io_ctx;
1383 };
1384
1385 extern struct lu_context_key ll_thread_key;
1386
1387 static inline struct ll_thread_info *ll_env_info(const struct lu_env *env)
1388 {
1389         struct ll_thread_info *lti;
1390
1391         lti = lu_context_key_get(&env->le_ctx, &ll_thread_key);
1392         LASSERT(lti != NULL);
1393
1394         return lti;
1395 }
1396
1397 static inline struct vvp_io_args *ll_env_args(const struct lu_env *env)
1398 {
1399         return &ll_env_info(env)->lti_args;
1400 }
1401
1402 void ll_io_init(struct cl_io *io, struct file *file, enum cl_io_type iot,
1403                 struct vvp_io_args *args);
1404
1405 /* llite/llite_mmap.c */
1406
1407 int ll_file_mmap(struct file * file, struct vm_area_struct * vma);
1408 void policy_from_vma(union ldlm_policy_data *policy, struct vm_area_struct *vma,
1409                      unsigned long addr, size_t count);
1410 struct vm_area_struct *our_vma(struct mm_struct *mm, unsigned long addr,
1411                                size_t count);
1412
1413 #define    ll_s2sbi(sb)        (s2lsi(sb)->lsi_llsbi)
1414
1415 /* don't need an addref as the sb_info should be holding one */
1416 static inline struct obd_export *ll_s2dtexp(struct super_block *sb)
1417 {
1418         return ll_s2sbi(sb)->ll_dt_exp;
1419 }
1420
1421 /* don't need an addref as the sb_info should be holding one */
1422 static inline struct obd_export *ll_s2mdexp(struct super_block *sb)
1423 {
1424         return ll_s2sbi(sb)->ll_md_exp;
1425 }
1426
1427 static inline struct client_obd *sbi2mdc(struct ll_sb_info *sbi)
1428 {
1429         struct obd_device *obd = sbi->ll_md_exp->exp_obd;
1430         if (obd == NULL)
1431                 LBUG();
1432         return &obd->u.cli;
1433 }
1434
1435 // FIXME: replace the name of this with LL_SB to conform to kernel stuff
1436 static inline struct ll_sb_info *ll_i2sbi(struct inode *inode)
1437 {
1438         return ll_s2sbi(inode->i_sb);
1439 }
1440
1441 static inline struct obd_export *ll_i2dtexp(struct inode *inode)
1442 {
1443         return ll_s2dtexp(inode->i_sb);
1444 }
1445
1446 static inline struct obd_export *ll_i2mdexp(struct inode *inode)
1447 {
1448         return ll_s2mdexp(inode->i_sb);
1449 }
1450
1451 static inline struct lu_fid *ll_inode2fid(struct inode *inode)
1452 {
1453         struct lu_fid *fid;
1454
1455         LASSERT(inode != NULL);
1456         fid = &ll_i2info(inode)->lli_fid;
1457
1458         return fid;
1459 }
1460
1461 static inline bool ll_dir_striped(struct inode *inode)
1462 {
1463         struct ll_inode_info *lli;
1464         bool rc;
1465
1466         LASSERT(inode);
1467         if (!S_ISDIR(inode->i_mode))
1468                 return false;
1469
1470         lli = ll_i2info(inode);
1471         if (!lli->lli_lsm_md)
1472                 return false;
1473
1474         down_read(&lli->lli_lsm_sem);
1475         rc = lmv_dir_striped(lli->lli_lsm_md);
1476         up_read(&lli->lli_lsm_sem);
1477
1478         return rc;
1479 }
1480
1481 static inline loff_t ll_file_maxbytes(struct inode *inode)
1482 {
1483         struct cl_object *obj = ll_i2info(inode)->lli_clob;
1484
1485         if (obj == NULL)
1486                 return MAX_LFS_FILESIZE;
1487
1488         return min_t(loff_t, cl_object_maxbytes(obj), MAX_LFS_FILESIZE);
1489 }
1490
1491 /* llite/xattr.c */
1492 extern const struct xattr_handler *ll_xattr_handlers[];
1493
1494 #define XATTR_USER_T            1
1495 #define XATTR_TRUSTED_T         2
1496 #define XATTR_SECURITY_T        3
1497 #define XATTR_ACL_ACCESS_T      4
1498 #define XATTR_ACL_DEFAULT_T     5
1499 #define XATTR_LUSTRE_T          6
1500 #define XATTR_OTHER_T           7
1501 #define XATTR_ENCRYPTION_T      9
1502
1503 ssize_t ll_listxattr(struct dentry *dentry, char *buffer, size_t size);
1504 int ll_xattr_list(struct inode *inode, const char *name, int type,
1505                   void *buffer, size_t size, u64 valid);
1506 const struct xattr_handler *get_xattr_type(const char *name);
1507
1508 /**
1509  * Common IO arguments for various VFS I/O interfaces.
1510  */
1511 int cl_sb_init(struct super_block *sb);
1512 int cl_sb_fini(struct super_block *sb);
1513
1514 enum ras_update_flags {
1515         LL_RAS_HIT  = 0x1,
1516         LL_RAS_MMAP = 0x2
1517 };
1518 void ll_ra_count_put(struct ll_sb_info *sbi, unsigned long len);
1519 void ll_ra_stats_inc(struct inode *inode, enum ra_stat which);
1520
1521 /* statahead.c */
1522
1523 #define LL_SA_RPC_MIN           2
1524 #define LL_SA_RPC_DEF           32
1525 #define LL_SA_RPC_MAX           512
1526
1527 /* XXX: If want to support more concurrent statahead instances,
1528  *      please consider to decentralize the RPC lists attached
1529  *      on related import, such as imp_{sending,delayed}_list.
1530  *      LU-11079 */
1531 #define LL_SA_RUNNING_MAX       256
1532 #define LL_SA_RUNNING_DEF       16
1533
1534 #define LL_SA_CACHE_BIT         5
1535 #define LL_SA_CACHE_SIZE        (1 << LL_SA_CACHE_BIT)
1536 #define LL_SA_CACHE_MASK        (LL_SA_CACHE_SIZE - 1)
1537
1538 /* per inode struct, for dir only */
1539 struct ll_statahead_info {
1540         struct dentry          *sai_dentry;
1541         atomic_t                sai_refcount;   /* when access this struct, hold
1542                                                  * refcount */
1543         unsigned int            sai_max;        /* max ahead of lookup */
1544         __u64                   sai_sent;       /* stat requests sent count */
1545         __u64                   sai_replied;    /* stat requests which received
1546                                                  * reply */
1547         __u64                   sai_index;      /* index of statahead entry */
1548         __u64                   sai_index_wait; /* index of entry which is the
1549                                                  * caller is waiting for */
1550         __u64                   sai_hit;        /* hit count */
1551         __u64                   sai_miss;       /* miss count:
1552                                                  * for "ls -al" case, includes
1553                                                  * hidden dentry miss;
1554                                                  * for "ls -l" case, it does not
1555                                                  * include hidden dentry miss.
1556                                                  * "sai_miss_hidden" is used for
1557                                                  * the later case.
1558                                                  */
1559         unsigned int            sai_consecutive_miss; /* consecutive miss */
1560         unsigned int            sai_miss_hidden;/* "ls -al", but first dentry
1561                                                  * is not a hidden one */
1562         unsigned int            sai_skip_hidden;/* skipped hidden dentry count
1563                                                  */
1564         unsigned int            sai_ls_all:1;   /* "ls -al", do stat-ahead for
1565                                                  * hidden entries */
1566         wait_queue_head_t       sai_waitq;      /* stat-ahead wait queue */
1567         struct task_struct      *sai_task;      /* stat-ahead thread */
1568         struct task_struct      *sai_agl_task;  /* AGL thread */
1569         struct list_head        sai_entries;    /* completed entries */
1570         struct list_head        sai_agls;       /* AGLs to be sent */
1571         struct list_head        sai_cache[LL_SA_CACHE_SIZE];
1572         spinlock_t              sai_cache_lock[LL_SA_CACHE_SIZE];
1573         atomic_t                sai_cache_count; /* entry count in cache */
1574 };
1575
1576 int ll_revalidate_statahead(struct inode *dir, struct dentry **dentry,
1577                             bool unplug);
1578 int ll_start_statahead(struct inode *dir, struct dentry *dentry, bool agl);
1579 void ll_authorize_statahead(struct inode *dir, void *key);
1580 void ll_deauthorize_statahead(struct inode *dir, void *key);
1581
1582 /* glimpse.c */
1583 blkcnt_t dirty_cnt(struct inode *inode);
1584
1585 int cl_glimpse_size0(struct inode *inode, int agl);
1586 int cl_glimpse_lock(const struct lu_env *env, struct cl_io *io,
1587                     struct inode *inode, struct cl_object *clob, int agl);
1588
1589 static inline int cl_glimpse_size(struct inode *inode)
1590 {
1591         return cl_glimpse_size0(inode, 0);
1592 }
1593
1594 /* AGL is 'asychronous glimpse lock', which is a speculative lock taken as
1595  * part of statahead */
1596 static inline int cl_agl(struct inode *inode)
1597 {
1598         return cl_glimpse_size0(inode, 1);
1599 }
1600
1601 int ll_file_lock_ahead(struct file *file, struct llapi_lu_ladvise *ladvise);
1602
1603 int cl_io_get(struct inode *inode, struct lu_env **envout,
1604               struct cl_io **ioout, __u16 *refcheck);
1605
1606 static inline int ll_glimpse_size(struct inode *inode)
1607 {
1608         struct ll_inode_info *lli = ll_i2info(inode);
1609         int rc;
1610
1611         down_read(&lli->lli_glimpse_sem);
1612         rc = cl_glimpse_size(inode);
1613         lli->lli_glimpse_time = ktime_get();
1614         up_read(&lli->lli_glimpse_sem);
1615         return rc;
1616 }
1617
1618 /* dentry may statahead when statahead is enabled and current process has opened
1619  * parent directory, and this dentry hasn't accessed statahead cache before */
1620 static inline bool
1621 dentry_may_statahead(struct inode *dir, struct dentry *dentry)
1622 {
1623         struct ll_inode_info  *lli;
1624         struct ll_dentry_data *ldd;
1625
1626         if (ll_i2sbi(dir)->ll_sa_max == 0)
1627                 return false;
1628
1629         lli = ll_i2info(dir);
1630
1631         /* statahead is not allowed for this dir, there may be three causes:
1632          * 1. dir is not opened.
1633          * 2. statahead hit ratio is too low.
1634          * 3. previous stat started statahead thread failed. */
1635         if (!lli->lli_sa_enabled)
1636                 return false;
1637
1638         /* not the same process, don't statahead */
1639         if (lli->lli_opendir_pid != current->pid)
1640                 return false;
1641
1642         /*
1643          * When stating a dentry, kernel may trigger 'revalidate' or 'lookup'
1644          * multiple times, eg. for 'getattr', 'getxattr' and etc.
1645          * For patchless client, lookup intent is not accurate, which may
1646          * misguide statahead. For example:
1647          * The 'revalidate' call for 'getattr' and 'getxattr' of a dentry will
1648          * have the same intent -- IT_GETATTR, while one dentry should access
1649          * statahead cache once, otherwise statahead windows is messed up.
1650          * The solution is as following:
1651          * Assign 'lld_sa_generation' with 'lli_sa_generation' when a dentry
1652          * IT_GETATTR for the first time, and subsequent IT_GETATTR will
1653          * bypass interacting with statahead cache by checking
1654          * 'lld_sa_generation == lli->lli_sa_generation'.
1655          */
1656         ldd = ll_d2d(dentry);
1657         if (ldd != NULL && lli->lli_sa_generation &&
1658             ldd->lld_sa_generation == lli->lli_sa_generation)
1659                 return false;
1660
1661         return true;
1662 }
1663
1664 int cl_sync_file_range(struct inode *inode, loff_t start, loff_t end,
1665                        enum cl_fsync_mode mode, int ignore_layout);
1666
1667 static inline int ll_file_nolock(const struct file *file)
1668 {
1669         struct ll_file_data *fd = file->private_data;
1670         struct inode *inode = file_inode((struct file *)file);
1671
1672         LASSERT(fd != NULL);
1673         return ((fd->fd_flags & LL_FILE_IGNORE_LOCK) ||
1674                 test_bit(LL_SBI_NOLCK, ll_i2sbi(inode)->ll_flags));
1675 }
1676
1677 static inline void ll_set_lock_data(struct obd_export *exp, struct inode *inode,
1678                                     struct lookup_intent *it, __u64 *bits)
1679 {
1680         if (!it->it_lock_set) {
1681                 struct lustre_handle handle;
1682
1683                 /* If this inode is a remote object, it will get two
1684                  * separate locks in different namespaces, Master MDT,
1685                  * where the name entry is, will grant LOOKUP lock,
1686                  * remote MDT, where the object is, will grant
1687                  * UPDATE|PERM lock. The inode will be attched to both
1688                  * LOOKUP and PERM locks, so revoking either locks will
1689                  * case the dcache being cleared */
1690                 if (it->it_remote_lock_mode) {
1691                         handle.cookie = it->it_remote_lock_handle;
1692                         CDEBUG(D_DLMTRACE, "setting l_data to inode "DFID
1693                                "(%p) for remote lock %#llx\n",
1694                                PFID(ll_inode2fid(inode)), inode,
1695                                handle.cookie);
1696                         md_set_lock_data(exp, &handle, inode, NULL);
1697                 }
1698
1699                 handle.cookie = it->it_lock_handle;
1700
1701                 CDEBUG(D_DLMTRACE, "setting l_data to inode "DFID"(%p)"
1702                        " for lock %#llx\n",
1703                        PFID(ll_inode2fid(inode)), inode, handle.cookie);
1704
1705                 md_set_lock_data(exp, &handle, inode, &it->it_lock_bits);
1706                 it->it_lock_set = 1;
1707         }
1708
1709         if (bits != NULL)
1710                 *bits = it->it_lock_bits;
1711 }
1712
1713 static inline int d_lustre_invalid(const struct dentry *dentry)
1714 {
1715         return !ll_d2d(dentry) || ll_d2d(dentry)->lld_invalid;
1716 }
1717
1718 /*
1719  * Mark dentry INVALID, if dentry refcount is zero (this is normally case for
1720  * ll_md_blocking_ast), it will be pruned by ll_prune_aliases() and
1721  * ll_prune_negative_children(); otherwise dput() of the last refcount will
1722  * unhash this dentry and kill it.
1723  */
1724 static inline void d_lustre_invalidate(struct dentry *dentry)
1725 {
1726         CDEBUG(D_DENTRY, "invalidate dentry %pd (%p) parent %p inode %p refc %d\n",
1727                dentry, dentry,
1728                dentry->d_parent, dentry->d_inode, ll_d_count(dentry));
1729
1730         spin_lock(&dentry->d_lock);
1731         if (lld_is_init(dentry))
1732                 ll_d2d(dentry)->lld_invalid = 1;
1733         spin_unlock(&dentry->d_lock);
1734 }
1735
1736 static inline void d_lustre_revalidate(struct dentry *dentry)
1737 {
1738         spin_lock(&dentry->d_lock);
1739         LASSERT(ll_d2d(dentry));
1740         ll_d2d(dentry)->lld_invalid = 0;
1741         spin_unlock(&dentry->d_lock);
1742 }
1743
1744 static inline dev_t ll_compat_encode_dev(dev_t dev)
1745 {
1746         /* The compat_sys_*stat*() syscalls will fail unless the
1747          * device majors and minors are both less than 256. Note that
1748          * the value returned here will be passed through
1749          * old_encode_dev() in cp_compat_stat(). And so we are not
1750          * trying to return a valid compat (u16) device number, just
1751          * one that will pass the old_valid_dev() check. */
1752
1753         return MKDEV(MAJOR(dev) & 0xff, MINOR(dev) & 0xff);
1754 }
1755
1756 int ll_layout_conf(struct inode *inode, const struct cl_object_conf *conf);
1757 int ll_layout_refresh(struct inode *inode, __u32 *gen);
1758 int ll_layout_restore(struct inode *inode, loff_t start, __u64 length);
1759 int ll_layout_write_intent(struct inode *inode, enum layout_intent_opc opc,
1760                            struct lu_extent *ext);
1761
1762 int ll_xattr_init(void);
1763 void ll_xattr_fini(void);
1764
1765 int ll_page_sync_io(const struct lu_env *env, struct cl_io *io,
1766                     struct cl_page *page, enum cl_req_type crt);
1767
1768 int ll_getparent(struct file *file, struct getparent __user *arg);
1769
1770 /* lcommon_cl.c */
1771 int cl_setattr_ost(struct cl_object *obj, const struct iattr *attr,
1772                    enum op_xvalid xvalid, unsigned int attr_flags);
1773
1774 extern struct lu_env *cl_inode_fini_env;
1775 extern __u16 cl_inode_fini_refcheck;
1776
1777 int cl_file_inode_init(struct inode *inode, struct lustre_md *md);
1778 void cl_inode_fini(struct inode *inode);
1779
1780 u64 cl_fid_build_ino(const struct lu_fid *fid, int api32);
1781 u32 cl_fid_build_gen(const struct lu_fid *fid);
1782
1783 static inline struct pcc_super *ll_i2pccs(struct inode *inode)
1784 {
1785         return &ll_i2sbi(inode)->ll_pcc_super;
1786 }
1787
1788 static inline struct pcc_super *ll_info2pccs(struct ll_inode_info *lli)
1789 {
1790         return ll_i2pccs(ll_info2i(lli));
1791 }
1792
1793 /* crypto.c */
1794 /* The digested form is made of a FID (16 bytes) followed by the second-to-last
1795  * ciphertext block (16 bytes), so a total length of 32 bytes.
1796  * That way, llcrypt does not compute a digested form of this digest.
1797  */
1798 struct ll_digest_filename {
1799         struct lu_fid ldf_fid;
1800         char ldf_excerpt[LL_CRYPTO_BLOCK_SIZE];
1801 };
1802
1803 int ll_setup_filename(struct inode *dir, const struct qstr *iname,
1804                       int lookup, struct llcrypt_name *fname,
1805                       struct lu_fid *fid);
1806 int ll_fname_disk_to_usr(struct inode *inode,
1807                          u32 hash, u32 minor_hash,
1808                          struct llcrypt_str *iname, struct llcrypt_str *oname,
1809                          struct lu_fid *fid);
1810 int ll_revalidate_d_crypto(struct dentry *dentry, unsigned int flags);
1811 int ll_file_open_encrypt(struct inode *inode, struct file *filp);
1812 static inline char *xattr_for_enc(struct inode *inode)
1813 {
1814         if (ll_sbi_has_name_encrypt(ll_i2sbi(inode)))
1815                 return LL_XATTR_NAME_ENCRYPTION_CONTEXT;
1816
1817         return LL_XATTR_NAME_ENCRYPTION_CONTEXT_OLD;
1818 }
1819 #ifdef HAVE_LUSTRE_CRYPTO
1820 extern const struct llcrypt_operations lustre_cryptops;
1821 #endif
1822
1823 /* llite/llite_foreign.c */
1824 int ll_manage_foreign(struct inode *inode, struct lustre_md *lmd);
1825 bool ll_foreign_is_openable(struct dentry *dentry, unsigned int flags);
1826 bool ll_foreign_is_removable(struct dentry *dentry, bool unset);
1827
1828 int ll_filemap_fault(struct vm_area_struct *vma, struct vm_fault *vmf);
1829
1830 #endif /* LLITE_INTERNAL_H */