staging: lustre: lustre: add all missing indentifier names

void lprocfs_stats_collect(struct lprocfs_stats *stats, int idx,

			   struct lprocfs_counter *cnt);

int lprocfs_single_release(struct inode *, struct file *);

int lprocfs_seq_release(struct inode *, struct file *);

int lprocfs_single_release(struct inode *inode, struct file *file);

int lprocfs_seq_release(struct inode *inode, struct file *file);

/* write the name##_seq_show function, call LPROC_SEQ_FOPS_RO for read-only

 * proc entries; otherwise, you will define name##_seq_write function also for

	return atomic_read(&ns->ns_bref) == 0;

}

void ldlm_namespace_move_to_active_locked(struct ldlm_namespace *,

					  enum ldlm_side);

void ldlm_namespace_move_to_inactive_locked(struct ldlm_namespace *,

					    enum ldlm_side);

struct ldlm_namespace *ldlm_namespace_first_locked(enum ldlm_side);

void ldlm_namespace_move_to_active_locked(struct ldlm_namespace *ns,

					  enum ldlm_side client);

void ldlm_namespace_move_to_inactive_locked(struct ldlm_namespace *ns,

					    enum ldlm_side client);

struct ldlm_namespace *ldlm_namespace_first_locked(enum ldlm_side client);

/* ldlm_request.c */

/* Cancel lru flag, it indicates we cancel aged locks. */

int ldlm_fill_lvb(struct ldlm_lock *lock, struct req_capsule *pill,

		  enum req_location loc, void *data, int size);

struct ldlm_lock *

ldlm_lock_create(struct ldlm_namespace *ns, const struct ldlm_res_id *,

ldlm_lock_create(struct ldlm_namespace *ns, const struct ldlm_res_id *id,

		 enum ldlm_type type, enum ldlm_mode mode,

		 const struct ldlm_callback_suite *cbs,

		 void *data, __u32 lvb_len, enum lvb_type lvb_type);

enum ldlm_error ldlm_lock_enqueue(struct ldlm_namespace *, struct ldlm_lock **,

				  void *cookie, __u64 *flags);

void ldlm_lock_addref_internal(struct ldlm_lock *, enum ldlm_mode mode);

void ldlm_lock_addref_internal_nolock(struct ldlm_lock *, enum ldlm_mode mode);

void ldlm_lock_decref_internal(struct ldlm_lock *, enum ldlm_mode mode);

void ldlm_lock_decref_internal_nolock(struct ldlm_lock *, enum ldlm_mode mode);

enum ldlm_error ldlm_lock_enqueue(struct ldlm_namespace *ns,

				  struct ldlm_lock **lock, void *cookie,

				  __u64 *flags);

void ldlm_lock_addref_internal(struct ldlm_lock *lock, enum ldlm_mode mode);

void ldlm_lock_addref_internal_nolock(struct ldlm_lock *lock,

				      enum ldlm_mode mode);

void ldlm_lock_decref_internal(struct ldlm_lock *lock, enum ldlm_mode mode);

void ldlm_lock_decref_internal_nolock(struct ldlm_lock *lock,

				      enum ldlm_mode mode);

int ldlm_run_ast_work(struct ldlm_namespace *ns, struct list_head *rpc_list,

		      enum ldlm_desc_ast_t ast_type);

int ldlm_lock_remove_from_lru_check(struct ldlm_lock *lock, time_t last_use);

struct inode *ll_iget(struct super_block *sb, ino_t hash,

		      struct lustre_md *lic);

int ll_test_inode_by_fid(struct inode *inode, void *opaque);

int ll_md_blocking_ast(struct ldlm_lock *, struct ldlm_lock_desc *,

int ll_md_blocking_ast(struct ldlm_lock *lock, struct ldlm_lock_desc *desc,

		       void *data, int flag);

struct dentry *ll_splice_alias(struct inode *inode, struct dentry *de);

void ll_update_times(struct ptlrpc_request *request, struct inode *inode);

/* llite/rw.c */

int ll_writepage(struct page *page, struct writeback_control *wbc);

int ll_writepages(struct address_space *, struct writeback_control *wbc);

int ll_writepages(struct address_space *mapping, struct writeback_control *wbc);

int ll_readpage(struct file *file, struct page *page);

void ll_readahead_init(struct inode *inode, struct ll_readahead_state *ras);

int vvp_io_write_commit(const struct lu_env *env, struct cl_io *io);

			       enum ldlm_mode mode);

int ll_file_open(struct inode *inode, struct file *file);

int ll_file_release(struct inode *inode, struct file *file);

int ll_release_openhandle(struct inode *, struct lookup_intent *);

int ll_release_openhandle(struct inode *inode, struct lookup_intent *it);

int ll_md_real_close(struct inode *inode, fmode_t fmode);

int ll_getattr(const struct path *path, struct kstat *stat,

	       u32 request_mask, unsigned int flags);

/* llite/dcache.c */

extern const struct dentry_operations ll_d_ops;

void ll_intent_drop_lock(struct lookup_intent *);

void ll_intent_release(struct lookup_intent *);

void ll_invalidate_aliases(struct inode *);

void ll_intent_drop_lock(struct lookup_intent *it);

void ll_intent_release(struct lookup_intent *it);

void ll_invalidate_aliases(struct inode *inode);

void ll_lookup_finish_locks(struct lookup_intent *it, struct inode *inode);

int ll_revalidate_it_finish(struct ptlrpc_request *request,

			    struct lookup_intent *it, struct inode *inode);

int ll_show_options(struct seq_file *seq, struct dentry *dentry);

void ll_dirty_page_discard_warn(struct page *page, int ioret);

int ll_prep_inode(struct inode **inode, struct ptlrpc_request *req,

		  struct super_block *, struct lookup_intent *);

		  struct super_block *sb, struct lookup_intent *it);

int ll_obd_statfs(struct inode *inode, void __user *arg);

int ll_get_max_mdsize(struct ll_sb_info *sbi, int *max_mdsize);

int ll_get_default_mdsize(struct ll_sb_info *sbi, int *default_mdsize);

static int lmv_set_mdc_active(struct lmv_obd *lmv, const struct obd_uuid *uuid,

			      int activate)

{

	struct lmv_tgt_desc    *uninitialized_var(tgt);

	struct lmv_tgt_desc *tgt = NULL;

	struct obd_device      *obd;

	u32		     i;

	int		     rc = 0;

void ptlrpc_set_add_new_req(struct ptlrpcd_ctl *pc,

			    struct ptlrpc_request *req);

int ptlrpc_expired_set(void *data);

int ptlrpc_set_next_timeout(struct ptlrpc_request_set *);

int ptlrpc_set_next_timeout(struct ptlrpc_request_set *set);

void ptlrpc_resend_req(struct ptlrpc_request *request);

void ptlrpc_set_bulk_mbits(struct ptlrpc_request *req);

void ptlrpc_assign_next_xid_nolock(struct ptlrpc_request *req);

int ptlrpc_init_portals(void);

void ptlrpc_exit_portals(void);

void ptlrpc_request_handle_notconn(struct ptlrpc_request *);

void ptlrpc_request_handle_notconn(struct ptlrpc_request *req);

void lustre_assert_wire_constants(void);

int ptlrpc_import_in_recovery(struct obd_import *imp);

int ptlrpc_set_import_discon(struct obd_import *imp, __u32 conn_cnt);