[GitHub/mt8127/android_kernel_alcatel_ttab.git] / fs / ecryptfs / kthread.c

/**
 * eCryptfs: Linux filesystem encryption layer
 *
 * Copyright (C) 2008 International Business Machines Corp.
 *   Author(s): Michael A. Halcrow <mahalcro@us.ibm.com>
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307, USA.
 */

#include <linux/kthread.h>
#include <linux/freezer.h>
#include <linux/wait.h>
#include <linux/mount.h>
#include "ecryptfs_kernel.h"

struct kmem_cache *ecryptfs_open_req_cache;

static struct ecryptfs_kthread_ctl {
#define ECRYPTFS_KTHREAD_ZOMBIE 0x00000001
	u32 flags;
	struct mutex mux;
	struct list_head req_list;
	wait_queue_head_t wait;
} ecryptfs_kthread_ctl;

static struct task_struct *ecryptfs_kthread;

/**
 * ecryptfs_threadfn
 * @ignored: ignored
 *
 * The eCryptfs kernel thread that has the responsibility of getting
 * the lower persistent file with RW permissions.
 *
 * Returns zero on success; non-zero otherwise
 */
static int ecryptfs_threadfn(void *ignored)
{
	set_freezable();
	while (1)  {
		struct ecryptfs_open_req *req;

		wait_event_freezable(
			ecryptfs_kthread_ctl.wait,
			(!list_empty(&ecryptfs_kthread_ctl.req_list)
			 || kthread_should_stop()));
		mutex_lock(&ecryptfs_kthread_ctl.mux);
		if (ecryptfs_kthread_ctl.flags & ECRYPTFS_KTHREAD_ZOMBIE) {
			mutex_unlock(&ecryptfs_kthread_ctl.mux);
			goto out;
		}
		while (!list_empty(&ecryptfs_kthread_ctl.req_list)) {
			req = list_first_entry(&ecryptfs_kthread_ctl.req_list,
					       struct ecryptfs_open_req,
					       kthread_ctl_list);
			mutex_lock(&req->mux);
			list_del(&req->kthread_ctl_list);
			if (!(req->flags & ECRYPTFS_REQ_ZOMBIE)) {
				dget(req->lower_dentry);
				mntget(req->lower_mnt);
				(*req->lower_file) = dentry_open(
					req->lower_dentry, req->lower_mnt,
					(O_RDWR | O_LARGEFILE), current_cred());
				req->flags |= ECRYPTFS_REQ_PROCESSED;
			}
			wake_up(&req->wait);
			mutex_unlock(&req->mux);
		}
		mutex_unlock(&ecryptfs_kthread_ctl.mux);
	}
out:
	return 0;
}

int ecryptfs_init_kthread(void)
{
	int rc = 0;

	mutex_init(&ecryptfs_kthread_ctl.mux);
	init_waitqueue_head(&ecryptfs_kthread_ctl.wait);
	INIT_LIST_HEAD(&ecryptfs_kthread_ctl.req_list);
	ecryptfs_kthread = kthread_run(&ecryptfs_threadfn, NULL,
				       "ecryptfs-kthread");
	if (IS_ERR(ecryptfs_kthread)) {
		rc = PTR_ERR(ecryptfs_kthread);
		printk(KERN_ERR "%s: Failed to create kernel thread; rc = [%d]"
		       "\n", __func__, rc);
	}
	return rc;
}

void ecryptfs_destroy_kthread(void)
{
	struct ecryptfs_open_req *req;

	mutex_lock(&ecryptfs_kthread_ctl.mux);
	ecryptfs_kthread_ctl.flags |= ECRYPTFS_KTHREAD_ZOMBIE;
	list_for_each_entry(req, &ecryptfs_kthread_ctl.req_list,
			    kthread_ctl_list) {
		mutex_lock(&req->mux);
		req->flags |= ECRYPTFS_REQ_ZOMBIE;
		wake_up(&req->wait);
		mutex_unlock(&req->mux);
	}
	mutex_unlock(&ecryptfs_kthread_ctl.mux);
	kthread_stop(ecryptfs_kthread);
	wake_up(&ecryptfs_kthread_ctl.wait);
}

/**
 * ecryptfs_privileged_open
 * @lower_file: Result of dentry_open by root on lower dentry
 * @lower_dentry: Lower dentry for file to open
 * @lower_mnt: Lower vfsmount for file to open
 *
 * This function gets a r/w file opened againt the lower dentry.
 *
 * Returns zero on success; non-zero otherwise
 */
int ecryptfs_privileged_open(struct file **lower_file,
			     struct dentry *lower_dentry,
			     struct vfsmount *lower_mnt,
			     const struct cred *cred)
{
	struct ecryptfs_open_req *req;
	int flags = O_LARGEFILE;
	int rc = 0;

	/* Corresponding dput() and mntput() are done when the
	 * persistent file is fput() when the eCryptfs inode is
	 * destroyed. */
	dget(lower_dentry);
	mntget(lower_mnt);
	flags |= IS_RDONLY(lower_dentry->d_inode) ? O_RDONLY : O_RDWR;
	(*lower_file) = dentry_open(lower_dentry, lower_mnt, flags, cred);
	if (!IS_ERR(*lower_file))
		goto out;
	if (flags & O_RDONLY) {
		rc = PTR_ERR((*lower_file));
		goto out;
	}
	req = kmem_cache_alloc(ecryptfs_open_req_cache, GFP_KERNEL);
	if (!req) {
		rc = -ENOMEM;
		goto out;
	}
	mutex_init(&req->mux);
	req->lower_file = lower_file;
	req->lower_dentry = lower_dentry;
	req->lower_mnt = lower_mnt;
	init_waitqueue_head(&req->wait);
	req->flags = 0;
	mutex_lock(&ecryptfs_kthread_ctl.mux);
	if (ecryptfs_kthread_ctl.flags & ECRYPTFS_KTHREAD_ZOMBIE) {
		rc = -EIO;
		mutex_unlock(&ecryptfs_kthread_ctl.mux);
		printk(KERN_ERR "%s: We are in the middle of shutting down; "
		       "aborting privileged request to open lower file\n",
			__func__);
		goto out_free;
	}
	list_add_tail(&req->kthread_ctl_list, &ecryptfs_kthread_ctl.req_list);
	mutex_unlock(&ecryptfs_kthread_ctl.mux);
	wake_up(&ecryptfs_kthread_ctl.wait);
	wait_event(req->wait, (req->flags != 0));
	mutex_lock(&req->mux);
	BUG_ON(req->flags == 0);
	if (req->flags & ECRYPTFS_REQ_DROPPED
	    || req->flags & ECRYPTFS_REQ_ZOMBIE) {
		rc = -EIO;
		printk(KERN_WARNING "%s: Privileged open request dropped\n",
		       __func__);
		goto out_unlock;
	}
	if (IS_ERR(*req->lower_file))
		rc = PTR_ERR(*req->lower_file);
out_unlock:
	mutex_unlock(&req->mux);
out_free:
	kmem_cache_free(ecryptfs_open_req_cache, req);
out:
	return rc;
}
Commit	Line	Data
746f1e55 MH	1	/**
	2	* eCryptfs: Linux filesystem encryption layer
	3	*
	4	* Copyright (C) 2008 International Business Machines Corp.
	5	* Author(s): Michael A. Halcrow <mahalcro@us.ibm.com>
	6	*
	7	* This program is free software; you can redistribute it and/or
	8	* modify it under the terms of the GNU General Public License as
	9	* published by the Free Software Foundation; either version 2 of the
	10	* License, or (at your option) any later version.
	11	*
	12	* This program is distributed in the hope that it will be useful, but
	13	* WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	15	* General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU General Public License
	18	* along with this program; if not, write to the Free Software
	19	* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
	20	* 02111-1307, USA.
	21	*/
	22
	23	#include <linux/kthread.h>
	24	#include <linux/freezer.h>
	25	#include <linux/wait.h>
	26	#include <linux/mount.h>
	27	#include "ecryptfs_kernel.h"
	28
	29	struct kmem_cache *ecryptfs_open_req_cache;
	30
	31	static struct ecryptfs_kthread_ctl {
	32	#define ECRYPTFS_KTHREAD_ZOMBIE 0x00000001
	33	u32 flags;
	34	struct mutex mux;
	35	struct list_head req_list;
	36	wait_queue_head_t wait;
	37	} ecryptfs_kthread_ctl;
	38
	39	static struct task_struct *ecryptfs_kthread;
	40
	41	/**
	42	* ecryptfs_threadfn
	43	* @ignored: ignored
	44	*
	45	* The eCryptfs kernel thread that has the responsibility of getting
	46	* the lower persistent file with RW permissions.
	47	*
	48	* Returns zero on success; non-zero otherwise
	49	*/
	50	static int ecryptfs_threadfn(void *ignored)
	51	{
	52	set_freezable();
	53	while (1) {
	54	struct ecryptfs_open_req *req;
	55
	56	wait_event_freezable(
	57	ecryptfs_kthread_ctl.wait,
	58	(!list_empty(&ecryptfs_kthread_ctl.req_list)
	59	\|\| kthread_should_stop()));
	60	mutex_lock(&ecryptfs_kthread_ctl.mux);
	61	if (ecryptfs_kthread_ctl.flags & ECRYPTFS_KTHREAD_ZOMBIE) {
	62	mutex_unlock(&ecryptfs_kthread_ctl.mux);
	63	goto out;
	64	}
65	while (!list_empty(&ecryptfs_kthread_ctl.req_list)) {
66	req = list_first_entry(&ecryptfs_kthread_ctl.req_list,
67	struct ecryptfs_open_req,
68	kthread_ctl_list);
69	mutex_lock(&req->mux);
70	list_del(&req->kthread_ctl_list);
71	if (!(req->flags & ECRYPTFS_REQ_ZOMBIE)) {
72	dget(req->lower_dentry);
73	mntget(req->lower_mnt);
74	(*req->lower_file) = dentry_open(
75	req->lower_dentry, req->lower_mnt,
745ca247	76	(O_RDWR \| O_LARGEFILE), current_cred());
746f1e55 MH	77	req->flags \|= ECRYPTFS_REQ_PROCESSED;
	78	}
	79	wake_up(&req->wait);
	80	mutex_unlock(&req->mux);
	81	}
	82	mutex_unlock(&ecryptfs_kthread_ctl.mux);
	83	}
	84	out:
	85	return 0;
	86	}
	87
	88	int ecryptfs_init_kthread(void)
	89	{
	90	int rc = 0;
	91
	92	mutex_init(&ecryptfs_kthread_ctl.mux);
	93	init_waitqueue_head(&ecryptfs_kthread_ctl.wait);
	94	INIT_LIST_HEAD(&ecryptfs_kthread_ctl.req_list);
	95	ecryptfs_kthread = kthread_run(&ecryptfs_threadfn, NULL,
	96	"ecryptfs-kthread");
	97	if (IS_ERR(ecryptfs_kthread)) {
	98	rc = PTR_ERR(ecryptfs_kthread);
	99	printk(KERN_ERR "%s: Failed to create kernel thread; rc = [%d]"
	100	"\n", __func__, rc);
	101	}
	102	return rc;
	103	}
	104
	105	void ecryptfs_destroy_kthread(void)
	106	{
	107	struct ecryptfs_open_req *req;
	108
	109	mutex_lock(&ecryptfs_kthread_ctl.mux);
	110	ecryptfs_kthread_ctl.flags \|= ECRYPTFS_KTHREAD_ZOMBIE;
	111	list_for_each_entry(req, &ecryptfs_kthread_ctl.req_list,
	112	kthread_ctl_list) {
	113	mutex_lock(&req->mux);
	114	req->flags \|= ECRYPTFS_REQ_ZOMBIE;
	115	wake_up(&req->wait);
	116	mutex_unlock(&req->mux);
	117	}
	118	mutex_unlock(&ecryptfs_kthread_ctl.mux);
	119	kthread_stop(ecryptfs_kthread);
	120	wake_up(&ecryptfs_kthread_ctl.wait);
	121	}
	122
	123	/**
	124	* ecryptfs_privileged_open
	125	* @lower_file: Result of dentry_open by root on lower dentry
	126	* @lower_dentry: Lower dentry for file to open
	127	* @lower_mnt: Lower vfsmount for file to open
	128	*
	129	* This function gets a r/w file opened againt the lower dentry.
	130	*
	131	* Returns zero on success; non-zero otherwise
	132	*/
	133	int ecryptfs_privileged_open(struct file **lower_file,
	134	struct dentry *lower_dentry,
745ca247 DH	135	struct vfsmount *lower_mnt,
745ca247 DH	136	const struct cred *cred)
746f1e55 MH	137	{
746f1e55 MH	138	struct ecryptfs_open_req *req;
ac22ba23	139	int flags = O_LARGEFILE;
746f1e55 MH	140	int rc = 0;
	141
	142	/* Corresponding dput() and mntput() are done when the
	143	* persistent file is fput() when the eCryptfs inode is
	144	* destroyed. */
	145	dget(lower_dentry);
	146	mntget(lower_mnt);
ac22ba23 TH	147	flags \|= IS_RDONLY(lower_dentry->d_inode) ? O_RDONLY : O_RDWR;
ac22ba23 TH	148	(*lower_file) = dentry_open(lower_dentry, lower_mnt, flags, cred);
746f1e55 MH	149	if (!IS_ERR(*lower_file))
746f1e55 MH	150	goto out;
ac22ba23 TH	151	if (flags & O_RDONLY) {
	152	rc = PTR_ERR((*lower_file));
	153	goto out;
	154	}
746f1e55 MH	155	req = kmem_cache_alloc(ecryptfs_open_req_cache, GFP_KERNEL);
	156	if (!req) {
	157	rc = -ENOMEM;
	158	goto out;
	159	}
	160	mutex_init(&req->mux);
	161	req->lower_file = lower_file;
	162	req->lower_dentry = lower_dentry;
	163	req->lower_mnt = lower_mnt;
	164	init_waitqueue_head(&req->wait);
	165	req->flags = 0;
	166	mutex_lock(&ecryptfs_kthread_ctl.mux);
	167	if (ecryptfs_kthread_ctl.flags & ECRYPTFS_KTHREAD_ZOMBIE) {
	168	rc = -EIO;
	169	mutex_unlock(&ecryptfs_kthread_ctl.mux);
	170	printk(KERN_ERR "%s: We are in the middle of shutting down; "
	171	"aborting privileged request to open lower file\n",
	172	__func__);
	173	goto out_free;
	174	}
	175	list_add_tail(&req->kthread_ctl_list, &ecryptfs_kthread_ctl.req_list);
	176	mutex_unlock(&ecryptfs_kthread_ctl.mux);
	177	wake_up(&ecryptfs_kthread_ctl.wait);
	178	wait_event(req->wait, (req->flags != 0));
	179	mutex_lock(&req->mux);
	180	BUG_ON(req->flags == 0);
	181	if (req->flags & ECRYPTFS_REQ_DROPPED
	182	\|\| req->flags & ECRYPTFS_REQ_ZOMBIE) {
	183	rc = -EIO;
	184	printk(KERN_WARNING "%s: Privileged open request dropped\n",
	185	__func__);
	186	goto out_unlock;
	187	}
ac22ba23	188	if (IS_ERR(*req->lower_file))
746f1e55	189	rc = PTR_ERR(*req->lower_file);
746f1e55 MH	190	out_unlock:
	191	mutex_unlock(&req->mux);
	192	out_free:
	193	kmem_cache_free(ecryptfs_open_req_cache, req);
	194	out:
	195	return rc;
	196	}