lustre/llite/llite_internal.h

   1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
   2  * vim:expandtab:shiftwidth=8:tabstop=8:
   3  *
   4  * GPL HEADER START
   5  *
   6  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License version 2 only,
  10  * as published by the Free Software Foundation.
  11  *
  12  * This program is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * General Public License version 2 for more details (a copy is included
  16  * in the LICENSE file that accompanied this code).
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * version 2 along with this program; If not, see
  20  * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
  21  *
  22  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
  23  * CA 95054 USA or visit www.sun.com if you need additional information or
  24  * have any questions.
  25  *
  26  * GPL HEADER END
  27  */
  28 /*
  29  * Copyright  2008 Sun Microsystems, Inc. All rights reserved
  30  * Use is subject to license terms.
  31  */
  32 /*
  33  * This file is part of Lustre, http://www.lustre.org/
  34  * Lustre is a trademark of Sun Microsystems, Inc.
  35  */
  36
  37 #ifndef LLITE_INTERNAL_H
  38 #define LLITE_INTERNAL_H
  39
  40 #include <lustre_acl.h>
  41
  42 #include <lustre_debug.h>
  43 #include <lustre_ver.h>
  44 #include <lustre_disk.h>  /* for s2sbi */
  45 #include <lustre_eacl.h>
  46
  47 /* for struct cl_lock_descr and struct cl_io */
  48 #include <cl_object.h>
  49 #include <lclient.h>
  50
  51 #ifndef FMODE_EXEC
  52 #define FMODE_EXEC 0
  53 #endif
  54
  55 #ifndef DCACHE_LUSTRE_INVALID
  56 #define DCACHE_LUSTRE_INVALID 0x100
  57 #endif
  58
  59 #define LL_IT2STR(it) ((it) ? ldlm_it2str((it)->it_op) : "0")
  60 #define LUSTRE_FPRIVATE(file) ((file)->private_data)
  61
  62 #ifdef HAVE_VFS_INTENT_PATCHES
  63 static inline struct lookup_intent *ll_nd2it(struct nameidata *nd)
  64 {
  65         return &nd->intent;
  66 }
  67 #endif
  68
  69 struct ll_dentry_data {
  70         int                      lld_cwd_count;
  71         int                      lld_mnt_count;
  72         struct obd_client_handle lld_cwd_och;
  73         struct obd_client_handle lld_mnt_och;
  74 #ifndef HAVE_VFS_INTENT_PATCHES
  75         struct lookup_intent    *lld_it;
  76 #endif
  77         unsigned int             lld_sa_generation;
  78 };
  79
  80 #define ll_d2d(de) ((struct ll_dentry_data*)((de)->d_fsdata))
  81
  82 extern struct file_operations ll_pgcache_seq_fops;
  83
  84 #define LLI_INODE_MAGIC                 0x111d0de5
  85 #define LLI_INODE_DEAD                  0xdeadd00d
  86
  87 /* remote client permission cache */
  88 #define REMOTE_PERM_HASHSIZE 16
  89
  90 /* llite setxid/access permission for user on remote client */
  91 struct ll_remote_perm {
  92         struct hlist_node       lrp_list;
  93         uid_t                   lrp_uid;
  94         gid_t                   lrp_gid;
  95         uid_t                   lrp_fsuid;
  96         gid_t                   lrp_fsgid;
  97         int                     lrp_access_perm; /* MAY_READ/WRITE/EXEC, this
  98                                                     is access permission with
  99                                                     lrp_fsuid/lrp_fsgid. */
 100 };
 101
 102 enum lli_flags {
 103         /* MDS has an authority for the Size-on-MDS attributes. */
 104         LLIF_MDS_SIZE_LOCK      = (1 << 0),
 105         /* Epoch close is postponed. */
 106         LLIF_EPOCH_PENDING      = (1 << 1),
 107         /* DONE WRITING is allowed. */
 108         LLIF_DONE_WRITING       = (1 << 2),
 109         /* Sizeon-on-MDS attributes are changed. An attribute update needs to
 110          * be sent to MDS. */
 111         LLIF_SOM_DIRTY          = (1 << 3),
 112         /* File is contented */
 113         LLIF_CONTENDED         = (1 << 4),
 114         /* Truncate uses server lock for this file */
 115         LLIF_SRVLOCK           = (1 << 5)
 116
 117 };
 118
 119 struct ll_inode_info {
 120         int                     lli_inode_magic;
 121         struct semaphore        lli_size_sem;           /* protect open and change size */
 122         void                   *lli_size_sem_owner;
 123         struct semaphore        lli_write_sem;
 124         char                   *lli_symlink_name;
 125         __u64                   lli_maxbytes;
 126         __u64                   lli_ioepoch;
 127         unsigned long           lli_flags;
 128         cfs_time_t              lli_contention_time;
 129
 130         /* this lock protects posix_acl, pending_write_llaps, mmap_cnt */
 131         spinlock_t              lli_lock;
 132         struct list_head        lli_close_list;
 133         /* handle is to be sent to MDS later on done_writing and setattr.
 134          * Open handle data are needed for the recovery to reconstruct
 135          * the inode state on the MDS. XXX: recovery is not ready yet. */
 136         struct obd_client_handle *lli_pending_och;
 137
 138         /* for writepage() only to communicate to fsync */
 139         int                     lli_async_rc;
 140
 141         struct posix_acl       *lli_posix_acl;
 142
 143         /* remote permission hash */
 144         struct hlist_head      *lli_remote_perms;
 145         unsigned long           lli_rmtperm_utime;
 146         struct semaphore        lli_rmtperm_sem;
 147
 148         struct list_head        lli_dead_list;
 149
 150         struct semaphore        lli_och_sem; /* Protects access to och pointers
 151                                                 and their usage counters */
 152         /* We need all three because every inode may be opened in different
 153            modes */
 154         struct obd_client_handle *lli_mds_read_och;
 155         __u64                   lli_open_fd_read_count;
 156         struct obd_client_handle *lli_mds_write_och;
 157         __u64                   lli_open_fd_write_count;
 158         struct obd_client_handle *lli_mds_exec_och;
 159         __u64                   lli_open_fd_exec_count;
 160
 161         struct inode            lli_vfs_inode;
 162
 163         /* identifying fields for both metadata and data stacks. */
 164         struct lu_fid           lli_fid;
 165         struct lov_stripe_md   *lli_smd;
 166
 167         /* fid capability */
 168         /* open count currently used by capability only, indicate whether
 169          * capability needs renewal */
 170         atomic_t                lli_open_count;
 171         struct obd_capa        *lli_mds_capa;
 172         struct list_head        lli_oss_capas;
 173
 174         /* metadata stat-ahead */
 175         /*
 176          * "opendir_pid" is the token when lookup/revalid -- I am the owner of
 177          * dir statahead.
 178          */
 179         pid_t                   lli_opendir_pid;
 180         /*
 181          * since parent-child threads can share the same @file struct,
 182          * "opendir_key" is the token when dir close for case of parent exit
 183          * before child -- it is me should cleanup the dir readahead. */
 184         void                   *lli_opendir_key;
 185         struct ll_statahead_info *lli_sai;
 186         struct cl_object       *lli_clob;
 187 };
 188
 189 /*
 190  * Locking to guarantee consistency of non-atomic updates to long long i_size,
 191  * consistency between file size and KMS, and consistency within
 192  * ->lli_smd->lsm_oinfo[]'s.
 193  *
 194  * Implemented by ->lli_size_sem and ->lsm_sem, nested in that order.
 195  */
 196
 197 void ll_inode_size_lock(struct inode *inode, int lock_lsm);
 198 void ll_inode_size_unlock(struct inode *inode, int unlock_lsm);
 199
 200 // FIXME: replace the name of this with LL_I to conform to kernel stuff
 201 // static inline struct ll_inode_info *LL_I(struct inode *inode)
 202 static inline struct ll_inode_info *ll_i2info(struct inode *inode)
 203 {
 204         return container_of(inode, struct ll_inode_info, lli_vfs_inode);
 205 }
 206
 207 /* default to about 40meg of readahead on a given system.  That much tied
 208  * up in 512k readahead requests serviced at 40ms each is about 1GB/s. */
 209 #define SBI_DEFAULT_READAHEAD_MAX (40UL << (20 - CFS_PAGE_SHIFT))
 210
 211 /* default to read-ahead full files smaller than 2MB on the second read */
 212 #define SBI_DEFAULT_READAHEAD_WHOLE_MAX (2UL << (20 - CFS_PAGE_SHIFT))
 213
 214 enum ra_stat {
 215         RA_STAT_HIT = 0,
 216         RA_STAT_MISS,
 217         RA_STAT_DISTANT_READPAGE,
 218         RA_STAT_MISS_IN_WINDOW,
 219         RA_STAT_FAILED_GRAB_PAGE,
 220         RA_STAT_FAILED_MATCH,
 221         RA_STAT_DISCARDED,
 222         RA_STAT_ZERO_LEN,
 223         RA_STAT_ZERO_WINDOW,
 224         RA_STAT_EOF,
 225         RA_STAT_MAX_IN_FLIGHT,
 226         RA_STAT_WRONG_GRAB_PAGE,
 227         _NR_RA_STAT,
 228 };
 229
 230 struct ll_ra_info {
 231         atomic_t                  ra_cur_pages;
 232         unsigned long             ra_max_pages;
 233         unsigned long             ra_max_pages_per_file;
 234         unsigned long             ra_max_read_ahead_whole_pages;
 235 };
 236
 237 /* ra_io_arg will be filled in the beginning of ll_readahead with
 238  * ras_lock, then the following ll_read_ahead_pages will read RA
 239  * pages according to this arg, all the items in this structure are
 240  * counted by page index.
 241  */
 242 struct ra_io_arg {
 243         unsigned long ria_start;  /* start offset of read-ahead*/
 244         unsigned long ria_end;    /* end offset of read-ahead*/
 245         /* If stride read pattern is detected, ria_stoff means where
 246          * stride read is started. Note: for normal read-ahead, the
 247          * value here is meaningless, and also it will not be accessed*/
 248         pgoff_t ria_stoff;
 249         /* ria_length and ria_pages are the length and pages length in the
 250          * stride I/O mode. And they will also be used to check whether
 251          * it is stride I/O read-ahead in the read-ahead pages*/
 252         unsigned long ria_length;
 253         unsigned long ria_pages;
 254 };
 255
 256 /* LL_HIST_MAX=32 causes an overflow */
 257 #define LL_HIST_MAX 28
 258 #define LL_HIST_START 12 /* buckets start at 2^12 = 4k */
 259 #define LL_PROCESS_HIST_MAX 10
 260 struct per_process_info {
 261         pid_t pid;
 262         struct obd_histogram pp_r_hist;
 263         struct obd_histogram pp_w_hist;
 264 };
 265
 266 /* pp_extents[LL_PROCESS_HIST_MAX] will hold the combined process info */
 267 struct ll_rw_extents_info {
 268         struct per_process_info pp_extents[LL_PROCESS_HIST_MAX + 1];
 269 };
 270
 271 #define LL_OFFSET_HIST_MAX 100
 272 struct ll_rw_process_info {
 273         pid_t                     rw_pid;
 274         int                       rw_op;
 275         loff_t                    rw_range_start;
 276         loff_t                    rw_range_end;
 277         loff_t                    rw_last_file_pos;
 278         loff_t                    rw_offset;
 279         size_t                    rw_smallest_extent;
 280         size_t                    rw_largest_extent;
 281         struct ll_file_data      *rw_last_file;
 282 };
 283
 284 enum stats_track_type {
 285         STATS_TRACK_ALL = 0,  /* track all processes */
 286         STATS_TRACK_PID,      /* track process with this pid */
 287         STATS_TRACK_PPID,     /* track processes with this ppid */
 288         STATS_TRACK_GID,      /* track processes with this gid */
 289         STATS_TRACK_LAST,
 290 };
 291
 292 /* flags for sbi->ll_flags */
 293 #define LL_SBI_NOLCK             0x01 /* DLM locking disabled (directio-only) */
 294 #define LL_SBI_CHECKSUM          0x02 /* checksum each page as it's written */
 295 #define LL_SBI_FLOCK             0x04
 296 #define LL_SBI_USER_XATTR        0x08 /* support user xattr */
 297 #define LL_SBI_ACL               0x10 /* support ACL */
 298 #define LL_SBI_JOIN              0x20 /* support JOIN */
 299 #define LL_SBI_RMT_CLIENT        0x40 /* remote client */
 300 #define LL_SBI_MDS_CAPA          0x80 /* support mds capa */
 301 #define LL_SBI_OSS_CAPA         0x100 /* support oss capa */
 302 #define LL_SBI_LOCALFLOCK       0x200 /* Local flocks support by kernel */
 303 #define LL_SBI_LRU_RESIZE       0x400 /* lru resize support */
 304 #define LL_SBI_LAZYSTATFS       0x800 /* lazystatfs mount option */
 305
 306 /* default value for ll_sb_info->contention_time */
 307 #define SBI_DEFAULT_CONTENTION_SECONDS     60
 308 /* default value for lockless_truncate_enable */
 309 #define SBI_DEFAULT_LOCKLESS_TRUNCATE_ENABLE 1
 310 #define RCE_HASHES      32
 311
 312 struct rmtacl_ctl_entry {
 313         struct list_head rce_list;
 314         pid_t            rce_key; /* hash key */
 315         int              rce_ops; /* acl operation type */
 316 };
 317
 318 struct rmtacl_ctl_table {
 319         spinlock_t       rct_lock;
 320         struct list_head rct_entries[RCE_HASHES];
 321 };
 322
 323 #define EE_HASHES       32
 324
 325 struct eacl_entry {
 326         struct list_head      ee_list;
 327         pid_t                 ee_key; /* hash key */
 328         struct lu_fid         ee_fid;
 329         int                   ee_type; /* ACL type for ACCESS or DEFAULT */
 330         ext_acl_xattr_header *ee_acl;
 331 };
 332
 333 struct eacl_table {
 334         spinlock_t       et_lock;
 335         struct list_head et_entries[EE_HASHES];
 336 };
 337
 338 struct ll_sb_info {
 339         struct list_head          ll_list;
 340         /* this protects pglist and ra_info.  It isn't safe to
 341          * grab from interrupt contexts */
 342         spinlock_t                ll_lock;
 343         spinlock_t                ll_pp_extent_lock; /* Lock for pp_extent entries */
 344         spinlock_t                ll_process_lock; /* Lock for ll_rw_process_info */
 345         struct obd_uuid           ll_sb_uuid;
 346         struct obd_export        *ll_md_exp;
 347         struct obd_export        *ll_dt_exp;
 348         struct proc_dir_entry*    ll_proc_root;
 349         struct lu_fid             ll_root_fid; /* root object fid */
 350
 351         int                       ll_flags;
 352         struct list_head          ll_conn_chain; /* per-conn chain of SBs */
 353         struct lustre_client_ocd  ll_lco;
 354
 355         struct list_head          ll_orphan_dentry_list; /*please don't ask -p*/
 356         struct ll_close_queue    *ll_lcq;
 357
 358         struct lprocfs_stats     *ll_stats; /* lprocfs stats counter */
 359
 360         unsigned long             ll_async_page_max;
 361         unsigned long             ll_async_page_count;
 362
 363         struct lprocfs_stats     *ll_ra_stats;
 364
 365         struct ll_ra_info         ll_ra_info;
 366         unsigned int              ll_namelen;
 367         struct file_operations   *ll_fop;
 368
 369 #ifdef HAVE_EXPORT___IGET
 370         struct list_head          ll_deathrow; /* inodes to be destroyed (b1443) */
 371         spinlock_t                ll_deathrow_lock;
 372 #endif
 373         /* =0 - hold lock over whole read/write
 374          * >0 - max. chunk to be read/written w/o lock re-acquiring */
 375         unsigned long             ll_max_rw_chunk;
 376
 377         struct lu_site           *ll_site;
 378         struct cl_device         *ll_cl;
 379         /* Statistics */
 380         struct ll_rw_extents_info ll_rw_extents_info;
 381         int                       ll_extent_process_count;
 382         struct ll_rw_process_info ll_rw_process_info[LL_PROCESS_HIST_MAX];
 383         unsigned int              ll_offset_process_count;
 384         struct ll_rw_process_info ll_rw_offset_info[LL_OFFSET_HIST_MAX];
 385         unsigned int              ll_rw_offset_entry_count;
 386         enum stats_track_type     ll_stats_track_type;
 387         int                       ll_stats_track_id;
 388         int                       ll_rw_stats_on;
 389
 390         /* metadata stat-ahead */
 391         unsigned int              ll_sa_max;     /* max statahead RPCs */
 392         unsigned int              ll_sa_wrong;   /* statahead thread stopped for
 393                                                   * low hit ratio */
 394         unsigned int              ll_sa_total;   /* statahead thread started
 395                                                   * count */
 396         unsigned long long        ll_sa_blocked; /* ls count waiting for
 397                                                   * statahead */
 398         unsigned long long        ll_sa_cached;  /* ls count got in cache */
 399         unsigned long long        ll_sa_hit;     /* hit count */
 400         unsigned long long        ll_sa_miss;    /* miss count */
 401
 402         dev_t                     ll_sdev_orig; /* save s_dev before assign for
 403                                                  * clustred nfs */
 404         struct rmtacl_ctl_table   ll_rct;
 405         struct eacl_table         ll_et;
 406 };
 407
 408 #define LL_DEFAULT_MAX_RW_CHUNK      (32 * 1024 * 1024)
 409
 410 struct ll_ra_read {
 411         pgoff_t             lrr_start;
 412         pgoff_t             lrr_count;
 413         struct task_struct *lrr_reader;
 414         struct list_head    lrr_linkage;
 415 };
 416
 417 /*
 418  * per file-descriptor read-ahead data.
 419  */
 420 struct ll_readahead_state {
 421         spinlock_t      ras_lock;
 422         /*
 423          * index of the last page that read(2) needed and that wasn't in the
 424          * cache. Used by ras_update() to detect seeks.
 425          *
 426          * XXX nikita: if access seeks into cached region, Lustre doesn't see
 427          * this.
 428          */
 429         unsigned long   ras_last_readpage;
 430         /*
 431          * number of pages read after last read-ahead window reset. As window
 432          * is reset on each seek, this is effectively a number of consecutive
 433          * accesses. Maybe ->ras_accessed_in_window is better name.
 434          *
 435          * XXX nikita: window is also reset (by ras_update()) when Lustre
 436          * believes that memory pressure evicts read-ahead pages. In that
 437          * case, it probably doesn't make sense to expand window to
 438          * PTLRPC_MAX_BRW_PAGES on the third access.
 439          */
 440         unsigned long   ras_consecutive_pages;
 441         /*
 442          * number of read requests after the last read-ahead window reset
 443          * As window is reset on each seek, this is effectively the number
 444          * on consecutive read request and is used to trigger read-ahead.
 445          */
 446         unsigned long   ras_consecutive_requests;
 447         /*
 448          * Parameters of current read-ahead window. Handled by
 449          * ras_update(). On the initial access to the file or after a seek,
 450          * window is reset to 0. After 3 consecutive accesses, window is
 451          * expanded to PTLRPC_MAX_BRW_PAGES. Afterwards, window is enlarged by
 452          * PTLRPC_MAX_BRW_PAGES chunks up to ->ra_max_pages.
 453          */
 454         unsigned long   ras_window_start, ras_window_len;
 455         /*
 456          * Where next read-ahead should start at. This lies within read-ahead
 457          * window. Read-ahead window is read in pieces rather than at once
 458          * because: 1. lustre limits total number of pages under read-ahead by
 459          * ->ra_max_pages (see ll_ra_count_get()), 2. client cannot read pages
 460          * not covered by DLM lock.
 461          */
 462         unsigned long   ras_next_readahead;
 463         /*
 464          * Total number of ll_file_read requests issued, reads originating
 465          * due to mmap are not counted in this total.  This value is used to
 466          * trigger full file read-ahead after multiple reads to a small file.
 467          */
 468         unsigned long   ras_requests;
 469         /*
 470          * Page index with respect to the current request, these value
 471          * will not be accurate when dealing with reads issued via mmap.
 472          */
 473         unsigned long   ras_request_index;
 474         /*
 475          * list of struct ll_ra_read's one per read(2) call current in
 476          * progress against this file descriptor. Used by read-ahead code,
 477          * protected by ->ras_lock.
 478          */
 479         struct list_head ras_read_beads;
 480         /*
 481          * The following 3 items are used for detecting the stride I/O
 482          * mode.
 483          * In stride I/O mode,
 484          * ...............|-----data-----|****gap*****|--------|******|....
 485          *    offset      |-stride_pages-|-stride_gap-|
 486          * ras_stride_offset = offset;
 487          * ras_stride_length = stride_pages + stride_gap;
 488          * ras_stride_pages = stride_pages;
 489          * Note: all these three items are counted by pages.
 490          */
 491         unsigned long ras_stride_length;
 492         unsigned long ras_stride_pages;
 493         pgoff_t ras_stride_offset;
 494         /*
 495          * number of consecutive stride request count, and it is similar as
 496          * ras_consecutive_requests, but used for stride I/O mode.
 497          * Note: only more than 2 consecutive stride request are detected,
 498          * stride read-ahead will be enable
 499          */
 500         unsigned long ras_consecutive_stride_requests;
 501 };
 502
 503 struct ll_file_dir {
 504 };
 505
 506 extern cfs_mem_cache_t *ll_file_data_slab;
 507 struct lustre_handle;
 508 struct ll_file_data {
 509         struct ll_readahead_state fd_ras;
 510         int fd_omode;
 511         struct ccc_grouplock fd_grouplock;
 512         struct ll_file_dir fd_dir;
 513         __u32 fd_flags;
 514         struct file *fd_file;
 515 };
 516
 517 struct lov_stripe_md;
 518
 519 extern spinlock_t inode_lock;
 520
 521 extern struct proc_dir_entry *proc_lustre_fs_root;
 522
 523 static inline struct inode *ll_info2i(struct ll_inode_info *lli)
 524 {
 525         return &lli->lli_vfs_inode;
 526 }
 527
 528 struct it_cb_data {
 529         struct inode *icbd_parent;
 530         struct dentry **icbd_childp;
 531         obd_id hash;
 532 };
 533
 534 __u32 ll_i2suppgid(struct inode *i);
 535 void ll_i2gids(__u32 *suppgids, struct inode *i1,struct inode *i2);
 536
 537 #define LLAP_MAGIC 98764321
 538
 539 extern cfs_mem_cache_t *ll_async_page_slab;
 540 extern size_t ll_async_page_slab_size;
 541
 542 void ll_ra_read_in(struct file *f, struct ll_ra_read *rar);
 543 void ll_ra_read_ex(struct file *f, struct ll_ra_read *rar);
 544 struct ll_ra_read *ll_ra_read_get(struct file *f);
 545
 546 /* llite/lproc_llite.c */
 547 #ifdef LPROCFS
 548 int lprocfs_register_mountpoint(struct proc_dir_entry *parent,
 549                                 struct super_block *sb, char *osc, char *mdc);
 550 void lprocfs_unregister_mountpoint(struct ll_sb_info *sbi);
 551 void ll_stats_ops_tally(struct ll_sb_info *sbi, int op, int count);
 552 void lprocfs_llite_init_vars(struct lprocfs_static_vars *lvars);
 553 #else
 554 static inline int lprocfs_register_mountpoint(struct proc_dir_entry *parent,
 555                         struct super_block *sb, char *osc, char *mdc){return 0;}
 556 static inline void lprocfs_unregister_mountpoint(struct ll_sb_info *sbi) {}
 557 static void ll_stats_ops_tally(struct ll_sb_info *sbi, int op, int count) {}
 558 static void lprocfs_llite_init_vars(struct lprocfs_static_vars *lvars)
 559 {
 560         memset(lvars, 0, sizeof(*lvars));
 561 }
 562 #endif
 563
 564
 565 /* llite/dir.c */
 566 static inline void ll_put_page(struct page *page)
 567 {
 568         kunmap(page);
 569         page_cache_release(page);
 570 }
 571
 572 extern struct file_operations ll_dir_operations;
 573 extern struct inode_operations ll_dir_inode_operations;
 574 struct page *ll_get_dir_page(struct inode *dir, __u64 hash, int exact,
 575                              struct ll_dir_chain *chain);
 576 /* llite/namei.c */
 577 int ll_objects_destroy(struct ptlrpc_request *request,
 578                        struct inode *dir);
 579 struct inode *ll_iget(struct super_block *sb, ino_t hash,
 580                       struct lustre_md *lic);
 581 int ll_md_blocking_ast(struct ldlm_lock *, struct ldlm_lock_desc *,
 582                        void *data, int flag);
 583 #ifndef HAVE_VFS_INTENT_PATCHES
 584 struct lookup_intent *ll_convert_intent(struct open_intent *oit,
 585                                         int lookup_flags);
 586 #endif
 587 int ll_lookup_it_finish(struct ptlrpc_request *request,
 588                         struct lookup_intent *it, void *data);
 589 void ll_lookup_finish_locks(struct lookup_intent *it, struct dentry *dentry);
 590
 591 /* llite/rw.c */
 592 int ll_prepare_write(struct file *, struct page *, unsigned from, unsigned to);
 593 int ll_commit_write(struct file *, struct page *, unsigned from, unsigned to);
 594 int ll_writepage(struct page *page, struct writeback_control *wbc);
 595 void ll_removepage(struct page *page);
 596 int ll_readpage(struct file *file, struct page *page);
 597 void ll_readahead_init(struct inode *inode, struct ll_readahead_state *ras);
 598 void ll_truncate(struct inode *inode);
 599 int ll_file_punch(struct inode *, loff_t, int);
 600 ssize_t ll_file_lockless_io(struct file *, char *, size_t, loff_t *, int);
 601 void ll_clear_file_contended(struct inode*);
 602 int ll_sync_page_range(struct inode *, struct address_space *, loff_t, size_t);
 603 int ll_readahead(const struct lu_env *env, struct cl_io *io, struct ll_readahead_state *ras,
 604                  struct address_space *mapping, struct cl_page_list *queue, int flags);
 605
 606 /* llite/file.c */
 607 extern struct file_operations ll_file_operations;
 608 extern struct file_operations ll_file_operations_flock;
 609 extern struct file_operations ll_file_operations_noflock;
 610 extern struct inode_operations ll_file_inode_operations;
 611 extern int ll_inode_revalidate_it(struct dentry *, struct lookup_intent *);
 612 extern int ll_have_md_lock(struct inode *inode, __u64 bits);
 613 extern ldlm_mode_t ll_take_md_lock(struct inode *inode, __u64 bits,
 614                                    struct lustre_handle *lockh);
 615 int __ll_inode_revalidate_it(struct dentry *, struct lookup_intent *,  __u64 bits);
 616 int ll_revalidate_nd(struct dentry *dentry, struct nameidata *nd);
 617 int ll_file_open(struct inode *inode, struct file *file);
 618 int ll_file_release(struct inode *inode, struct file *file);
 619 int ll_glimpse_ioctl(struct ll_sb_info *sbi,
 620                      struct lov_stripe_md *lsm, lstat_t *st);
 621 void ll_ioepoch_open(struct ll_inode_info *lli, __u64 ioepoch);
 622 int ll_local_open(struct file *file,
 623                   struct lookup_intent *it, struct ll_file_data *fd,
 624                   struct obd_client_handle *och);
 625 int ll_release_openhandle(struct dentry *, struct lookup_intent *);
 626 int ll_md_close(struct obd_export *md_exp, struct inode *inode,
 627                 struct file *file);
 628 int ll_md_real_close(struct inode *inode, int flags);
 629 void ll_epoch_close(struct inode *inode, struct md_op_data *op_data,
 630                     struct obd_client_handle **och, unsigned long flags);
 631 int ll_sizeonmds_update(struct inode *inode, struct lustre_handle *fh,
 632                         __u64 ioepoch);
 633 int ll_inode_getattr(struct inode *inode, struct obdo *obdo);
 634 int ll_md_setattr(struct inode *inode, struct md_op_data *op_data,
 635                   struct md_open_data **mod);
 636 void ll_pack_inode2opdata(struct inode *inode, struct md_op_data *op_data,
 637                           struct lustre_handle *fh);
 638 extern void ll_rw_stats_tally(struct ll_sb_info *sbi, pid_t pid,
 639                               struct ll_file_data *file, loff_t pos,
 640                               size_t count, int rw);
 641 int ll_getattr_it(struct vfsmount *mnt, struct dentry *de,
 642                struct lookup_intent *it, struct kstat *stat);
 643 int ll_getattr(struct vfsmount *mnt, struct dentry *de, struct kstat *stat);
 644 struct ll_file_data *ll_file_data_get(void);
 645 int ll_inode_permission(struct inode *inode, int mask, struct nameidata *nd);
 646 int ll_lov_setstripe_ea_info(struct inode *inode, struct file *file,
 647                              int flags, struct lov_user_md *lum,
 648                              int lum_size);
 649 int ll_lov_getstripe_ea_info(struct inode *inode, const char *filename,
 650                              struct lov_mds_md **lmm, int *lmm_size,
 651                              struct ptlrpc_request **request);
 652 int ll_dir_setstripe(struct inode *inode, struct lov_user_md *lump,
 653                      int set_default);
 654 int ll_dir_getstripe(struct inode *inode, struct lov_mds_md **lmm,
 655                      int *lmm_size, struct ptlrpc_request **request);
 656 int ll_fsync(struct file *file, struct dentry *dentry, int data);
 657 int ll_fiemap(struct inode *inode, struct ll_user_fiemap *fiemap,
 658               int num_bytes);
 659 int ll_merge_lvb(struct inode *inode);
 660 int ll_get_grouplock(struct inode *inode, struct file *file, unsigned long arg);
 661 int ll_put_grouplock(struct inode *inode, struct file *file, unsigned long arg);
 662 int ll_fid2path(struct obd_export *exp, void *arg);
 663
 664 /* llite/dcache.c */
 665 /* llite/namei.c */
 666 /**
 667  * protect race ll_find_aliases vs ll_revalidate_it vs ll_unhash_aliases
 668  */
 669 extern spinlock_t ll_lookup_lock;
 670 extern struct dentry_operations ll_d_ops;
 671 void ll_intent_drop_lock(struct lookup_intent *);
 672 void ll_intent_release(struct lookup_intent *);
 673 int ll_drop_dentry(struct dentry *dentry);
 674 extern void ll_set_dd(struct dentry *de);
 675 int ll_drop_dentry(struct dentry *dentry);
 676 void ll_unhash_aliases(struct inode *);
 677 void ll_frob_intent(struct lookup_intent **itp, struct lookup_intent *deft);
 678 void ll_lookup_finish_locks(struct lookup_intent *it, struct dentry *dentry);
 679 int ll_dcompare(struct dentry *parent, struct qstr *d_name, struct qstr *name);
 680 int ll_revalidate_it_finish(struct ptlrpc_request *request,
 681                             struct lookup_intent *it, struct dentry *de);
 682
 683 /* llite/llite_lib.c */
 684 extern struct super_operations lustre_super_operations;
 685 void ll_dump_inode(struct inode *inode);
 686 char *ll_read_opt(const char *opt, char *data);
 687 void ll_lli_init(struct ll_inode_info *lli);
 688 int ll_fill_super(struct super_block *sb);
 689 void ll_put_super(struct super_block *sb);
 690 void ll_kill_super(struct super_block *sb);
 691 int ll_shrink_cache(int nr_to_scan, gfp_t gfp_mask);
 692 struct inode *ll_inode_from_lock(struct ldlm_lock *lock);
 693 void ll_clear_inode(struct inode *inode);
 694 int ll_setattr_raw(struct inode *inode, struct iattr *attr);
 695 int ll_setattr(struct dentry *de, struct iattr *attr);
 696 #ifndef HAVE_STATFS_DENTRY_PARAM
 697 int ll_statfs(struct super_block *sb, struct kstatfs *sfs);
 698 #else
 699 int ll_statfs(struct dentry *de, struct kstatfs *sfs);
 700 #endif
 701 int ll_statfs_internal(struct super_block *sb, struct obd_statfs *osfs,
 702                        __u64 max_age, __u32 flags);
 703 void ll_update_inode(struct inode *inode, struct lustre_md *md);
 704 void ll_read_inode2(struct inode *inode, void *opaque);
 705 void ll_delete_inode(struct inode *inode);
 706 int ll_iocontrol(struct inode *inode, struct file *file,
 707                  unsigned int cmd, unsigned long arg);
 708 int ll_flush_ctx(struct inode *inode);
 709 #ifdef HAVE_UMOUNTBEGIN_VFSMOUNT
 710 void ll_umount_begin(struct vfsmount *vfsmnt, int flags);
 711 #else
 712 void ll_umount_begin(struct super_block *sb);
 713 #endif
 714 int ll_remount_fs(struct super_block *sb, int *flags, char *data);
 715 int ll_show_options(struct seq_file *seq, struct vfsmount *vfs);
 716 int ll_prep_inode(struct inode **inode, struct ptlrpc_request *req,
 717                   struct super_block *);
 718 void lustre_dump_dentry(struct dentry *, int recur);
 719 void lustre_dump_inode(struct inode *);
 720 int ll_obd_statfs(struct inode *inode, void *arg);
 721 int ll_get_max_mdsize(struct ll_sb_info *sbi, int *max_mdsize);
 722 int ll_process_config(struct lustre_cfg *lcfg);
 723 struct md_op_data *ll_prep_md_op_data(struct md_op_data *op_data,
 724                                       struct inode *i1, struct inode *i2,
 725                                       const char *name, int namelen,
 726                                       int mode, __u32 opc, void *data);
 727 void ll_finish_md_op_data(struct md_op_data *op_data);
 728
 729 /* llite/llite_nfs.c */
 730 extern struct export_operations lustre_export_operations;
 731 __u32 get_uuid2int(const char *name, int len);
 732 struct dentry *ll_fh_to_dentry(struct super_block *sb, __u32 *data, int len,
 733                                int fhtype, int parent);
 734 int ll_dentry_to_fh(struct dentry *, __u32 *datap, int *lenp, int need_parent);
 735
 736 /* llite/special.c */
 737 extern struct inode_operations ll_special_inode_operations;
 738 extern struct file_operations ll_special_chr_inode_fops;
 739 extern struct file_operations ll_special_chr_file_fops;
 740 extern struct file_operations ll_special_blk_inode_fops;
 741 extern struct file_operations ll_special_fifo_inode_fops;
 742 extern struct file_operations ll_special_fifo_file_fops;
 743 extern struct file_operations ll_special_sock_inode_fops;
 744
 745 /* llite/symlink.c */
 746 extern struct inode_operations ll_fast_symlink_inode_operations;
 747
 748 /* llite/llite_close.c */
 749 struct ll_close_queue {
 750         spinlock_t              lcq_lock;
 751         struct list_head        lcq_head;
 752         wait_queue_head_t       lcq_waitq;
 753         struct completion       lcq_comp;
 754         atomic_t                lcq_stop;
 755 };
 756
 757 struct vvp_thread_info {
 758         struct ost_lvb       vti_lvb;
 759         struct cl_2queue     vti_queue;
 760         struct iovec         vti_local_iov;
 761         struct ccc_io_args   vti_args;
 762         struct ra_io_arg     vti_ria;
 763         struct kiocb         vti_kiocb;
 764 };
 765
 766 struct ccc_object *cl_inode2ccc(struct inode *inode);
 767
 768 static inline struct vvp_thread_info *vvp_env_info(const struct lu_env *env)
 769 {
 770         extern struct lu_context_key vvp_key;
 771         struct vvp_thread_info      *info;
 772
 773         info = lu_context_key_get(&env->le_ctx, &vvp_key);
 774         LASSERT(info != NULL);
 775         return info;
 776 }
 777
 778 void vvp_write_pending (struct ccc_object *club, struct ccc_page *page);
 779 void vvp_write_complete(struct ccc_object *club, struct ccc_page *page);
 780
 781 struct vvp_io {
 782         union {
 783                 struct {
 784                         read_actor_t      cui_actor;
 785                         void             *cui_target;
 786                 } read;
 787                 struct vvp_fault_io {
 788                         /**
 789                          * Inode modification time that is checked across DLM
 790                          * lock request.
 791                          */
 792                         time_t                 ft_mtime;
 793                         struct vm_area_struct *ft_vma;
 794                         /**
 795                          * Virtual address at which fault occurred.
 796                          */
 797                         unsigned long          ft_address;
 798                         /**
 799                          * Fault type, as to be supplied to filemap_nopage().
 800                          */
 801                         int                   *ft_type;
 802                 } fault;
 803         } u;
 804         /**
 805          * Read-ahead state used by read and page-fault IO contexts.
 806          */
 807         struct ll_ra_read    cui_bead;
 808         /**
 809          * Set when cui_bead has been initialized.
 810          */
 811         int                  cui_ra_window_set;
 812         /**
 813          * If IO was created directly in low level method like
 814          * ->prepare_write(), this field stores the number of method calls
 815          * that constitute this IO. This field is decremented by ll_cl_fini(),
 816          * and cl_io is destroyed, when it reaches 0. When oneshot IO
 817          * completes, this fields is set to -1.
 818          */
 819
 820         int                  cui_oneshot;
 821         /**
 822          * Partially truncated page, that vvp_io_trunc_start() keeps locked
 823          * across truncate.
 824          */
 825         struct cl_page      *cui_partpage;
 826 };
 827
 828 struct vvp_session {
 829         struct vvp_io vs_ios;
 830 };
 831
 832 static inline struct vvp_session *vvp_env_session(const struct lu_env *env)
 833 {
 834         extern struct lu_context_key vvp_session_key;
 835         struct vvp_session *ses;
 836
 837         ses = lu_context_key_get(env->le_ses, &vvp_session_key);
 838         LASSERT(ses != NULL);
 839         return ses;
 840 }
 841
 842 static inline struct vvp_io *vvp_env_io(const struct lu_env *env)
 843 {
 844         return &vvp_env_session(env)->vs_ios;
 845 }
 846
 847 void ll_queue_done_writing(struct inode *inode, unsigned long flags);
 848 void ll_close_thread_shutdown(struct ll_close_queue *lcq);
 849 int ll_close_thread_start(struct ll_close_queue **lcq_ret);
 850
 851 /* llite/llite_mmap.c */
 852 typedef struct rb_root  rb_root_t;
 853 typedef struct rb_node  rb_node_t;
 854
 855 struct ll_lock_tree_node;
 856 struct ll_lock_tree {
 857         rb_root_t                       lt_root;
 858         struct list_head                lt_locked_list;
 859         struct ll_file_data             *lt_fd;
 860 };
 861
 862 int ll_teardown_mmaps(struct address_space *mapping, __u64 first, __u64 last);
 863 int ll_file_mmap(struct file * file, struct vm_area_struct * vma);
 864 struct ll_lock_tree_node * ll_node_from_inode(struct inode *inode, __u64 start,
 865                                               __u64 end, ldlm_mode_t mode);
 866 void policy_from_vma(ldlm_policy_data_t *policy,
 867                 struct vm_area_struct *vma, unsigned long addr, size_t count);
 868 struct vm_area_struct *our_vma(unsigned long addr, size_t count);
 869
 870 #define    ll_s2sbi(sb)        (s2lsi(sb)->lsi_llsbi)
 871
 872 static inline __u64 ll_ts2u64(struct timespec *time)
 873 {
 874         __u64 t = time->tv_sec;
 875         return t;
 876 }
 877
 878 /* don't need an addref as the sb_info should be holding one */
 879 static inline struct obd_export *ll_s2dtexp(struct super_block *sb)
 880 {
 881         return ll_s2sbi(sb)->ll_dt_exp;
 882 }
 883
 884 /* don't need an addref as the sb_info should be holding one */
 885 static inline struct obd_export *ll_s2mdexp(struct super_block *sb)
 886 {
 887         return ll_s2sbi(sb)->ll_md_exp;
 888 }
 889
 890 static inline struct client_obd *sbi2mdc(struct ll_sb_info *sbi)
 891 {
 892         struct obd_device *obd = sbi->ll_md_exp->exp_obd;
 893         if (obd == NULL)
 894                 LBUG();
 895         return &obd->u.cli;
 896 }
 897
 898 // FIXME: replace the name of this with LL_SB to conform to kernel stuff
 899 static inline struct ll_sb_info *ll_i2sbi(struct inode *inode)
 900 {
 901         return ll_s2sbi(inode->i_sb);
 902 }
 903
 904 static inline struct obd_export *ll_i2dtexp(struct inode *inode)
 905 {
 906         return ll_s2dtexp(inode->i_sb);
 907 }
 908
 909 static inline struct obd_export *ll_i2mdexp(struct inode *inode)
 910 {
 911         return ll_s2mdexp(inode->i_sb);
 912 }
 913
 914 static inline struct lu_fid *ll_inode2fid(struct inode *inode)
 915 {
 916         struct lu_fid *fid;
 917         LASSERT(inode != NULL);
 918         fid = &ll_i2info(inode)->lli_fid;
 919         LASSERT(fid_is_igif(fid) || fid_ver(fid) == 0);
 920         return fid;
 921 }
 922
 923 static inline int ll_mds_max_easize(struct super_block *sb)
 924 {
 925         return sbi2mdc(ll_s2sbi(sb))->cl_max_mds_easize;
 926 }
 927
 928 static inline __u64 ll_file_maxbytes(struct inode *inode)
 929 {
 930         return ll_i2info(inode)->lli_maxbytes;
 931 }
 932
 933 /* llite/xattr.c */
 934 int ll_setxattr(struct dentry *dentry, const char *name,
 935                 const void *value, size_t size, int flags);
 936 ssize_t ll_getxattr(struct dentry *dentry, const char *name,
 937                     void *buffer, size_t size);
 938 ssize_t ll_listxattr(struct dentry *dentry, char *buffer, size_t size);
 939 int ll_removexattr(struct dentry *dentry, const char *name);
 940
 941 /* llite/remote_perm.c */
 942 extern cfs_mem_cache_t *ll_remote_perm_cachep;
 943 extern cfs_mem_cache_t *ll_rmtperm_hash_cachep;
 944
 945 struct hlist_head *alloc_rmtperm_hash(void);
 946 void free_rmtperm_hash(struct hlist_head *hash);
 947 int ll_update_remote_perm(struct inode *inode, struct mdt_remote_perm *perm);
 948 int lustre_check_remote_perm(struct inode *inode, int mask);
 949
 950 /* llite/llite_fid.c */
 951 ino_t ll_fid_build_ino(struct ll_sb_info *sbi, struct lu_fid *fid);
 952 __u32 ll_fid_build_gen(struct ll_sb_info *sbi, struct lu_fid *fid);
 953
 954 /* llite/llite_capa.c */
 955 extern cfs_timer_t ll_capa_timer;
 956
 957 int ll_capa_thread_start(void);
 958 void ll_capa_thread_stop(void);
 959 void ll_capa_timer_callback(unsigned long unused);
 960
 961 struct obd_capa *ll_add_capa(struct inode *inode, struct obd_capa *ocapa);
 962 int ll_update_capa(struct obd_capa *ocapa, struct lustre_capa *capa);
 963
 964 void ll_capa_open(struct inode *inode);
 965 void ll_capa_close(struct inode *inode);
 966
 967 struct obd_capa *ll_mdscapa_get(struct inode *inode);
 968 struct obd_capa *ll_osscapa_get(struct inode *inode, __u64 opc);
 969
 970 void ll_truncate_free_capa(struct obd_capa *ocapa);
 971 void ll_clear_inode_capas(struct inode *inode);
 972 void ll_print_capa_stat(struct ll_sb_info *sbi);
 973
 974 /* llite/llite_cl.c */
 975 extern struct lu_device_type vvp_device_type;
 976
 977 /**
 978  * Common IO arguments for various VFS I/O interfaces.
 979  */
 980
 981 int cl_sb_init(struct super_block *sb);
 982 int cl_sb_fini(struct super_block *sb);
 983 int cl_inode_init(struct inode *inode, struct lustre_md *md);
 984 void cl_inode_fini(struct inode *inode);
 985
 986 enum cl_lock_mode  vvp_mode_from_vma(struct vm_area_struct *vma);
 987 void ll_io_init(struct cl_io *io, const struct file *file, int write);
 988
 989 void ras_update(struct ll_sb_info *sbi, struct inode *inode,
 990                 struct ll_readahead_state *ras, unsigned long index,
 991                 unsigned hit);
 992 void ll_ra_count_put(struct ll_sb_info *sbi, unsigned long len);
 993 int ll_is_file_contended(struct file *file);
 994 void ll_ra_stats_inc(struct address_space *mapping, enum ra_stat which);
 995
 996 /* llite/llite_rmtacl.c */
 997 #ifdef CONFIG_FS_POSIX_ACL
 998 obd_valid rce_ops2valid(int ops);
 999 struct rmtacl_ctl_entry *rct_search(struct rmtacl_ctl_table *rct, pid_t key);
1000 int rct_add(struct rmtacl_ctl_table *rct, pid_t key, int ops);
1001 int rct_del(struct rmtacl_ctl_table *rct, pid_t key);
1002 void rct_init(struct rmtacl_ctl_table *rct);
1003 void rct_fini(struct rmtacl_ctl_table *rct);
1004
1005 void ee_free(struct eacl_entry *ee);
1006 int ee_add(struct eacl_table *et, pid_t key, struct lu_fid *fid, int type,
1007            ext_acl_xattr_header *header);
1008 struct eacl_entry *et_search_del(struct eacl_table *et, pid_t key,
1009                                  struct lu_fid *fid, int type);
1010 void et_search_free(struct eacl_table *et, pid_t key);
1011 void et_init(struct eacl_table *et);
1012 void et_fini(struct eacl_table *et);
1013 #endif
1014
1015 /* statahead.c */
1016
1017 #define LL_SA_RPC_MIN   2
1018 #define LL_SA_RPC_DEF   32
1019 #define LL_SA_RPC_MAX   8192
1020
1021 /* per inode struct, for dir only */
1022 struct ll_statahead_info {
1023         struct inode           *sai_inode;
1024         unsigned int            sai_generation; /* generation for statahead */
1025         atomic_t                sai_refcount;   /* when access this struct, hold
1026                                                  * refcount */
1027         unsigned int            sai_sent;       /* stat requests sent count */
1028         unsigned int            sai_replied;    /* stat requests which received
1029                                                  * reply */
1030         unsigned int            sai_max;        /* max ahead of lookup */
1031         unsigned int            sai_index;      /* index of statahead entry */
1032         unsigned int            sai_index_next; /* index for the next statahead
1033                                                  * entry to be stated */
1034         unsigned int            sai_hit;        /* hit count */
1035         unsigned int            sai_miss;       /* miss count:
1036                                                  * for "ls -al" case, it includes
1037                                                  * hidden dentry miss;
1038                                                  * for "ls -l" case, it does not
1039                                                  * include hidden dentry miss.
1040                                                  * "sai_miss_hidden" is used for
1041                                                  * the later case.
1042                                                  */
1043         unsigned int            sai_consecutive_miss; /* consecutive miss */
1044         unsigned int            sai_miss_hidden;/* "ls -al", but first dentry
1045                                                  * is not a hidden one */
1046         unsigned int            sai_skip_hidden;/* skipped hidden dentry count */
1047         unsigned int            sai_ls_all:1;   /* "ls -al", do stat-ahead for
1048                                                  * hidden entries */
1049         cfs_waitq_t             sai_waitq;      /* stat-ahead wait queue */
1050         struct ptlrpc_thread    sai_thread;     /* stat-ahead thread */
1051         struct list_head        sai_entries_sent;     /* entries sent out */
1052         struct list_head        sai_entries_received; /* entries returned */
1053         struct list_head        sai_entries_stated;   /* entries stated */
1054 };
1055
1056 int do_statahead_enter(struct inode *dir, struct dentry **dentry, int lookup);
1057 void ll_statahead_exit(struct inode *dir, struct dentry *dentry, int result);
1058 void ll_stop_statahead(struct inode *inode, void *key);
1059
1060 static inline
1061 void ll_statahead_mark(struct inode *dir, struct dentry *dentry)
1062 {
1063         struct ll_inode_info  *lli;
1064         struct ll_dentry_data *ldd = ll_d2d(dentry);
1065
1066         /* dentry has been move to other directory, no need mark */
1067         if (unlikely(dir != dentry->d_parent->d_inode))
1068                 return;
1069
1070         lli = ll_i2info(dir);
1071         /* not the same process, don't mark */
1072         if (lli->lli_opendir_pid != cfs_curproc_pid())
1073                 return;
1074
1075         spin_lock(&lli->lli_lock);
1076         if (likely(lli->lli_sai != NULL && ldd != NULL))
1077                 ldd->lld_sa_generation = lli->lli_sai->sai_generation;
1078         spin_unlock(&lli->lli_lock);
1079 }
1080
1081 static inline
1082 int ll_statahead_enter(struct inode *dir, struct dentry **dentryp, int lookup)
1083 {
1084         struct ll_inode_info  *lli;
1085         struct ll_dentry_data *ldd = ll_d2d(*dentryp);
1086
1087         if (unlikely(dir == NULL))
1088                 return -EAGAIN;
1089
1090         if (ll_i2sbi(dir)->ll_sa_max == 0)
1091                 return -ENOTSUPP;
1092
1093         lli = ll_i2info(dir);
1094         /* not the same process, don't statahead */
1095         if (lli->lli_opendir_pid != cfs_curproc_pid())
1096                 return -EAGAIN;
1097
1098         /*
1099          * When "ls" a dentry, the system trigger more than once "revalidate" or
1100          * "lookup", for "getattr", for "getxattr", and maybe for others.
1101          * Under patchless client mode, the operation intent is not accurate,
1102          * it maybe misguide the statahead thread. For example:
1103          * The "revalidate" call for "getattr" and "getxattr" of a dentry maybe
1104          * have the same operation intent -- "IT_GETATTR".
1105          * In fact, one dentry should has only one chance to interact with the
1106          * statahead thread, otherwise the statahead windows will be confused.
1107          * The solution is as following:
1108          * Assign "lld_sa_generation" with "sai_generation" when a dentry
1109          * "IT_GETATTR" for the first time, and the subsequent "IT_GETATTR"
1110          * will bypass interacting with statahead thread for checking:
1111          * "lld_sa_generation == lli_sai->sai_generation"
1112          */
1113         if (ldd && lli->lli_sai &&
1114             ldd->lld_sa_generation == lli->lli_sai->sai_generation)
1115                 return -EAGAIN;
1116
1117         return do_statahead_enter(dir, dentryp, lookup);
1118 }
1119
1120 static void inline ll_dops_init(struct dentry *de, int block)
1121 {
1122         struct ll_dentry_data *lld = ll_d2d(de);
1123
1124         if (lld == NULL && block != 0) {
1125                 ll_set_dd(de);
1126                 lld = ll_d2d(de);
1127         }
1128
1129         if (lld != NULL)
1130                 lld->lld_sa_generation = 0;
1131
1132         de->d_op = &ll_d_ops;
1133 }
1134
1135 /* llite ioctl register support rountine */
1136 #ifdef __KERNEL__
1137 enum llioc_iter {
1138         LLIOC_CONT = 0,
1139         LLIOC_STOP
1140 };
1141
1142 #define LLIOC_MAX_CMD           256
1143
1144 /*
1145  * Rules to write a callback function:
1146  *
1147  * Parameters:
1148  *  @magic: Dynamic ioctl call routine will feed this vaule with the pointer
1149  *      returned to ll_iocontrol_register.  Callback functions should use this
1150  *      data to check the potential collasion of ioctl cmd. If collasion is
1151  *      found, callback function should return LLIOC_CONT.
1152  *  @rcp: The result of ioctl command.
1153  *
1154  *  Return values:
1155  *      If @magic matches the pointer returned by ll_iocontrol_data, the
1156  *      callback should return LLIOC_STOP; return LLIOC_STOP otherwise.
1157  */
1158 typedef enum llioc_iter (*llioc_callback_t)(struct inode *inode,
1159                 struct file *file, unsigned int cmd, unsigned long arg,
1160                 void *magic, int *rcp);
1161
1162 enum llioc_iter ll_iocontrol_call(struct inode *inode, struct file *file,
1163                 unsigned int cmd, unsigned long arg, int *rcp);
1164
1165 /* export functions */
1166 /* Register ioctl block dynamatically for a regular file.
1167  *
1168  * @cmd: the array of ioctl command set
1169  * @count: number of commands in the @cmd
1170  * @cb: callback function, it will be called if an ioctl command is found to
1171  *      belong to the command list @cmd.
1172  *
1173  * Return vaule:
1174  *      A magic pointer will be returned if success;
1175  *      otherwise, NULL will be returned.
1176  * */
1177 void *ll_iocontrol_register(llioc_callback_t cb, int count, unsigned int *cmd);
1178 void ll_iocontrol_unregister(void *magic);
1179
1180 #endif
1181
1182 /* lclient compat stuff */
1183 #define cl_inode_info ll_inode_info
1184 #define cl_i2info(info) ll_i2info(info)
1185 #define cl_inode_mode(inode) ((inode)->i_mode)
1186 #define cl_i2sbi ll_i2sbi
1187 #define cl_isize_read(inode) i_size_read(inode)
1188 #define cl_isize_write(inode,kms) i_size_write(inode, kms)
1189 #define cl_isize_write_nolock(inode,kms) do {(inode)->i_size=(kms);}while(0)
1190
1191 static inline void cl_isize_lock(struct inode *inode, int lsmlock)
1192 {
1193         ll_inode_size_lock(inode, lsmlock);
1194 }
1195
1196 static inline void cl_isize_unlock(struct inode *inode, int lsmlock)
1197 {
1198         ll_inode_size_unlock(inode, lsmlock);
1199 }
1200
1201 static inline int cl_merge_lvb(struct inode *inode)
1202 {
1203         return ll_merge_lvb(inode);
1204 }
1205
1206 #define cl_inode_atime(inode) LTIME_S((inode)->i_atime)
1207 #define cl_inode_ctime(inode) LTIME_S((inode)->i_ctime)
1208 #define cl_inode_mtime(inode) LTIME_S((inode)->i_mtime)
1209
1210 struct obd_capa *cl_capa_lookup(struct inode *inode, enum cl_req_type crt);
1211
1212 /** direct write pages */
1213 struct ll_dio_pages {
1214         /** page array to be written. we don't support
1215          * partial pages except the last one. */
1216         struct page **ldp_pages;
1217         /* offset of each page */
1218         loff_t       *ldp_offsets;
1219         /** if ldp_offsets is NULL, it means a sequential
1220          * pages to be written, then this is the file offset
1221          * of the * first page. */
1222         loff_t        ldp_start_offset;
1223         /** how many bytes are to be written. */
1224         size_t        ldp_size;
1225         /** # of pages in the array. */
1226         int           ldp_nr;
1227 };
1228
1229 extern ssize_t ll_direct_rw_pages(const struct lu_env *env, struct cl_io *io,
1230                                   int rw, struct inode *inode,
1231                                   struct ll_dio_pages *pv);
1232
1233 static inline int ll_file_nolock(const struct file *file)
1234 {
1235         struct ll_file_data *fd = LUSTRE_FPRIVATE(file);
1236         struct inode *inode = file->f_dentry->d_inode;
1237
1238         LASSERT(fd != NULL);
1239         return ((fd->fd_flags & LL_FILE_IGNORE_LOCK) ||
1240                 (ll_i2sbi(inode)->ll_flags & LL_SBI_NOLCK));
1241 }
1242 #endif /* LLITE_INTERNAL_H */