ANDROID: sdcardfs: implement vm_ops->page_mkwrite

	return err;

}

static int sdcardfs_page_mkwrite(struct vm_area_struct *vma,

			       struct vm_fault *vmf)

{

	int err = 0;

	struct file *file, *lower_file;

	const struct vm_operations_struct *lower_vm_ops;

	struct vm_area_struct lower_vma;

	memcpy(&lower_vma, vma, sizeof(struct vm_area_struct));

	file = lower_vma.vm_file;

	lower_vm_ops = SDCARDFS_F(file)->lower_vm_ops;

	BUG_ON(!lower_vm_ops);

	if (!lower_vm_ops->page_mkwrite)

		goto out;

	lower_file = sdcardfs_lower_file(file);

	/*

	 * XXX: vm_ops->page_mkwrite may be called in parallel.

	 * Because we have to resort to temporarily changing the

	 * vma->vm_file to point to the lower file, a concurrent

	 * invocation of sdcardfs_page_mkwrite could see a different

	 * value.  In this workaround, we keep a different copy of the

	 * vma structure in our stack, so we never expose a different

	 * value of the vma->vm_file called to us, even temporarily.

	 * A better fix would be to change the calling semantics of

	 * ->page_mkwrite to take an explicit file pointer.

	 */

	lower_vma.vm_file = lower_file;

	err = lower_vm_ops->page_mkwrite(&lower_vma, vmf);

out:

	return err;

}

static ssize_t sdcardfs_direct_IO(int rw, struct kiocb *iocb,

		struct iov_iter *iter, loff_t pos)

{

const struct vm_operations_struct sdcardfs_vm_ops = {

	.fault		= sdcardfs_fault,

	.page_mkwrite	= sdcardfs_page_mkwrite,

};