cramfs: Convert cramfs to read_folio

(Block size in cramfs refers to the size of input data that is

compressed at a time.  It's intended to be somewhere around

PAGE_SIZE for cramfs_readpage's convenience.)

PAGE_SIZE for cramfs_read_folio's convenience.)

The superblock ought to indicate the block size that the fs was

written for, since comments in <linux/pagemap.h> indicate that

     PAGE_SIZE.

It's easy enough to change the kernel to use a smaller value than

PAGE_SIZE: just make cramfs_readpage read multiple blocks.

PAGE_SIZE: just make cramfs_read_folio read multiple blocks.

The cost of option 1 is that kernels with a larger PAGE_SIZE

value don't get as good compression as they can.

smaller PAGE_SIZE values.

Option 3 is easy to implement if we don't mind being CPU-inefficient:

e.g. get readpage to decompress to a buffer of size MAX_BLKSIZE (which

e.g. get read_folio to decompress to a buffer of size MAX_BLKSIZE (which

must be no larger than 32KB) and discard what it doesn't need.

Getting readpage to read into all the covered pages is harder.

Getting read_folio to read into all the covered pages is harder.

The main advantage of option 3 over 1, 2, is better compression.  The

cost is greater complexity.  Probably not worth it, but I hope someone

		/*

		 * Let's create a mixed map if we can't map it all.

		 * The normal paging machinery will take care of the

		 * unpopulated ptes via cramfs_readpage().

		 * unpopulated ptes via cramfs_read_folio().

		 */

		int i;

		vma->vm_flags |= VM_MIXEDMAP;

	return d_splice_alias(inode, dentry);

}

static int cramfs_readpage(struct file *file, struct page *page)

static int cramfs_read_folio(struct file *file, struct folio *folio)

{

	struct page *page = &folio->page;

	struct inode *inode = page->mapping->host;

	u32 maxblock;

	int bytes_filled;

}

static const struct address_space_operations cramfs_aops = {

	.readpage = cramfs_readpage

	.read_folio = cramfs_read_folio

};

/*