drivers/staging/lustre/include/linux/libcfs/params_tree.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 <linux/libcfs/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__ */