staging: lustre: delete params_tree.h

#include "libcfs_hash.h"

#include "libcfs_heap.h"

#include "libcfs_fail.h"

#include "params_tree.h"

#include "libcfs_crypto.h"

/* container_of depends on "likely" which is defined in libcfs_private.h */

/*

 * GPL HEADER START

 *

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 only,

 * as published by the Free Software Foundation.

 *

 * This program is distributed in the hope that it will be useful, but

 * WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * General Public License version 2 for more details (a copy is included

 * in the LICENSE file that accompanied this code).

 *

 * You should have received a copy of the GNU General Public License

 * version 2 along with this program; If not, see

 * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf

 *

 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 *

 * GPL HEADER END

 */

/*

 * Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.

 * Use is subject to license terms.

 *

 * Copyright (c) 2012, Intel Corporation.

 */

/*

 * This file is part of Lustre, http://www.lustre.org/

 * Lustre is a trademark of Sun Microsystems, Inc.

 *

 * API and structure definitions for params_tree.

 *

 * Author: LiuYing <emoly.liu@oracle.com>

 */

#ifndef __PARAMS_TREE_H__

#define __PARAMS_TREE_H__

#include "libcfs.h"

#undef LPROCFS

#if  defined(CONFIG_PROC_FS)

# define LPROCFS

#endif

#ifdef LPROCFS

typedef struct file			     cfs_param_file_t;

typedef struct inode			    cfs_inode_t;

typedef struct proc_inode		       cfs_proc_inode_t;

typedef struct seq_file			 cfs_seq_file_t;

typedef struct seq_operations		   cfs_seq_ops_t;

typedef struct file_operations		  cfs_param_file_ops_t;

typedef struct proc_dir_entry		   cfs_param_dentry_t;

typedef struct poll_table_struct		cfs_poll_table_t;

#define CFS_PARAM_MODULE			THIS_MODULE

#define cfs_file_private(file)		  (file->private_data)

#define cfs_dentry_data(dentry)		 (dentry->data)

#define cfs_proc_inode_pde(proc_inode)	  (proc_inode->pde)

#define cfs_proc_inode(proc_inode)	      (proc_inode->vfs_inode)

#define cfs_seq_read_common		     seq_read

#define cfs_seq_lseek_common		    seq_lseek

#define cfs_seq_private(seq)		    (seq->private)

#define cfs_seq_printf(seq, format, ...)	seq_printf(seq, format,  \

							   ## __VA_ARGS__)

#define cfs_seq_release(inode, file)	    seq_release(inode, file)

#define cfs_seq_puts(seq, s)		    seq_puts(seq, s)

#define cfs_seq_putc(seq, s)		    seq_putc(seq, s)

#define cfs_seq_read(file, buf, count, ppos, rc) (rc = seq_read(file, buf, \

							    count, ppos))

#define cfs_seq_open(file, ops, rc)	     (rc = seq_open(file, ops))

#else /* !LPROCFS */

typedef struct cfs_params_file {

	void	   *param_private;

	loff_t	  param_pos;

	unsigned int    param_flags;

} cfs_param_file_t;

typedef struct cfs_param_inode {

	void    *param_private;

} cfs_inode_t;

typedef struct cfs_param_dentry {

	void *param_data;

} cfs_param_dentry_t;

typedef struct cfs_proc_inode {

	cfs_param_dentry_t *param_pde;

	cfs_inode_t	 param_inode;

} cfs_proc_inode_t;

struct cfs_seq_operations;

typedef struct cfs_seq_file {

	char		      *buf;

	size_t		     size;

	size_t		     from;

	size_t		     count;

	loff_t		     index;

	loff_t		     version;

	struct mutex			lock;

	struct cfs_seq_operations *op;

	void		      *private;

} cfs_seq_file_t;

typedef struct cfs_seq_operations {

	void *(*start)(cfs_seq_file_t *m, loff_t *pos);

	void  (*stop)(cfs_seq_file_t *m, void *v);

	void *(*next)(cfs_seq_file_t *m, void *v, loff_t *pos);

	int   (*show)(cfs_seq_file_t *m, void *v);

} cfs_seq_ops_t;

typedef void *cfs_poll_table_t;

typedef struct cfs_param_file_ops {

	struct module *owner;

	int (*open)(cfs_inode_t *, struct file *);

	loff_t (*llseek)(struct file *, loff_t, int);

	int (*release)(cfs_inode_t *, cfs_param_file_t *);

	unsigned int (*poll)(struct file *, cfs_poll_table_t *);

	ssize_t (*write)(struct file *, const char *, size_t, loff_t *);

	ssize_t (*read)(struct file *, char *, size_t, loff_t *);

} cfs_param_file_ops_t;

typedef cfs_param_file_ops_t *cfs_lproc_filep_t;

static inline cfs_proc_inode_t *FAKE_PROC_I(const cfs_inode_t *inode)

{

	return container_of(inode, cfs_proc_inode_t, param_inode);

}

#define CFS_PARAM_MODULE			NULL

#define cfs_file_private(file)		  (file->param_private)

#define cfs_dentry_data(dentry)		 (dentry->param_data)

#define cfs_proc_inode(proc_inode)	      (proc_inode->param_inode)

#define cfs_proc_inode_pde(proc_inode)	  (proc_inode->param_pde)

#define cfs_seq_read_common		     NULL

#define cfs_seq_lseek_common		    NULL

#define cfs_seq_private(seq)		    (seq->private)

#define cfs_seq_read(file, buf, count, ppos, rc) do {} while (0)

#define cfs_seq_open(file, ops, rc)		     \

do {						    \

	 cfs_seq_file_t *p = cfs_file_private(file);    \

	 if (!p) {				      \

		LIBCFS_ALLOC(p, sizeof(*p));	    \

		if (!p) {			       \

			rc = -ENOMEM;		   \

			break;			  \

		}				       \

		cfs_file_private(file) = p;	     \

	}					       \

	memset(p, 0, sizeof(*p));		       \

	p->op = ops;				    \

	rc = 0;					 \

} while (0)

#endif /* LPROCFS */

/* XXX: params_tree APIs */

#endif  /* __PARAMS_TREE_H__ */