Staging: pohmelfs: sync with the development tree (2d7cf8ef) · Commits · e / devices / android_kernel_sony_msm8998

drivers/staging/pohmelfs/config.c

+93 −5

Original line number	Original line	Diff line number	Diff line
	@@ -289,6 +289,88 @@ out_unlock:
	return err;		return err;
	}		}

			static int pohmelfs_cn_dump(struct cn_msg *msg)
			{
			struct pohmelfs_config_group *g;
			struct pohmelfs_config c, tmp;
			int err = 0, i = 1;
			int total_msg = 0;

			if (msg->len != sizeof(struct pohmelfs_ctl))
			return -EBADMSG;

			mutex_lock(&pohmelfs_config_lock);

			list_for_each_entry(g, &pohmelfs_config_list, group_entry) {
			if (g)
			total_msg += g->num_entry;
			}
			if (total_msg == 0) {
			if (pohmelfs_send_reply(err, 0, POHMELFS_NOINFO_ACK, msg, NULL))
			err = -ENOMEM;
			goto out_unlock;
			}

			list_for_each_entry(g, &pohmelfs_config_list, group_entry) {
			if (g) {
			list_for_each_entry_safe(c, tmp, &g->config_list, config_entry) {
			struct pohmelfs_ctl *sc = &c->state.ctl;
			if (pohmelfs_send_reply(err, total_msg - i, POHMELFS_CTLINFO_ACK, msg, sc)) {
			err = -ENOMEM;
			goto out_unlock;
			}
			i += 1;
			}
			}
			}

			out_unlock:
			mutex_unlock(&pohmelfs_config_lock);
			return err;
			}

			static int pohmelfs_cn_flush(struct cn_msg *msg)
			{
			struct pohmelfs_config_group *g;
			struct pohmelfs_ctl ctl = (struct pohmelfs_ctl )msg->data;
			struct pohmelfs_config c, tmp;
			int err = 0;

			if (msg->len != sizeof(struct pohmelfs_ctl))
			return -EBADMSG;

			mutex_lock(&pohmelfs_config_lock);

			if (ctl->idx != POHMELFS_NULL_IDX) {
			g = pohmelfs_find_config_group(ctl->idx);

			if (!g)
			goto out_unlock;

			list_for_each_entry_safe(c, tmp, &g->config_list, config_entry) {
			list_del(&c->config_entry);
			g->num_entry--;
			kfree(c);
			}
			} else {
			list_for_each_entry(g, &pohmelfs_config_list, group_entry) {
			if (g) {
			list_for_each_entry_safe(c, tmp, &g->config_list, config_entry) {
			list_del(&c->config_entry);
			g->num_entry--;
			kfree(c);
			}
			}
			}
			}

			out_unlock:
			mutex_unlock(&pohmelfs_config_lock);
			pohmelfs_cn_dump(msg);

			return err;
			}

	static int pohmelfs_modify_config(struct pohmelfs_ctl old, struct pohmelfs_ctl new)		static int pohmelfs_modify_config(struct pohmelfs_ctl old, struct pohmelfs_ctl new)
	{		{
	old->perm = new->perm;		old->perm = new->perm;
	@@ -408,7 +490,6 @@ static int pohmelfs_crypto_cipher_init(struct pohmelfs_config_group *g, struct p
	return 0;		return 0;
	}		}


	static int pohmelfs_cn_crypto(struct cn_msg *msg)		static int pohmelfs_cn_crypto(struct cn_msg *msg)
	{		{
	struct pohmelfs_crypto crypto = (struct pohmelfs_crypto )msg->data;		struct pohmelfs_crypto crypto = (struct pohmelfs_crypto )msg->data;
	@@ -456,9 +537,15 @@ static void pohmelfs_cn_callback(struct cn_msg *msg)
	case POHMELFS_FLAGS_MODIFY:		case POHMELFS_FLAGS_MODIFY:
	err = pohmelfs_cn_ctl(msg, msg->flags);		err = pohmelfs_cn_ctl(msg, msg->flags);
	break;		break;
			case POHMELFS_FLAGS_FLUSH:
			err = pohmelfs_cn_flush(msg);
			break;
	case POHMELFS_FLAGS_SHOW:		case POHMELFS_FLAGS_SHOW:
	err = pohmelfs_cn_disp(msg);		err = pohmelfs_cn_disp(msg);
	break;		break;
			case POHMELFS_FLAGS_DUMP:
			err = pohmelfs_cn_dump(msg);
			break;
	case POHMELFS_FLAGS_CRYPTO:		case POHMELFS_FLAGS_CRYPTO:
	err = pohmelfs_cn_crypto(msg);		err = pohmelfs_cn_crypto(msg);
	break;		break;
	@@ -497,7 +584,8 @@ int pohmelfs_config_check(struct pohmelfs_config *config, int idx)

	int __init pohmelfs_config_init(void)		int __init pohmelfs_config_init(void)
	{		{
	return cn_add_callback(&pohmelfs_cn_id, "pohmelfs", pohmelfs_cn_callback);		/* XXX remove (void ) cast when vanilla connector got synced /
			return cn_add_callback(&pohmelfs_cn_id, "pohmelfs", (void *)pohmelfs_cn_callback);
	}		}

	void pohmelfs_config_exit(void)		void pohmelfs_config_exit(void)

drivers/staging/pohmelfs/crypto.c

+2 −2

Original line number	Original line	Diff line number	Diff line
	@@ -176,7 +176,7 @@ static int pohmelfs_crypto_process(struct ablkcipher_request *req,
	timeout);		timeout);
	if (!err)		if (!err)
	err = -ETIMEDOUT;		err = -ETIMEDOUT;
	else		else if (err > 0)
	err = complete.error;		err = complete.error;
	break;		break;
	default:		default:
	@@ -738,7 +738,7 @@ static int pohmelfs_crypto_init_handshake(struct pohmelfs_sb *psb)
	psb->wait_on_page_timeout);		psb->wait_on_page_timeout);
	if (!err)		if (!err)
	err = -ETIMEDOUT;		err = -ETIMEDOUT;
	else		else if (err > 0)
	err = -psb->flags;		err = -psb->flags;

	if (!err)		if (!err)

drivers/staging/pohmelfs/dir.c

+18 −7

Original line number	Original line	Diff line number	Diff line
	@@ -352,6 +352,8 @@ static int pohmelfs_sync_remote_dir(struct pohmelfs_inode *pi)
	test_bit(NETFS_INODE_REMOTE_DIR_SYNCED, &pi->state) \|\| pi->error, ret);		test_bit(NETFS_INODE_REMOTE_DIR_SYNCED, &pi->state) \|\| pi->error, ret);
	dprintk("%s: awake dir: %llu, ret: %ld, err: %d.\n", __func__, pi->ino, ret, pi->error);		dprintk("%s: awake dir: %llu, ret: %ld, err: %d.\n", __func__, pi->ino, ret, pi->error);
	if (ret <= 0) {		if (ret <= 0) {
			err = ret;
			if (!err)
	err = -ETIMEDOUT;		err = -ETIMEDOUT;
	goto err_out_exit;		goto err_out_exit;
	}		}
	@@ -472,10 +474,11 @@ static int pohmelfs_lookup_single(struct pohmelfs_inode *parent,
	err = 0;		err = 0;
	ret = wait_event_interruptible_timeout(psb->wait,		ret = wait_event_interruptible_timeout(psb->wait,
	!test_bit(NETFS_COMMAND_PENDING, &parent->state), ret);		!test_bit(NETFS_COMMAND_PENDING, &parent->state), ret);
	if (ret == 0)		if (ret <= 0) {
			err = ret;
			if (!err)
	err = -ETIMEDOUT;		err = -ETIMEDOUT;
	else if (signal_pending(current))		}
	err = -EINTR;

	if (err)		if (err)
	goto err_out_exit;		goto err_out_exit;
	@@ -505,13 +508,21 @@ struct dentry pohmelfs_lookup(struct inode dir, struct dentry *dentry, struct
	struct pohmelfs_name *n;		struct pohmelfs_name *n;
	struct inode *inode = NULL;		struct inode *inode = NULL;
	unsigned long ino = 0;		unsigned long ino = 0;
	int err, lock_type = POHMELFS_READ_LOCK, need_lock;		int err, lock_type = POHMELFS_READ_LOCK, need_lock = 1;
	struct qstr str = dentry->d_name;		struct qstr str = dentry->d_name;

	if ((nd->intent.open.flags & O_ACCMODE) > 1)		if ((nd->intent.open.flags & O_ACCMODE) > 1)
	lock_type = POHMELFS_WRITE_LOCK;		lock_type = POHMELFS_WRITE_LOCK;

	need_lock = pohmelfs_need_lock(parent, lock_type);		if (test_bit(NETFS_INODE_OWNED, &parent->state)) {
			if (lock_type == parent->lock_type)
			need_lock = 0;
			if ((lock_type == POHMELFS_READ_LOCK) && (parent->lock_type == POHMELFS_WRITE_LOCK))
			need_lock = 0;
			}

			if ((lock_type == POHMELFS_READ_LOCK) && !test_bit(NETFS_INODE_REMOTE_DIR_SYNCED, &parent->state))
			need_lock = 1;

	str.hash = jhash(dentry->d_name.name, dentry->d_name.len, 0);		str.hash = jhash(dentry->d_name.name, dentry->d_name.len, 0);

drivers/staging/pohmelfs/inode.c

+4 −3

Original line number	Original line	Diff line number	Diff line
	@@ -1504,7 +1504,9 @@ static void pohmelfs_flush_inode(struct pohmelfs_inode *pi, unsigned int count)
	inode->i_sb->s_op->write_inode(inode, 0);		inode->i_sb->s_op->write_inode(inode, 0);
	}		}

			#ifdef POHMELFS_TRUNCATE_ON_INODE_FLUSH
	truncate_inode_pages(inode->i_mapping, 0);		truncate_inode_pages(inode->i_mapping, 0);
			#endif

	pohmelfs_data_unlock(pi, 0, ~0, POHMELFS_WRITE_LOCK);		pohmelfs_data_unlock(pi, 0, ~0, POHMELFS_WRITE_LOCK);
	mutex_unlock(&inode->i_mutex);		mutex_unlock(&inode->i_mutex);
	@@ -1743,11 +1745,10 @@ static int pohmelfs_root_handshake(struct pohmelfs_sb *psb)
	err = wait_event_interruptible_timeout(psb->wait,		err = wait_event_interruptible_timeout(psb->wait,
	(psb->flags != ~0),		(psb->flags != ~0),
	psb->wait_on_page_timeout);		psb->wait_on_page_timeout);
	if (!err) {		if (!err)
	err = -ETIMEDOUT;		err = -ETIMEDOUT;
	} else {		else if (err > 0)
	err = -psb->flags;		err = -psb->flags;
	}

	if (err)		if (err)
	goto err_out_exit;		goto err_out_exit;

drivers/staging/pohmelfs/net.c

+8 −10

Original line number	Original line	Diff line number	Diff line
	@@ -1005,13 +1005,12 @@ int netfs_state_init(struct netfs_state *st)

	if (st->socket->ops->family == AF_INET) {		if (st->socket->ops->family == AF_INET) {
	struct sockaddr_in sin = (struct sockaddr_in )&ctl->addr;		struct sockaddr_in sin = (struct sockaddr_in )&ctl->addr;
	printk(KERN_INFO "%s: (re)connected to peer %u.%u.%u.%u:%d.\n", __func__,		printk(KERN_INFO "%s: (re)connected to peer %pi4:%d.\n", __func__,
	NIPQUAD(sin->sin_addr.s_addr), ntohs(sin->sin_port));		&sin->sin_addr.s_addr, ntohs(sin->sin_port));
	} else if (st->socket->ops->family == AF_INET6) {		} else if (st->socket->ops->family == AF_INET6) {
	struct sockaddr_in6 sin = (struct sockaddr_in6 )&ctl->addr;		struct sockaddr_in6 sin = (struct sockaddr_in6 )&ctl->addr;
	printk(KERN_INFO "%s: (re)connected to peer "		printk(KERN_INFO "%s: (re)connected to peer %pi6:%d", __func__,
	"%pi6:%d",		&sin->sin6_addr, ntohs(sin->sin6_port));
	__func__, &sin->sin6_addr, ntohs(sin->sin6_port));
	}		}

	return 0;		return 0;
	@@ -1031,13 +1030,12 @@ void netfs_state_exit(struct netfs_state *st)

	if (st->socket->ops->family == AF_INET) {		if (st->socket->ops->family == AF_INET) {
	struct sockaddr_in sin = (struct sockaddr_in )&st->ctl.addr;		struct sockaddr_in sin = (struct sockaddr_in )&st->ctl.addr;
	printk("%s: disconnected from peer %u.%u.%u.%u:%d.\n", __func__,		printk(KERN_INFO "%s: disconnected from peer %pi4:%d.\n", __func__,
	NIPQUAD(sin->sin_addr.s_addr), ntohs(sin->sin_port));		&sin->sin_addr.s_addr, ntohs(sin->sin_port));
	} else if (st->socket->ops->family == AF_INET6) {		} else if (st->socket->ops->family == AF_INET6) {
	struct sockaddr_in6 sin = (struct sockaddr_in6 )&st->ctl.addr;		struct sockaddr_in6 sin = (struct sockaddr_in6 )&st->ctl.addr;
	printk("%s: disconnected from peer "		printk(KERN_INFO "%s: disconnected from peer %pi6:%d", __func__,
	"%pi6:%d",		&sin->sin6_addr, ntohs(sin->sin6_port));
	__func__, &sin->sin6_addr, ntohs(sin->sin6_port));
	}		}

	sock_release(st->socket);		sock_release(st->socket);