Merge "soc: qcom: glink: Reorganize glink lock hierarchy"

 * @curr_qos_rate_kBps:		Aggregate of currently supported QoS requests.

 * @threshold_rate_kBps:	Maximum Rate allocated for QoS traffic.

 * @num_priority:		Number of priority buckets in the transport.

 * @tx_ready_lock_lhb2:	lock to protect @tx_ready

 * @tx_ready_lock_lhb3:	lock to protect @tx_ready

 * @active_high_prio:		Highest priority of active channels.

 * @prio_bin:			Pointer to priority buckets.

 * @pm_qos_req:			power management QoS request for TX path

 * @qos_req_active:		a vote is active with the PM QoS system

 * @tx_path_activity:		transmit activity has occurred

 * @pm_qos_work:		removes PM QoS vote due to inactivity

 * @xprt_dbgfs_lock_lhb3:	debugfs channel structure lock

 * @xprt_dbgfs_lock_lhb4:	debugfs channel structure lock

 * @log_ctx:			IPC logging context for this transport.

 */

struct glink_core_xprt_ctx {

	unsigned long curr_qos_rate_kBps;

	unsigned long threshold_rate_kBps;

	uint32_t num_priority;

	spinlock_t tx_ready_lock_lhb2;

	spinlock_t tx_ready_lock_lhb3;

	uint32_t active_high_prio;

	struct glink_qos_priority_bin *prio_bin;

	bool tx_path_activity;

	struct delayed_work pm_qos_work;

	struct mutex xprt_dbgfs_lock_lhb3;

	struct mutex xprt_dbgfs_lock_lhb4;

	void *log_ctx;

};

 * @tx_cnt:				Packets to be picked by tx scheduler.

 */

struct channel_ctx {

	struct rwref_lock ch_state_lhc0;

	struct rwref_lock ch_state_lhb2;

	struct list_head port_list_node;

	struct list_head tx_ready_list_node;

	char name[GLINK_NAME_SIZE];

		if (!strcmp(subsystem, xprt_ctx->edge) &&

				xprt_is_fully_opened(xprt_ctx)) {

			GLINK_INFO_XPRT(xprt_ctx, "%s: SSR\n", __func__);

			spin_lock_irqsave(&xprt_ctx->tx_ready_lock_lhb2,

			spin_lock_irqsave(&xprt_ctx->tx_ready_lock_lhb3,

					  flags);

			for (i = 0; i < xprt_ctx->num_priority; i++)

				list_for_each_entry_safe(ch_ctx, temp_ch_ctx,

						tx_ready_list_node)

					list_del_init(

						&ch_ctx->tx_ready_list_node);

			spin_unlock_irqrestore(&xprt_ctx->tx_ready_lock_lhb2,

			spin_unlock_irqrestore(&xprt_ctx->tx_ready_lock_lhb3,

						flags);

			xprt_ctx->ops->ssr(xprt_ctx->ops);

 *

 * This function is called to update the channel priority during QoS request,

 * QoS Cancel or Priority evaluation by packet scheduler. This function must

 * be called with transport's tx_ready_lock_lhb2 lock and channel's

 * be called with transport's tx_ready_lock_lhb3 lock and channel's

 * tx_lists_lock_lhc3 locked.

 */

static void glink_qos_update_ch_prio(struct channel_ctx *ctx,

	uint32_t i;

	unsigned long flags;

	spin_lock_irqsave(&ctx->transport_ptr->tx_ready_lock_lhb2, flags);

	spin_lock_irqsave(&ctx->transport_ptr->tx_ready_lock_lhb3, flags);

	if (ctx->req_rate_kBps) {

		spin_unlock_irqrestore(&ctx->transport_ptr->tx_ready_lock_lhb2,

		spin_unlock_irqrestore(&ctx->transport_ptr->tx_ready_lock_lhb3,

					flags);

		GLINK_ERR_CH(ctx, "%s: QoS Request already exists\n", __func__);

		return -EINVAL;

	ret = glink_qos_check_feasibility(ctx->transport_ptr, req_rate_kBps);

	if (ret < 0) {

		spin_unlock_irqrestore(&ctx->transport_ptr->tx_ready_lock_lhb2,

		spin_unlock_irqrestore(&ctx->transport_ptr->tx_ready_lock_lhb3,

					flags);

		return ret;

	}

		ctx->token_start_time = arch_counter_get_cntpct();

	}

	spin_unlock(&ctx->tx_lists_lock_lhc3);

	spin_unlock_irqrestore(&ctx->transport_ptr->tx_ready_lock_lhb2, flags);

	spin_unlock_irqrestore(&ctx->transport_ptr->tx_ready_lock_lhb3, flags);

	return 0;

}

{

	unsigned long flags;

	spin_lock_irqsave(&ctx->transport_ptr->tx_ready_lock_lhb2, flags);

	spin_lock_irqsave(&ctx->transport_ptr->tx_ready_lock_lhb3, flags);

	spin_lock(&ctx->tx_lists_lock_lhc3);

	if (ctx->initial_priority > 0) {

		ctx->initial_priority = 0;

		ctx->req_rate_kBps = 0;

	}

	spin_unlock(&ctx->tx_lists_lock_lhc3);

	spin_unlock_irqrestore(&ctx->transport_ptr->tx_ready_lock_lhb2, flags);

	spin_unlock_irqrestore(&ctx->transport_ptr->tx_ready_lock_lhb3, flags);

	return 0;

}

 *

 * This function is called to vote for the transport either when the channel

 * is transmitting or when it shows an intention to transmit sooner. This

 * function must be called with transport's tx_ready_lock_lhb2 lock and

 * function must be called with transport's tx_ready_lock_lhb3 lock and

 * channel's tx_lists_lock_lhc3 locked.

 *

 * Return: 0 on success, standard Linux error codes on failure.

 *

 * This function is called to unvote for the transport either when all the

 * packets queued by the channel are transmitted by the scheduler. This

 * function must be called with transport's tx_ready_lock_lhb2 lock and

 * function must be called with transport's tx_ready_lock_lhb3 lock and

 * channel's tx_lists_lock_lhc3 locked.

 *

 * Return: 0 on success, standard Linux error codes on failure.

 *

 * This function is called to update the channel state when it is intending to

 * transmit sooner. This function must be called with transport's

 * tx_ready_lock_lhb2 lock and channel's tx_lists_lock_lhc3 locked.

 * tx_ready_lock_lhb3 lock and channel's tx_lists_lock_lhc3 locked.

 *

 * Return: 0 on success, standard Linux error codes on failure.

 */

 *

 * This function is called to update the channel state when it is queueing a

 * packet to transmit. This function must be called with transport's

 * tx_ready_lock_lhb2 lock and channel's tx_lists_lock_lhc3 locked.

 * tx_ready_lock_lhb3 lock and channel's tx_lists_lock_lhc3 locked.

 *

 * Return: 0 on success, standard Linux error codes on failure.

 */

 *

 * This function is called to update the channel state when all packets in its

 * transmit queue are successfully transmitted. This function must be called

 * with transport's tx_ready_lock_lhb2 lock and channel's tx_lists_lock_lhc3

 * with transport's tx_ready_lock_lhb3 lock and channel's tx_lists_lock_lhc3

 * locked.

 *

 * Return: 0 on success, standard Linux error codes on failure.

	spin_lock_irqsave(&xprt_ctx->xprt_ctx_lock_lhb1, flags);

	list_for_each_entry(entry, &xprt_ctx->channels, port_list_node)

		if (entry->lcid == lcid) {

			rwref_get(&entry->ch_state_lhc0);

			rwref_get(&entry->ch_state_lhb2);

			spin_unlock_irqrestore(&xprt_ctx->xprt_ctx_lock_lhb1,

					flags);

			return entry;

	spin_lock_irqsave(&xprt_ctx->xprt_ctx_lock_lhb1, flags);

	list_for_each_entry(entry, &xprt_ctx->channels, port_list_node)

		if (entry->rcid == rcid) {

			rwref_get(&entry->ch_state_lhc0);

			rwref_get(&entry->ch_state_lhb2);

			spin_unlock_irqrestore(&xprt_ctx->xprt_ctx_lock_lhb1,

					flags);

			return entry;

static void glink_ch_ctx_release(struct rwref_lock *ch_st_lock)

{

	struct channel_ctx *ctx = container_of(ch_st_lock, struct channel_ctx,

						ch_state_lhc0);

						ch_state_lhb2);

	ctx->transport_ptr = NULL;

	kfree(ctx);

	GLINK_INFO("%s: freed the channel ctx in pid [%d]\n", __func__,

	ctx->local_open_state = GLINK_CHANNEL_CLOSED;

	strlcpy(ctx->name, name, GLINK_NAME_SIZE);

	rwref_lock_init(&ctx->ch_state_lhc0, glink_ch_ctx_release);

	rwref_lock_init(&ctx->ch_state_lhb2, glink_ch_ctx_release);

	INIT_LIST_HEAD(&ctx->tx_ready_list_node);

	init_completion(&ctx->int_req_ack_complete);

	init_completion(&ctx->int_req_complete);

	}

	spin_unlock_irqrestore(&xprt_ctx->xprt_ctx_lock_lhb1, flags);

	rwref_write_put(&xprt_ctx->xprt_state_lhb0);

	mutex_lock(&xprt_ctx->xprt_dbgfs_lock_lhb3);

	mutex_lock(&xprt_ctx->xprt_dbgfs_lock_lhb4);

	if (ctx != NULL)

		glink_debugfs_add_channel(ctx, xprt_ctx);

	mutex_unlock(&xprt_ctx->xprt_dbgfs_lock_lhb3);

	mutex_unlock(&xprt_ctx->xprt_dbgfs_lock_lhb4);

	return ctx;

}

{

	bool is_fully_closed;

	rwref_write_get(&ctx->ch_state_lhc0);

	rwref_write_get(&ctx->ch_state_lhb2);

	ctx->local_open_state = lstate;

	is_fully_closed = ch_is_fully_closed(ctx);

	rwref_write_put(&ctx->ch_state_lhc0);

	rwref_write_put(&ctx->ch_state_lhb2);

	return is_fully_closed;

}

{

	bool is_fully_closed;

	rwref_write_get(&ctx->ch_state_lhc0);

	rwref_write_get(&ctx->ch_state_lhb2);

	ctx->remote_opened = rstate;

	is_fully_closed = ch_is_fully_closed(ctx);

	rwref_write_put(&ctx->ch_state_lhc0);

	rwref_write_put(&ctx->ch_state_lhb2);

	return is_fully_closed;

}

			flags);

	if (add_flcid)

		glink_add_free_lcid_list(ctx);

	mutex_lock(&ctx->transport_ptr->xprt_dbgfs_lock_lhb3);

	mutex_lock(&ctx->transport_ptr->xprt_dbgfs_lock_lhb4);

	glink_debugfs_remove_channel(ctx, ctx->transport_ptr);

	mutex_unlock(&ctx->transport_ptr->xprt_dbgfs_lock_lhb3);

	rwref_put(&ctx->ch_state_lhc0);

	mutex_unlock(&ctx->transport_ptr->xprt_dbgfs_lock_lhb4);

	rwref_put(&ctx->ch_state_lhb2);

}

/**

	complete_all(&ctx->int_req_ack_complete);

	complete_all(&ctx->int_req_complete);

	spin_lock_irqsave(&ctx->transport_ptr->tx_ready_lock_lhb2, flags);

	spin_lock_irqsave(&ctx->transport_ptr->tx_ready_lock_lhb3, flags);

	if (!list_empty(&ctx->tx_ready_list_node))

		list_del_init(&ctx->tx_ready_list_node);

	spin_unlock_irqrestore(&ctx->transport_ptr->tx_ready_lock_lhb2, flags);

	spin_unlock_irqrestore(&ctx->transport_ptr->tx_ready_lock_lhb3, flags);

	if (ctx->transport_ptr->local_state != GLINK_XPRT_DOWN) {

		glink_qos_reset_priority(ctx);

	if (!ctx)

		return -EINVAL;

	rwref_get(&ctx->ch_state_lhc0);

	rwref_get(&ctx->ch_state_lhb2);

	if (!(vbuf_provider || pbuf_provider)) {

		rwref_put(&ctx->ch_state_lhc0);

		rwref_put(&ctx->ch_state_lhb2);

		return -EINVAL;

	}

	if (!ch_is_fully_opened(ctx)) {

		rwref_put(&ctx->ch_state_lhc0);

		rwref_put(&ctx->ch_state_lhb2);

		return -EBUSY;

	}

	if (size > GLINK_MAX_PKT_SIZE) {

		rwref_put(&ctx->ch_state_lhc0);

		rwref_put(&ctx->ch_state_lhb2);

		return -EINVAL;

	}

	if (unlikely(tx_flags & GLINK_TX_TRACER_PKT)) {

		if (!(ctx->transport_ptr->capabilities & GCAP_TRACER_PKT)) {

			rwref_put(&ctx->ch_state_lhc0);

			rwref_put(&ctx->ch_state_lhb2);

			return -EOPNOTSUPP;

		}

		tracer_pkt_log_event(data, GLINK_CORE_TX);

			GLINK_ERR_CH(ctx,

				"%s: R[%u]:%zu Intent not present for lcid\n",

				__func__, riid, size);

			rwref_put(&ctx->ch_state_lhc0);

			rwref_put(&ctx->ch_state_lhb2);

			return -EAGAIN;

		}

		if (is_atomic && !(ctx->transport_ptr->capabilities &

			GLINK_ERR_CH(ctx,

				"%s: Cannot request intent in atomic context\n",

				__func__);

			rwref_put(&ctx->ch_state_lhc0);

			rwref_put(&ctx->ch_state_lhb2);

			return -EINVAL;

		}

		if (ret) {

			GLINK_ERR_CH(ctx, "%s: Request intent failed %d\n",

					__func__, ret);

			rwref_put(&ctx->ch_state_lhc0);

			rwref_put(&ctx->ch_state_lhb2);

			return ret;

		}

				GLINK_ERR_CH(ctx,

				    "%s Intent of size %zu not ready\n",

				    __func__, size);

				rwref_put(&ctx->ch_state_lhc0);

				rwref_put(&ctx->ch_state_lhb2);

				return -EAGAIN;

			}

				GLINK_ERR_CH(ctx,

					"%s: Channel closed while waiting for intent\n",

					__func__);

				rwref_put(&ctx->ch_state_lhc0);

				rwref_put(&ctx->ch_state_lhb2);

				return -EBUSY;

			}

				GLINK_ERR_CH(ctx,

					"%s: Intent request ack with size: %zu not granted for lcid\n",

					__func__, size);

				rwref_put(&ctx->ch_state_lhc0);

				rwref_put(&ctx->ch_state_lhb2);

				return -ETIMEDOUT;

			}

				    "%s: Intent Request with size: %zu %s",

				    __func__, size,

				    "not granted for lcid\n");

				rwref_put(&ctx->ch_state_lhc0);

				rwref_put(&ctx->ch_state_lhb2);

				return -EAGAIN;

			}

				GLINK_ERR_CH(ctx,

					"%s: Intent request with size: %zu not granted for lcid\n",

					__func__, size);

				rwref_put(&ctx->ch_state_lhc0);

				rwref_put(&ctx->ch_state_lhb2);

				return -ETIMEDOUT;

			}

	}

	if (!is_atomic) {

		spin_lock_irqsave(&ctx->transport_ptr->tx_ready_lock_lhb2,

		spin_lock_irqsave(&ctx->transport_ptr->tx_ready_lock_lhb3,

				  flags);

		glink_pm_qos_vote(ctx->transport_ptr);

		spin_unlock_irqrestore(&ctx->transport_ptr->tx_ready_lock_lhb2,

		spin_unlock_irqrestore(&ctx->transport_ptr->tx_ready_lock_lhb3,

					flags);

	}

	if (!tx_info) {

		GLINK_ERR_CH(ctx, "%s: No memory for allocation\n", __func__);

		ch_push_remote_rx_intent(ctx, intent_size, riid);

		rwref_put(&ctx->ch_state_lhc0);

		rwref_put(&ctx->ch_state_lhb2);

		return -ENOMEM;

	}

	rwref_lock_init(&tx_info->pkt_ref, glink_tx_pkt_release);

	else

		xprt_schedule_tx(ctx->transport_ptr, ctx, tx_info);

	rwref_put(&ctx->ch_state_lhc0);

	rwref_put(&ctx->ch_state_lhb2);

	return ret;

}

		return -EBUSY;

	}

	spin_lock_irqsave(&ctx->transport_ptr->tx_ready_lock_lhb2, flags);

	spin_lock_irqsave(&ctx->transport_ptr->tx_ready_lock_lhb3, flags);

	spin_lock(&ctx->tx_lists_lock_lhc3);

	ret = glink_qos_add_ch_tx_intent(ctx);

	spin_unlock(&ctx->tx_lists_lock_lhc3);

	spin_unlock_irqrestore(&ctx->transport_ptr->tx_ready_lock_lhb2, flags);

	spin_unlock_irqrestore(&ctx->transport_ptr->tx_ready_lock_lhb3, flags);

	return ret;

}

EXPORT_SYMBOL(glink_qos_start);

	xprt_ptr->remote_neg_completed = false;

	INIT_LIST_HEAD(&xprt_ptr->channels);

	spin_lock_init(&xprt_ptr->tx_ready_lock_lhb2);

	mutex_init(&xprt_ptr->xprt_dbgfs_lock_lhb3);

	spin_lock_init(&xprt_ptr->tx_ready_lock_lhb3);

	mutex_init(&xprt_ptr->xprt_dbgfs_lock_lhb4);

	init_kthread_work(&xprt_ptr->tx_kwork, tx_func);

	init_kthread_worker(&xprt_ptr->tx_wq);

	xprt_ptr->tx_task = kthread_run(kthread_worker_fn,

	xprt_ptr->local_state = GLINK_XPRT_DOWN;

	xprt_ptr->remote_neg_completed = false;

	INIT_LIST_HEAD(&xprt_ptr->channels);

	spin_lock_init(&xprt_ptr->tx_ready_lock_lhb2);

	mutex_init(&xprt_ptr->xprt_dbgfs_lock_lhb3);

	spin_lock_init(&xprt_ptr->tx_ready_lock_lhb3);

	mutex_init(&xprt_ptr->xprt_dbgfs_lock_lhb4);

	return xprt_ptr;

}

	spin_lock_irqsave(&xprt_ptr->xprt_ctx_lock_lhb1, flags);

	list_for_each_entry_safe(ctx, tmp_ctx, &xprt_ptr->channels,

						port_list_node) {

		rwref_get(&ctx->ch_state_lhc0);

		rwref_get(&ctx->ch_state_lhb2);

		if (ctx->local_open_state == GLINK_CHANNEL_OPENED ||

			ctx->local_open_state == GLINK_CHANNEL_OPENING) {

			rwref_get(&dummy_xprt_ctx->xprt_state_lhb0);

				glink_delete_ch_from_list(ctx, false);

			spin_lock_irqsave(&xprt_ptr->xprt_ctx_lock_lhb1, flags);

		}

		rwref_put(&ctx->ch_state_lhc0);

		rwref_put(&ctx->ch_state_lhb2);

	}

	list_for_each_entry_safe(temp_lcid, temp_lcid1,

			&xprt_ptr->free_lcid_list, list_node) {

	spin_lock_irqsave(&dummy_xprt_ctx->xprt_ctx_lock_lhb1, d_flags);

	list_for_each_entry_safe(ctx, tmp_ctx, &dummy_xprt_ctx->channels,

						port_list_node) {

		rwref_get(&ctx->ch_state_lhc0);

		rwref_get(&ctx->ch_state_lhb2);

		spin_unlock_irqrestore(&dummy_xprt_ctx->xprt_ctx_lock_lhb1,

				d_flags);

		glink_core_remote_close_common(ctx);

		spin_lock_irqsave(&dummy_xprt_ctx->xprt_ctx_lock_lhb1,

				d_flags);

		rwref_put(&ctx->ch_state_lhc0);

		rwref_put(&ctx->ch_state_lhb2);

	}

	spin_unlock_irqrestore(&dummy_xprt_ctx->xprt_ctx_lock_lhb1, d_flags);

	rwref_put(&dummy_xprt_ctx->xprt_state_lhb0);

							ctx->local_xprt_req &&

							ctx->local_xprt_resp) {

					l_ctx = ctx;

					rwref_get(&l_ctx->ch_state_lhc0);

					rwref_get(&l_ctx->ch_state_lhb2);

				}

			spin_unlock_irqrestore(&xprt->xprt_ctx_lock_lhb1,

									flags);

							ctx->remote_xprt_req &&

							ctx->remote_xprt_resp) {

					r_ctx = ctx;

					rwref_get(&r_ctx->ch_state_lhc0);

					rwref_get(&r_ctx->ch_state_lhb2);

				}

			spin_unlock_irqrestore(&xprt->xprt_ctx_lock_lhb1,

									flags);

	if (!r_ctx)

		r_ctx = find_r_ctx_get(l_ctx);

	else

		rwref_get(&r_ctx->ch_state_lhc0);

		rwref_get(&r_ctx->ch_state_lhb2);

	if (!r_ctx)

		return migrate;

	if (!l_ctx)

		l_ctx = find_l_ctx_get(r_ctx);

	else

		rwref_get(&l_ctx->ch_state_lhc0);

		rwref_get(&l_ctx->ch_state_lhb2);

	if (!l_ctx)

		goto exit;

	migrate = true;

exit:

	if (l_ctx)

		rwref_put(&l_ctx->ch_state_lhc0);

		rwref_put(&l_ctx->ch_state_lhb2);

	if (r_ctx)

		rwref_put(&r_ctx->ch_state_lhc0);

		rwref_put(&r_ctx->ch_state_lhb2);

	return migrate;

}

	if (!r_ctx)

		r_ctx = find_r_ctx_get(l_ctx);

	else

		rwref_get(&r_ctx->ch_state_lhc0);

		rwref_get(&r_ctx->ch_state_lhb2);

	if (!r_ctx)

		return migrated;

	if (!l_ctx)

		l_ctx = find_l_ctx_get(r_ctx);

	else

		rwref_get(&l_ctx->ch_state_lhc0);

		rwref_get(&l_ctx->ch_state_lhb2);

	if (!l_ctx) {

		rwref_put(&r_ctx->ch_state_lhc0);

		rwref_put(&r_ctx->ch_state_lhb2);

		return migrated;

	}

	list_del_init(&l_ctx->port_list_node);

	spin_unlock_irqrestore(&l_ctx->transport_ptr->xprt_ctx_lock_lhb1,

									flags);

	mutex_lock(&l_ctx->transport_ptr->xprt_dbgfs_lock_lhb3);

	mutex_lock(&l_ctx->transport_ptr->xprt_dbgfs_lock_lhb4);

	glink_debugfs_remove_channel(l_ctx, l_ctx->transport_ptr);

	mutex_unlock(&l_ctx->transport_ptr->xprt_dbgfs_lock_lhb3);

	mutex_unlock(&l_ctx->transport_ptr->xprt_dbgfs_lock_lhb4);

	memcpy(ctx_clone, l_ctx, sizeof(*ctx_clone));

	ctx_clone->local_xprt_req = 0;

	ctx_clone->remote_xprt_resp = 0;

	ctx_clone->notify_state = NULL;

	ctx_clone->local_open_state = GLINK_CHANNEL_CLOSING;

	rwref_lock_init(&ctx_clone->ch_state_lhc0, glink_ch_ctx_release);

	rwref_lock_init(&ctx_clone->ch_state_lhb2, glink_ch_ctx_release);

	init_completion(&ctx_clone->int_req_ack_complete);

	init_completion(&ctx_clone->int_req_complete);

	spin_lock_init(&ctx_clone->local_rx_intent_lst_lock_lhc1);

		spin_unlock_irqrestore(&xprt->xprt_ctx_lock_lhb1, flags);

	}

	mutex_lock(&xprt->xprt_dbgfs_lock_lhb3);

	mutex_lock(&xprt->xprt_dbgfs_lock_lhb4);

	glink_debugfs_add_channel(l_ctx, xprt);

	mutex_unlock(&xprt->xprt_dbgfs_lock_lhb3);

	mutex_unlock(&xprt->xprt_dbgfs_lock_lhb4);

	mutex_lock(&transport_list_lock_lha0);

	list_for_each_entry(xprt, &transport_list, list_node)

	migrated = true;

exit:

	rwref_put(&l_ctx->ch_state_lhc0);

	rwref_put(&r_ctx->ch_state_lhc0);

	rwref_put(&l_ctx->ch_state_lhb2);

	rwref_put(&r_ctx->ch_state_lhb2);

	return migrated;

}

	}

	if (l_ctx)

		rwref_put(&l_ctx->ch_state_lhc0);

		rwref_put(&l_ctx->ch_state_lhb2);

	return r_ctx->remote_xprt_resp;

}

		GLINK_ERR_CH(ctx,

			"%s: unexpected open ack receive for lcid. Current state: %u. Thread: %u\n",

				__func__, ctx->local_open_state, current->pid);

		rwref_put(&ctx->ch_state_lhc0);

		rwref_put(&ctx->ch_state_lhb2);

		return;

	}

					__func__);

		}

	}

	rwref_put(&ctx->ch_state_lhc0);

	rwref_put(&ctx->ch_state_lhb2);

}

/**

		GLINK_ERR_CH(ctx,

			"%s: unexpected remote close receive for rcid %u\n",

			__func__, (unsigned)rcid);

		rwref_put(&ctx->ch_state_lhc0);

		rwref_put(&ctx->ch_state_lhb2);

		return;