netfs: Fix gcc-12 warning by embedding vfs inode in netfs_i_context

its use on each netfs inode it is helping to manage.  To this end, a context

structure is defined::

	struct netfs_i_context {

	struct netfs_inode {

		struct inode inode;

		const struct netfs_request_ops *ops;

		struct fscache_cookie *cache;

	};

A network filesystem that wants to use netfs lib must place one of these

directly after the VFS ``struct inode`` it allocates, usually as part of its

own struct.  This can be done in a way similar to the following::

A network filesystem that wants to use netfs lib must place one of these in its

inode wrapper struct instead of the VFS ``struct inode``.  This can be done in

a way similar to the following::

	struct my_inode {

		struct {

			/* These must be contiguous */

			struct inode		vfs_inode;

			struct netfs_i_context  netfs_ctx;

		};

		struct netfs_inode netfs; /* Netfslib context and vfs inode */

		...

	};

This allows netfslib to find its state by simple offset from the inode pointer,

thereby allowing the netfslib helper functions to be pointed to directly by the

VFS/VM operation tables.

This allows netfslib to find its state by using ``container_of()`` from the

inode pointer, thereby allowing the netfslib helper functions to be pointed to

directly by the VFS/VM operation tables.

The structure contains the following fields:

 * ``inode``

   The VFS inode structure.

 * ``ops``

   The set of operations provided by the network filesystem to netfslib.

provided.  Firstly, a function to perform basic initialisation on a context and

set the operations table pointer::

	void netfs_i_context_init(struct inode *inode,

	void netfs_inode_init(struct inode *inode,

			      const struct netfs_request_ops *ops);

then two functions to cast between the VFS inode structure and the netfs

context::

then a function to cast from the VFS inode structure to the netfs context::

	struct netfs_i_context *netfs_i_context(struct inode *inode);

	struct inode *netfs_inode(struct netfs_i_context *ctx);

	struct netfs_inode *netfs_node(struct inode *inode);

and finally, a function to get the cache cookie pointer from the context

attached to an inode (or NULL if fscache is disabled)::

	version = cpu_to_le32(v9inode->qid.version);

	path = cpu_to_le64(v9inode->qid.path);

	v9ses = v9fs_inode2v9ses(inode);

	v9inode->netfs_ctx.cache =

	v9inode->netfs.cache =

		fscache_acquire_cookie(v9fs_session_cache(v9ses),

				       0,

				       &path, sizeof(path),

				       &version, sizeof(version),

				       i_size_read(&v9inode->vfs_inode));

				       i_size_read(&v9inode->netfs.inode));

	p9_debug(P9_DEBUG_FSC, "inode %p get cookie %p\n",

		 inode, v9fs_inode_cookie(v9inode));

	struct v9fs_inode *v9inode = (struct v9fs_inode *)foo;

	memset(&v9inode->qid, 0, sizeof(v9inode->qid));

	inode_init_once(&v9inode->vfs_inode);

	inode_init_once(&v9inode->netfs.inode);

}

/**

#define V9FS_INO_INVALID_ATTR 0x01

struct v9fs_inode {

	struct {

		/* These must be contiguous */

		struct inode	vfs_inode;	/* the VFS's inode record */

		struct netfs_i_context netfs_ctx; /* Netfslib context */

	};

	struct netfs_inode netfs; /* Netfslib context and vfs inode */

	struct p9_qid qid;

	unsigned int cache_validity;

	struct p9_fid *writeback_fid;

static inline struct v9fs_inode *V9FS_I(const struct inode *inode)

{

	return container_of(inode, struct v9fs_inode, vfs_inode);

	return container_of(inode, struct v9fs_inode, netfs.inode);

}

static inline struct fscache_cookie *v9fs_inode_cookie(struct v9fs_inode *v9inode)

{

#ifdef CONFIG_9P_FSCACHE

	return netfs_i_cookie(&v9inode->vfs_inode);

	return netfs_i_cookie(&v9inode->netfs.inode);

#else

	return NULL;

#endif

	    transferred_or_error != -ENOBUFS) {

		version = cpu_to_le32(v9inode->qid.version);

		fscache_invalidate(v9fs_inode_cookie(v9inode), &version,

				   i_size_read(&v9inode->vfs_inode), 0);

				   i_size_read(&v9inode->netfs.inode), 0);

	}

}