fs crypto: move per-file encryption from f2fs tree to fs/crypto

	  To the best of my knowledge this is dead code that no one cares about.

source "fs/crypto/Kconfig"

source "fs/notify/Kconfig"

source "fs/quota/Kconfig"

obj-$(CONFIG_USERFAULTFD)	+= userfaultfd.o

obj-$(CONFIG_AIO)               += aio.o

obj-$(CONFIG_FS_DAX)		+= dax.o

obj-$(CONFIG_FS_ENCRYPTION)	+= crypto/

obj-$(CONFIG_FILE_LOCKING)      += locks.o

obj-$(CONFIG_COMPAT)		+= compat.o compat_ioctl.o

obj-$(CONFIG_BINFMT_AOUT)	+= binfmt_aout.o

config FS_ENCRYPTION

	tristate "FS Encryption (Per-file encryption)"

	depends on BLOCK

	select CRYPTO

	select CRYPTO_AES

	select CRYPTO_CBC

	select CRYPTO_ECB

	select CRYPTO_XTS

	select CRYPTO_CTS

	select CRYPTO_CTR

	select CRYPTO_SHA256

	select KEYS

	select ENCRYPTED_KEYS

	help

	  Enable encryption of files and directories.  This

	  feature is similar to ecryptfs, but it is more memory

	  efficient since it avoids caching the encrypted and

	  decrypted pages in the page cache.

obj-$(CONFIG_FS_ENCRYPTION)	+= fscrypto.o

fscrypto-y := crypto.o fname.o policy.o keyinfo.o

/*

 * linux/fs/f2fs/crypto.c

 *

 * Copied from linux/fs/ext4/crypto.c

 * This contains encryption functions for per-file encryption.

 *

 * Copyright (C) 2015, Google, Inc.

 * Copyright (C) 2015, Motorola Mobility

 *

 * This contains encryption functions for f2fs

 *

 * Written by Michael Halcrow, 2014.

 *

 * Filename encryption additions

 *	Uday Savagaonkar, 2014

 * Encryption policy handling additions

 *	Ildar Muslukhov, 2014

 * Remove ext4_encrypted_zeroout(),

 *   add f2fs_restore_and_release_control_page()

 * Add fscrypt_pullback_bio_page()

 *	Jaegeuk Kim, 2015.

 *

 * This has not yet undergone a rigorous security audit.

 * The usage of AES-XTS should conform to recommendations in NIST

 * Special Publication 800-38E and IEEE P1619/D16.

 */

#include <crypto/hash.h>

#include <crypto/sha.h>

#include <keys/user-type.h>

#include <keys/encrypted-type.h>

#include <linux/crypto.h>

#include <linux/ecryptfs.h>

#include <linux/gfp.h>

#include <linux/kernel.h>

#include <linux/key.h>

#include <linux/list.h>

#include <linux/pagemap.h>

#include <linux/mempool.h>

#include <linux/module.h>

#include <linux/mutex.h>

#include <linux/random.h>

#include <linux/scatterlist.h>

#include <linux/spinlock_types.h>

#include <linux/f2fs_fs.h>

#include <linux/ratelimit.h>

#include <linux/bio.h>

#include "f2fs.h"

#include "xattr.h"

/* Encryption added and removed here! (L: */

#include <linux/dcache.h>

#include <linux/fscrypto.h>

static unsigned int num_prealloc_crypto_pages = 32;

static unsigned int num_prealloc_crypto_ctxs = 128;

MODULE_PARM_DESC(num_prealloc_crypto_ctxs,

		"Number of crypto contexts to preallocate");

static mempool_t *f2fs_bounce_page_pool;

static mempool_t *fscrypt_bounce_page_pool = NULL;

static LIST_HEAD(f2fs_free_crypto_ctxs);

static DEFINE_SPINLOCK(f2fs_crypto_ctx_lock);

static LIST_HEAD(fscrypt_free_ctxs);

static DEFINE_SPINLOCK(fscrypt_ctx_lock);

static struct workqueue_struct *f2fs_read_workqueue;

static DEFINE_MUTEX(crypto_init);

static struct workqueue_struct *fscrypt_read_workqueue;

static DEFINE_MUTEX(fscrypt_init_mutex);

static struct kmem_cache *f2fs_crypto_ctx_cachep;

struct kmem_cache *f2fs_crypt_info_cachep;

static struct kmem_cache *fscrypt_ctx_cachep;

struct kmem_cache *fscrypt_info_cachep;

/**

 * f2fs_release_crypto_ctx() - Releases an encryption context

 * fscrypt_release_ctx() - Releases an encryption context

 * @ctx: The encryption context to release.

 *

 * If the encryption context was allocated from the pre-allocated pool, returns

 *

 * If there's a bounce page in the context, this frees that.

 */

void f2fs_release_crypto_ctx(struct f2fs_crypto_ctx *ctx)

void fscrypt_release_ctx(struct fscrypt_ctx *ctx)

{

	unsigned long flags;

	if (ctx->flags & F2FS_WRITE_PATH_FL && ctx->w.bounce_page) {

		mempool_free(ctx->w.bounce_page, f2fs_bounce_page_pool);

	if (ctx->flags & FS_WRITE_PATH_FL && ctx->w.bounce_page) {

		mempool_free(ctx->w.bounce_page, fscrypt_bounce_page_pool);

		ctx->w.bounce_page = NULL;

	}

	ctx->w.control_page = NULL;

	if (ctx->flags & F2FS_CTX_REQUIRES_FREE_ENCRYPT_FL) {

		kmem_cache_free(f2fs_crypto_ctx_cachep, ctx);

	if (ctx->flags & FS_CTX_REQUIRES_FREE_ENCRYPT_FL) {

		kmem_cache_free(fscrypt_ctx_cachep, ctx);

	} else {

		spin_lock_irqsave(&f2fs_crypto_ctx_lock, flags);

		list_add(&ctx->free_list, &f2fs_free_crypto_ctxs);

		spin_unlock_irqrestore(&f2fs_crypto_ctx_lock, flags);

		spin_lock_irqsave(&fscrypt_ctx_lock, flags);

		list_add(&ctx->free_list, &fscrypt_free_ctxs);

		spin_unlock_irqrestore(&fscrypt_ctx_lock, flags);

	}

}

EXPORT_SYMBOL(fscrypt_release_ctx);

/**

 * f2fs_get_crypto_ctx() - Gets an encryption context

 * fscrypt_get_ctx() - Gets an encryption context

 * @inode:       The inode for which we are doing the crypto

 *

 * Allocates and initializes an encryption context.

 * Return: An allocated and initialized encryption context on success; error

 * value or NULL otherwise.

 */

struct f2fs_crypto_ctx *f2fs_get_crypto_ctx(struct inode *inode)

struct fscrypt_ctx *fscrypt_get_ctx(struct inode *inode)

{

	struct f2fs_crypto_ctx *ctx = NULL;

	struct fscrypt_ctx *ctx = NULL;

	struct fscrypt_info *ci = inode->i_crypt_info;

	unsigned long flags;

	struct f2fs_crypt_info *ci = F2FS_I(inode)->i_crypt_info;

	if (ci == NULL)

		return ERR_PTR(-ENOKEY);

	 * should generally be a "last resort" option for a filesystem

	 * to be able to do its job.

	 */

	spin_lock_irqsave(&f2fs_crypto_ctx_lock, flags);

	ctx = list_first_entry_or_null(&f2fs_free_crypto_ctxs,

					struct f2fs_crypto_ctx, free_list);

	spin_lock_irqsave(&fscrypt_ctx_lock, flags);

	ctx = list_first_entry_or_null(&fscrypt_free_ctxs,

					struct fscrypt_ctx, free_list);

	if (ctx)

		list_del(&ctx->free_list);

	spin_unlock_irqrestore(&f2fs_crypto_ctx_lock, flags);

	spin_unlock_irqrestore(&fscrypt_ctx_lock, flags);

	if (!ctx) {

		ctx = kmem_cache_zalloc(f2fs_crypto_ctx_cachep, GFP_NOFS);

		ctx = kmem_cache_zalloc(fscrypt_ctx_cachep, GFP_NOFS);

		if (!ctx)

			return ERR_PTR(-ENOMEM);

		ctx->flags |= F2FS_CTX_REQUIRES_FREE_ENCRYPT_FL;

		ctx->flags |= FS_CTX_REQUIRES_FREE_ENCRYPT_FL;

	} else {

		ctx->flags &= ~F2FS_CTX_REQUIRES_FREE_ENCRYPT_FL;

		ctx->flags &= ~FS_CTX_REQUIRES_FREE_ENCRYPT_FL;

	}

	ctx->flags &= ~F2FS_WRITE_PATH_FL;

	ctx->flags &= ~FS_WRITE_PATH_FL;

	return ctx;

}

/*

 * Call f2fs_decrypt on every single page, reusing the encryption

 * context.

 */

static void completion_pages(struct work_struct *work)

{

	struct f2fs_crypto_ctx *ctx =

		container_of(work, struct f2fs_crypto_ctx, r.work);

	struct bio *bio = ctx->r.bio;

	struct bio_vec *bv;

	int i;

	bio_for_each_segment_all(bv, bio, i) {

		struct page *page = bv->bv_page;

		int ret = f2fs_decrypt(page);

		if (ret) {

			WARN_ON_ONCE(1);

			SetPageError(page);

		} else

			SetPageUptodate(page);

		unlock_page(page);

	}

	f2fs_release_crypto_ctx(ctx);

	bio_put(bio);

}

void f2fs_end_io_crypto_work(struct f2fs_crypto_ctx *ctx, struct bio *bio)

{

	INIT_WORK(&ctx->r.work, completion_pages);

	ctx->r.bio = bio;

	queue_work(f2fs_read_workqueue, &ctx->r.work);

}

static void f2fs_crypto_destroy(void)

{

	struct f2fs_crypto_ctx *pos, *n;

	list_for_each_entry_safe(pos, n, &f2fs_free_crypto_ctxs, free_list)

		kmem_cache_free(f2fs_crypto_ctx_cachep, pos);

	INIT_LIST_HEAD(&f2fs_free_crypto_ctxs);

	if (f2fs_bounce_page_pool)

		mempool_destroy(f2fs_bounce_page_pool);

	f2fs_bounce_page_pool = NULL;

}

EXPORT_SYMBOL(fscrypt_get_ctx);

/**

 * f2fs_crypto_initialize() - Set up for f2fs encryption.

 *

 * We only call this when we start accessing encrypted files, since it

 * results in memory getting allocated that wouldn't otherwise be used.

 *

 * Return: Zero on success, non-zero otherwise.

 */

int f2fs_crypto_initialize(void)

{

	int i, res = -ENOMEM;

	if (f2fs_bounce_page_pool)

		return 0;

	mutex_lock(&crypto_init);

	if (f2fs_bounce_page_pool)

		goto already_initialized;

	for (i = 0; i < num_prealloc_crypto_ctxs; i++) {

		struct f2fs_crypto_ctx *ctx;

		ctx = kmem_cache_zalloc(f2fs_crypto_ctx_cachep, GFP_KERNEL);

		if (!ctx)

			goto fail;

		list_add(&ctx->free_list, &f2fs_free_crypto_ctxs);

	}

	/* must be allocated at the last step to avoid race condition above */

	f2fs_bounce_page_pool =

		mempool_create_page_pool(num_prealloc_crypto_pages, 0);

	if (!f2fs_bounce_page_pool)

		goto fail;

already_initialized:

	mutex_unlock(&crypto_init);

	return 0;

fail:

	f2fs_crypto_destroy();

	mutex_unlock(&crypto_init);

	return res;

}

/**

 * f2fs_exit_crypto() - Shutdown the f2fs encryption system

 */

void f2fs_exit_crypto(void)

{

	f2fs_crypto_destroy();

	if (f2fs_read_workqueue)

		destroy_workqueue(f2fs_read_workqueue);

	if (f2fs_crypto_ctx_cachep)

		kmem_cache_destroy(f2fs_crypto_ctx_cachep);

	if (f2fs_crypt_info_cachep)

		kmem_cache_destroy(f2fs_crypt_info_cachep);

}

int __init f2fs_init_crypto(void)

{

	int res = -ENOMEM;

	f2fs_read_workqueue = alloc_workqueue("f2fs_crypto", WQ_HIGHPRI, 0);

	if (!f2fs_read_workqueue)

		goto fail;

	f2fs_crypto_ctx_cachep = KMEM_CACHE(f2fs_crypto_ctx,

						SLAB_RECLAIM_ACCOUNT);

	if (!f2fs_crypto_ctx_cachep)

		goto fail;

	f2fs_crypt_info_cachep = KMEM_CACHE(f2fs_crypt_info,

						SLAB_RECLAIM_ACCOUNT);

	if (!f2fs_crypt_info_cachep)

		goto fail;

	return 0;

fail:

	f2fs_exit_crypto();

	return res;

}

void f2fs_restore_and_release_control_page(struct page **page)

{

	struct f2fs_crypto_ctx *ctx;

	struct page *bounce_page;

	/* The bounce data pages are unmapped. */

	if ((*page)->mapping)

		return;

	/* The bounce data page is unmapped. */

	bounce_page = *page;

	ctx = (struct f2fs_crypto_ctx *)page_private(bounce_page);

	/* restore control page */

	*page = ctx->w.control_page;

	f2fs_restore_control_page(bounce_page);

}

void f2fs_restore_control_page(struct page *data_page)

{

	struct f2fs_crypto_ctx *ctx =

		(struct f2fs_crypto_ctx *)page_private(data_page);

	set_page_private(data_page, (unsigned long)NULL);

	ClearPagePrivate(data_page);

	unlock_page(data_page);

	f2fs_release_crypto_ctx(ctx);

}

/**

 * f2fs_crypt_complete() - The completion callback for page encryption

 * fscrypt_complete() - The completion callback for page encryption

 * @req: The asynchronous encryption request context

 * @res: The result of the encryption operation

 */

static void f2fs_crypt_complete(struct crypto_async_request *req, int res)

static void fscrypt_complete(struct crypto_async_request *req, int res)

{

	struct f2fs_completion_result *ecr = req->data;

	struct fscrypt_completion_result *ecr = req->data;

	if (res == -EINPROGRESS)

		return;

}

typedef enum {

	F2FS_DECRYPT = 0,

	F2FS_ENCRYPT,

} f2fs_direction_t;

static int f2fs_page_crypto(struct inode *inode,

				f2fs_direction_t rw,

				pgoff_t index,

				struct page *src_page,

				struct page *dest_page)

	FS_DECRYPT = 0,

	FS_ENCRYPT,

} fscrypt_direction_t;

static int do_page_crypto(struct inode *inode,

			fscrypt_direction_t rw, pgoff_t index,

			struct page *src_page, struct page *dest_page)

{

	u8 xts_tweak[F2FS_XTS_TWEAK_SIZE];

	u8 xts_tweak[FS_XTS_TWEAK_SIZE];

	struct ablkcipher_request *req = NULL;

	DECLARE_F2FS_COMPLETION_RESULT(ecr);

	DECLARE_FS_COMPLETION_RESULT(ecr);

	struct scatterlist dst, src;

	struct f2fs_crypt_info *ci = F2FS_I(inode)->i_crypt_info;

	struct fscrypt_info *ci = inode->i_crypt_info;

	struct crypto_ablkcipher *tfm = ci->ci_ctfm;

	int res = 0;

				__func__);

		return -ENOMEM;

	}

	ablkcipher_request_set_callback(

		req, CRYPTO_TFM_REQ_MAY_BACKLOG | CRYPTO_TFM_REQ_MAY_SLEEP,

		f2fs_crypt_complete, &ecr);

		fscrypt_complete, &ecr);

	BUILD_BUG_ON(F2FS_XTS_TWEAK_SIZE < sizeof(index));

	memcpy(xts_tweak, &index, sizeof(index));

	BUILD_BUG_ON(FS_XTS_TWEAK_SIZE < sizeof(index));

	memcpy(xts_tweak, &inode->i_ino, sizeof(index));

	memset(&xts_tweak[sizeof(index)], 0,

			F2FS_XTS_TWEAK_SIZE - sizeof(index));

			FS_XTS_TWEAK_SIZE - sizeof(index));

	sg_init_table(&dst, 1);

	sg_set_page(&dst, dest_page, PAGE_CACHE_SIZE, 0);

	sg_set_page(&src, src_page, PAGE_CACHE_SIZE, 0);

	ablkcipher_request_set_crypt(req, &src, &dst, PAGE_CACHE_SIZE,

					xts_tweak);

	if (rw == F2FS_DECRYPT)

	if (rw == FS_DECRYPT)

		res = crypto_ablkcipher_decrypt(req);

	else

		res = crypto_ablkcipher_encrypt(req);

	if (res == -EINPROGRESS || res == -EBUSY) {

		BUG_ON(req->base.data != &ecr);

		wait_for_completion(&ecr.completion);

		res = ecr.res;

	}

	return 0;

}

static struct page *alloc_bounce_page(struct f2fs_crypto_ctx *ctx)

static struct page *alloc_bounce_page(struct fscrypt_ctx *ctx)

{

	ctx->w.bounce_page = mempool_alloc(f2fs_bounce_page_pool, GFP_NOWAIT);

	ctx->w.bounce_page = mempool_alloc(fscrypt_bounce_page_pool,

							GFP_NOWAIT);

	if (ctx->w.bounce_page == NULL)

		return ERR_PTR(-ENOMEM);

	ctx->flags |= F2FS_WRITE_PATH_FL;

	ctx->flags |= FS_WRITE_PATH_FL;

	return ctx->w.bounce_page;

}

/**

 * f2fs_encrypt() - Encrypts a page

 * fscypt_encrypt_page() - Encrypts a page

 * @inode:          The inode for which the encryption should take place

 * @plaintext_page: The page to encrypt. Must be locked.

 *

 * encryption context.

 *

 * Called on the page write path.  The caller must call

 * f2fs_restore_control_page() on the returned ciphertext page to

 * fscrypt_restore_control_page() on the returned ciphertext page to

 * release the bounce buffer and the encryption context.

 *

 * Return: An allocated page with the encrypted content on success. Else, an

 * error value or NULL.

 */

struct page *f2fs_encrypt(struct inode *inode,

struct page *fscrypt_encrypt_page(struct inode *inode,

				struct page *plaintext_page)

{

	struct f2fs_crypto_ctx *ctx;

	struct fscrypt_ctx *ctx;

	struct page *ciphertext_page = NULL;

	int err;

	BUG_ON(!PageLocked(plaintext_page));

	ctx = f2fs_get_crypto_ctx(inode);

	ctx = fscrypt_get_ctx(inode);

	if (IS_ERR(ctx))

		return (struct page *)ctx;

	/* The encryption operation will require a bounce page. */

	ciphertext_page = alloc_bounce_page(ctx);

	if (IS_ERR(ciphertext_page))

		goto err_out;

		goto errout;

	ctx->w.control_page = plaintext_page;

	err = f2fs_page_crypto(inode, F2FS_ENCRYPT, plaintext_page->index,

	err = do_page_crypto(inode, FS_ENCRYPT, plaintext_page->index,

					plaintext_page, ciphertext_page);

	if (err) {

		ciphertext_page = ERR_PTR(err);

		goto err_out;

		goto errout;

	}

	SetPagePrivate(ciphertext_page);

	set_page_private(ciphertext_page, (unsigned long)ctx);

	lock_page(ciphertext_page);

	return ciphertext_page;

err_out:

	f2fs_release_crypto_ctx(ctx);

errout:

	fscrypt_release_ctx(ctx);

	return ciphertext_page;

}

EXPORT_SYMBOL(fscrypt_encrypt_page);

/**

 * f2fs_decrypt() - Decrypts a page in-place

 * @ctx:  The encryption context.

 * f2crypt_decrypt_page() - Decrypts a page in-place

 * @page: The page to decrypt. Must be locked.

 *

 * Decrypts page in-place using the ctx encryption context.

 *

 * Return: Zero on success, non-zero otherwise.

 */

int f2fs_decrypt(struct page *page)

int fscrypt_decrypt_page(struct page *page)

{

	BUG_ON(!PageLocked(page));

	return f2fs_page_crypto(page->mapping->host,

				F2FS_DECRYPT, page->index, page, page);

	return do_page_crypto(page->mapping->host,

			FS_DECRYPT, page->index, page, page);

}

EXPORT_SYMBOL(fscrypt_decrypt_page);

int fscrypt_zeroout_range(struct inode *inode, pgoff_t lblk,

				sector_t pblk, unsigned int len)

{

	struct fscrypt_ctx *ctx;

	struct page *ciphertext_page = NULL;

	struct bio *bio;

	int ret, err = 0;

	BUG_ON(inode->i_sb->s_blocksize != PAGE_CACHE_SIZE);

	ctx = fscrypt_get_ctx(inode);

	if (IS_ERR(ctx))

		return PTR_ERR(ctx);

	ciphertext_page = alloc_bounce_page(ctx);

	if (IS_ERR(ciphertext_page)) {

		err = PTR_ERR(ciphertext_page);

		goto errout;

	}

	while (len--) {

		err = do_page_crypto(inode, FS_ENCRYPT, lblk,

						ZERO_PAGE(0), ciphertext_page);

		if (err)

			goto errout;

		bio = bio_alloc(GFP_KERNEL, 1);

		if (!bio) {

			err = -ENOMEM;

			goto errout;

		}

		bio->bi_bdev = inode->i_sb->s_bdev;

		bio->bi_iter.bi_sector =

			pblk << (inode->i_sb->s_blocksize_bits - 9);

		ret = bio_add_page(bio, ciphertext_page,

					inode->i_sb->s_blocksize, 0);

		if (ret != inode->i_sb->s_blocksize) {

			/* should never happen! */

			WARN_ON(1);

			bio_put(bio);

			err = -EIO;

			goto errout;

		}

		err = submit_bio_wait(WRITE, bio);

		if ((err == 0) && bio->bi_error)

			err = -EIO;

		bio_put(bio);

		if (err)

			goto errout;

		lblk++;

		pblk++;

	}

	err = 0;

errout:

	fscrypt_release_ctx(ctx);

	return err;

}

EXPORT_SYMBOL(fscrypt_zeroout_range);

bool f2fs_valid_contents_enc_mode(uint32_t mode)

/*

 * Validate dentries for encrypted directories to make sure we aren't

 * potentially caching stale data after a key has been added or

 * removed.

 */

static int fscrypt_d_revalidate(struct dentry *dentry, unsigned int flags)

{

	return (mode == F2FS_ENCRYPTION_MODE_AES_256_XTS);

	struct inode *dir = d_inode(dentry->d_parent);

	struct fscrypt_info *ci = dir->i_crypt_info;

	int dir_has_key, cached_with_key;

	if (!dir->i_sb->s_cop->is_encrypted(dir))

		return 0;

	if (ci && ci->ci_keyring_key &&

	    (ci->ci_keyring_key->flags & ((1 << KEY_FLAG_INVALIDATED) |

					  (1 << KEY_FLAG_REVOKED) |

					  (1 << KEY_FLAG_DEAD))))

		ci = NULL;

	/* this should eventually be an flag in d_flags */

	spin_lock(&dentry->d_lock);

	cached_with_key = dentry->d_flags & DCACHE_ENCRYPTED_WITH_KEY;

	spin_unlock(&dentry->d_lock);

	dir_has_key = (ci != NULL);

	/*

	 * If the dentry was cached without the key, and it is a

	 * negative dentry, it might be a valid name.  We can't check

	 * if the key has since been made available due to locking

	 * reasons, so we fail the validation so ext4_lookup() can do

	 * this check.

	 *

	 * We also fail the validation if the dentry was created with

	 * the key present, but we no longer have the key, or vice versa.

	 */

	if ((!cached_with_key && d_is_negative(dentry)) ||

			(!cached_with_key && dir_has_key) ||

			(cached_with_key && !dir_has_key))

		return 0;

	return 1;

}

const struct dentry_operations fscrypt_d_ops = {

	.d_revalidate = fscrypt_d_revalidate,

};

EXPORT_SYMBOL(fscrypt_d_ops);

/*

 * Call fscrypt_decrypt_page on every single page, reusing the encryption

 * context.

 */

static void completion_pages(struct work_struct *work)

{

	struct fscrypt_ctx *ctx =

		container_of(work, struct fscrypt_ctx, r.work);

	struct bio *bio = ctx->r.bio;

	struct bio_vec *bv;

	int i;

	bio_for_each_segment_all(bv, bio, i) {

		struct page *page = bv->bv_page;

		int ret = fscrypt_decrypt_page(page);

		if (ret) {

			WARN_ON_ONCE(1);

			SetPageError(page);

		} else {

			SetPageUptodate(page);

		}

		unlock_page(page);

	}

	fscrypt_release_ctx(ctx);

	bio_put(bio);

}

void fscrypt_decrypt_bio_pages(struct fscrypt_ctx *ctx, struct bio *bio)

{

	INIT_WORK(&ctx->r.work, completion_pages);