eCryptfs: remove unused functions and kmem_cache

The switch to read_write.c routines and the persistent file make a number of
functions unnecessary.  This patch removes them.

Signed-off-by: Michael Halcrow <mhalcrow@us.ibm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

1 files changed, 0 insertions, 150 deletions

diff --git a/fs/ecryptfs/crypto.c b/fs/ecryptfs/crypto.c
index 9408ea484164..a9ca373c6107 100644
--- a/fs/ecryptfs/crypto.c
+++ b/fs/ecryptfs/crypto.c
@@ -353,119 +353,6 @@ out:
         return rc;
 }
 
-static void
-ecryptfs_extent_to_lwr_pg_idx_and_offset(unsigned long *lower_page_idx,
-                                         int *byte_offset,
-                                         struct ecryptfs_crypt_stat *crypt_stat,
-                                         unsigned long extent_num)
-{
-        unsigned long lower_extent_num;
-        int extents_occupied_by_headers_at_front;
-        int bytes_occupied_by_headers_at_front;
-        int extent_offset;
-        int extents_per_page;
-
-        bytes_occupied_by_headers_at_front =
-                (crypt_stat->extent_size
-                 * crypt_stat->num_header_extents_at_front);
-        extents_occupied_by_headers_at_front =
-                ( bytes_occupied_by_headers_at_front
-                  / crypt_stat->extent_size );
-        lower_extent_num = extents_occupied_by_headers_at_front + extent_num;
-        extents_per_page = PAGE_CACHE_SIZE / crypt_stat->extent_size;
-        (*lower_page_idx) = lower_extent_num / extents_per_page;
-        extent_offset = lower_extent_num % extents_per_page;
-        (*byte_offset) = extent_offset * crypt_stat->extent_size;
-        ecryptfs_printk(KERN_DEBUG, " * crypt_stat->extent_size = "
-                        "[%d]\n", crypt_stat->extent_size);
-        ecryptfs_printk(KERN_DEBUG, " * crypt_stat->"
-                        "num_header_extents_at_front = [%d]\n",
-                        crypt_stat->num_header_extents_at_front);
-        ecryptfs_printk(KERN_DEBUG, " * extents_occupied_by_headers_at_"
-                        "front = [%d]\n", extents_occupied_by_headers_at_front);
-        ecryptfs_printk(KERN_DEBUG, " * lower_extent_num = [0x%.16x]\n",
-                        lower_extent_num);
-        ecryptfs_printk(KERN_DEBUG, " * extents_per_page = [%d]\n",
-                        extents_per_page);
-        ecryptfs_printk(KERN_DEBUG, " * (*lower_page_idx) = [0x%.16x]\n",
-                        (*lower_page_idx));
-        ecryptfs_printk(KERN_DEBUG, " * extent_offset = [%d]\n",
-                        extent_offset);
-        ecryptfs_printk(KERN_DEBUG, " * (*byte_offset) = [%d]\n",
-                        (*byte_offset));
-}
-
-static int ecryptfs_write_out_page(struct ecryptfs_page_crypt_context *ctx,
-                                   struct page *lower_page,
-                                   struct inode *lower_inode,
-                                   int byte_offset_in_page, int bytes_to_write)
-{
-        int rc = 0;
-
-        if (ctx->mode == ECRYPTFS_PREPARE_COMMIT_MODE) {
-                rc = ecryptfs_commit_lower_page(lower_page, lower_inode,
-                                                ctx->param.lower_file,
-                                                byte_offset_in_page,
-                                                bytes_to_write);
-                if (rc) {
-                        ecryptfs_printk(KERN_ERR, "Error calling lower "
-                                        "commit; rc = [%d]\n", rc);
-                        goto out;
-                }
-        } else {
-                rc = ecryptfs_writepage_and_release_lower_page(lower_page,
-                                                               lower_inode,
-                                                               ctx->param.wbc);
-                if (rc) {
-                        ecryptfs_printk(KERN_ERR, "Error calling lower "
-                                        "writepage(); rc = [%d]\n", rc);
-                        goto out;
-                }
-        }
-out:
-        return rc;
-}
-
-static int ecryptfs_read_in_page(struct ecryptfs_page_crypt_context *ctx,
-                                 struct page **lower_page,
-                                 struct inode *lower_inode,
-                                 unsigned long lower_page_idx,
-                                 int byte_offset_in_page)
-{
-        int rc = 0;
-
-        if (ctx->mode == ECRYPTFS_PREPARE_COMMIT_MODE) {
-                /* TODO: Limit this to only the data extents that are
-                 * needed */
-                rc = ecryptfs_get_lower_page(lower_page, lower_inode,
-                                             ctx->param.lower_file,
-                                             lower_page_idx,
-                                             byte_offset_in_page,
-                                             (PAGE_CACHE_SIZE
-                                              - byte_offset_in_page));
-                if (rc) {
-                        ecryptfs_printk(
-                                KERN_ERR, "Error attempting to grab, map, "
-                                "and prepare_write lower page with index "
-                                "[0x%.16x]; rc = [%d]\n", lower_page_idx, rc);
-                        goto out;
-                }
-        } else {
-                *lower_page = grab_cache_page(lower_inode->i_mapping,
-                                              lower_page_idx);
-                if (!(*lower_page)) {
-                        rc = -EINVAL;
-                        ecryptfs_printk(
-                                KERN_ERR, "Error attempting to grab and map "
-                                "lower page with index [0x%.16x]; rc = [%d]\n",
-                                lower_page_idx, rc);
-                        goto out;
-                }
-        }
-out:
-        return rc;
-}
-
 /**
  * ecryptfs_lower_offset_for_extent
  *
@@ -1306,43 +1193,6 @@ int ecryptfs_cipher_code_to_string(char *str, u16 cipher_code)
         return rc;
 }
 
-/**
- * ecryptfs_read_header_region
- * @data: The virtual address to write header region data into
- * @dentry: The lower dentry
- * @mnt: The lower VFS mount
- *
- * Returns zero on success; non-zero otherwise
- */
-static int ecryptfs_read_header_region(char *data, struct dentry *dentry,
-                                       struct vfsmount *mnt)
-{
-        struct file *lower_file;
-        mm_segment_t oldfs;
-        int rc;
-
-        rc = ecryptfs_open_lower_file(&lower_file, dentry, mnt, O_RDONLY);
-        if (rc) {
-                printk(KERN_ERR
-                       "Error opening lower_file to read header region\n");
-                goto out;
-        }
-        lower_file->f_pos = 0;
-        oldfs = get_fs();
-        set_fs(get_ds());
-        rc = lower_file->f_op->read(lower_file, (char __user *)data,
-                              ECRYPTFS_DEFAULT_EXTENT_SIZE, &lower_file->f_pos);
-        set_fs(oldfs);
-        rc = ecryptfs_close_lower_file(lower_file);
-        if (rc) {
-                printk(KERN_ERR "Error closing lower_file\n");
-                goto out;
-        }
-        rc = 0;
-out:
-        return rc;
-}
-
 int ecryptfs_read_and_validate_header_region(char *data,
                                              struct inode *ecryptfs_inode)
 {