Lines Matching refs:clt
17 #include "rtrs-clt.h"
47 static inline bool rtrs_clt_is_connected(const struct rtrs_clt *clt)
53 list_for_each_entry_rcu(sess, &clt->paths_list, s.entry)
61 __rtrs_get_permit(struct rtrs_clt *clt, enum rtrs_clt_con_type con_type)
63 size_t max_depth = clt->queue_depth;
75 bit = find_first_zero_bit(clt->permits_map, max_depth);
78 } while (unlikely(test_and_set_bit_lock(bit, clt->permits_map)));
80 permit = get_permit(clt, bit);
88 static inline void __rtrs_put_permit(struct rtrs_clt *clt,
91 clear_bit_unlock(permit->mem_id, clt->permits_map);
96 * @clt: Current session
108 struct rtrs_permit *rtrs_clt_get_permit(struct rtrs_clt *clt,
115 permit = __rtrs_get_permit(clt, con_type);
120 prepare_to_wait(&clt->permits_wait, &wait,
122 permit = __rtrs_get_permit(clt, con_type);
129 finish_wait(&clt->permits_wait, &wait);
137 * @clt: Current session
143 void rtrs_clt_put_permit(struct rtrs_clt *clt, struct rtrs_permit *permit)
145 if (WARN_ON(!test_bit(permit->mem_id, clt->permits_map)))
148 __rtrs_put_permit(clt, permit);
151 * rtrs_clt_get_permit() adds itself to the &clt->permits_wait list
153 * it must have added itself to &clt->permits_wait before
157 if (waitqueue_active(&clt->permits_wait))
158 wake_up(&clt->permits_wait);
310 struct rtrs_clt *clt = sess->clt;
316 delay_ms = clt->reconnect_delay_sec * 1000;
440 if (sess->clt->mp_policy == MP_POLICY_MIN_INFLIGHT)
538 rtrs_err(sess->clt, "rkey response is malformed: type %d\n",
603 rtrs_err(sess->clt, "RDMA failed: %s\n",
679 rtrs_wrn(sess->clt, "Unexpected WC type: %d\n", wc->opcode);
723 rtrs_err(sess->clt, "post_recv_io(), err: %d\n", err);
734 struct rtrs_clt *clt;
771 struct rtrs_clt *clt;
773 clt = it->clt;
781 ppcpu_path = this_cpu_ptr(clt->pcpu_path);
784 path = list_first_or_null_rcu(&clt->paths_list,
787 path = list_next_or_null_rr_rcu(&clt->paths_list,
808 struct rtrs_clt *clt = it->clt;
813 list_for_each_entry_rcu(sess, &clt->paths_list, s.entry) {
838 static inline void path_it_init(struct path_it *it, struct rtrs_clt *clt)
841 it->clt = clt;
844 if (clt->mp_policy == MP_POLICY_RR)
1033 if (sess->clt->mp_policy == MP_POLICY_MIN_INFLIGHT)
1154 if (sess->clt->mp_policy == MP_POLICY_MIN_INFLIGHT)
1167 * @clt: clt context
1170 static int rtrs_clt_failover_req(struct rtrs_clt *clt,
1179 for (path_it_init(&it, clt);
1180 (alive_sess = it.next_path(&it)) && it.i < it.clt->paths_num;
1206 struct rtrs_clt *clt = sess->clt;
1224 err = rtrs_clt_failover_req(clt, req);
1252 struct rtrs_clt *clt = sess->clt;
1269 req->sge = kmalloc_array(clt->max_segments + 1,
1295 static int alloc_permits(struct rtrs_clt *clt)
1300 clt->permits_map = kcalloc(BITS_TO_LONGS(clt->queue_depth),
1302 if (!clt->permits_map) {
1306 clt->permits = kcalloc(clt->queue_depth, permit_size(clt), GFP_KERNEL);
1307 if (!clt->permits) {
1311 chunk_bits = ilog2(clt->queue_depth - 1) + 1;
1312 for (i = 0; i < clt->queue_depth; i++) {
1315 permit = get_permit(clt, i);
1323 kfree(clt->permits_map);
1324 clt->permits_map = NULL;
1329 static void free_permits(struct rtrs_clt *clt)
1331 if (clt->permits_map) {
1332 size_t sz = clt->queue_depth;
1334 wait_event(clt->permits_wait,
1335 find_first_bit(clt->permits_map, sz) >= sz);
1337 kfree(clt->permits_map);
1338 clt->permits_map = NULL;
1339 kfree(clt->permits);
1340 clt->permits = NULL;
1416 static struct rtrs_clt_sess *alloc_sess(struct rtrs_clt *clt,
1453 strlcpy(sess->s.sessname, clt->sessname, sizeof(sess->s.sessname));
1455 sess->clt = clt;
1562 rtrs_wrn(sess->clt,
1665 struct rtrs_clt *clt = sess->clt;
1687 uuid_copy(&msg.paths_uuid, &clt->paths_uuid);
1691 rtrs_err(clt, "rdma_connect_locked(): %d\n", err);
1700 struct rtrs_clt *clt = sess->clt;
1709 rtrs_err(clt, "Invalid RTRS connection response\n");
1713 rtrs_err(clt, "Invalid RTRS magic\n");
1718 rtrs_err(clt, "Unsupported major RTRS version: %d, expected %d\n",
1724 rtrs_err(clt, "Invalid RTRS message: errno %d\n",
1732 rtrs_err(clt, "Error: queue depth changed\n");
1738 rtrs_err(clt,
1764 mutex_lock(&clt->paths_mutex);
1765 clt->queue_depth = sess->queue_depth;
1766 clt->max_io_size = min_not_zero(sess->max_io_size,
1767 clt->max_io_size);
1768 mutex_unlock(&clt->paths_mutex);
1982 struct rtrs_clt *clt = sess->clt;
1992 mutex_lock(&clt->paths_ev_mutex);
1993 up = ++clt->paths_up;
1999 if (up > MAX_PATHS_NUM && up == MAX_PATHS_NUM + clt->paths_num)
2000 clt->paths_up = clt->paths_num;
2002 clt->link_ev(clt->priv, RTRS_CLT_LINK_EV_RECONNECTED);
2003 mutex_unlock(&clt->paths_ev_mutex);
2013 struct rtrs_clt *clt = sess->clt;
2019 mutex_lock(&clt->paths_ev_mutex);
2020 WARN_ON(!clt->paths_up);
2021 if (--clt->paths_up == 0)
2022 clt->link_ev(clt->priv, RTRS_CLT_LINK_EV_DISCONNECTED);
2023 mutex_unlock(&clt->paths_ev_mutex);
2099 struct rtrs_clt *clt = sess->clt;
2104 mutex_lock(&clt->paths_mutex);
2130 * [!CONNECTED path] clt->paths_num--
2132 * load clt->paths_num from 2 to 1
2137 * ends, because expression i < clt->paths_num is false.
2139 clt->paths_num--;
2146 next = list_next_or_null_rr_rcu(&clt->paths_list, &sess->s.entry,
2157 ppcpu_path = per_cpu_ptr(clt->pcpu_path, cpu);
2159 lockdep_is_held(&clt->paths_mutex)) != sess)
2184 mutex_unlock(&clt->paths_mutex);
2190 struct rtrs_clt *clt = sess->clt;
2192 mutex_lock(&clt->paths_mutex);
2193 clt->paths_num++;
2195 list_add_tail_rcu(&sess->s.entry, &clt->paths_list);
2196 mutex_unlock(&clt->paths_mutex);
2271 rtrs_err(sess->clt, "Sess info request send failed: %s\n",
2296 rtrs_err(sess->clt,
2302 rtrs_err(sess->clt, "Incorrect sg_cnt %d, is not multiple\n",
2319 rtrs_err(sess->clt, "Incorrect [%d].len %d\n", sgi,
2333 rtrs_err(sess->clt, "Incorrect sg vector, not fully mapped\n");
2337 rtrs_err(sess->clt, "Incorrect total_len %d\n", total_len);
2359 rtrs_err(sess->clt, "Sess info response recv failed: %s\n",
2366 rtrs_err(sess->clt, "Sess info response is malformed: size %d\n",
2374 rtrs_err(sess->clt, "Sess info response is malformed: type %d\n",
2381 rtrs_err(sess->clt, "Sess info response is malformed: size %d\n",
2424 rtrs_err(sess->clt, "rtrs_iu_post_recv(), err: %d\n", err);
2439 rtrs_err(sess->clt, "rtrs_iu_post_send(), err: %d\n", err);
2482 rtrs_err(sess->clt, "init_conns(), err: %d\n", err);
2487 rtrs_err(sess->clt, "rtrs_send_sess_info(), err: %d\n", err);
2500 struct rtrs_clt *clt;
2506 clt = sess->clt;
2511 if (sess->reconnect_attempts >= clt->max_reconnect_attempts) {
2532 delay_ms = clt->reconnect_delay_sec * 1000;
2542 struct rtrs_clt *clt = container_of(dev, struct rtrs_clt, dev);
2544 mutex_destroy(&clt->paths_ev_mutex);
2545 mutex_destroy(&clt->paths_mutex);
2546 kfree(clt);
2558 struct rtrs_clt *clt;
2564 if (strlen(sessname) >= sizeof(clt->sessname))
2567 clt = kzalloc(sizeof(*clt), GFP_KERNEL);
2568 if (!clt)
2571 clt->pcpu_path = alloc_percpu(typeof(*clt->pcpu_path));
2572 if (!clt->pcpu_path) {
2573 kfree(clt);
2577 clt->dev.class = rtrs_clt_dev_class;
2578 clt->dev.release = rtrs_clt_dev_release;
2579 uuid_gen(&clt->paths_uuid);
2580 INIT_LIST_HEAD_RCU(&clt->paths_list);
2581 clt->paths_num = paths_num;
2582 clt->paths_up = MAX_PATHS_NUM;
2583 clt->port = port;
2584 clt->pdu_sz = pdu_sz;
2585 clt->max_segments = max_segments;
2586 clt->max_segment_size = max_segment_size;
2587 clt->reconnect_delay_sec = reconnect_delay_sec;
2588 clt->max_reconnect_attempts = max_reconnect_attempts;
2589 clt->priv = priv;
2590 clt->link_ev = link_ev;
2591 clt->mp_policy = MP_POLICY_MIN_INFLIGHT;
2592 strlcpy(clt->sessname, sessname, sizeof(clt->sessname));
2593 init_waitqueue_head(&clt->permits_wait);
2594 mutex_init(&clt->paths_ev_mutex);
2595 mutex_init(&clt->paths_mutex);
2596 device_initialize(&clt->dev);
2598 err = dev_set_name(&clt->dev, "%s", sessname);
2606 dev_set_uevent_suppress(&clt->dev, true);
2607 err = device_add(&clt->dev);
2611 clt->kobj_paths = kobject_create_and_add("paths", &clt->dev.kobj);
2612 if (!clt->kobj_paths) {
2616 err = rtrs_clt_create_sysfs_root_files(clt);
2618 kobject_del(clt->kobj_paths);
2619 kobject_put(clt->kobj_paths);
2622 dev_set_uevent_suppress(&clt->dev, false);
2623 kobject_uevent(&clt->dev.kobj, KOBJ_ADD);
2625 return clt;
2627 device_del(&clt->dev);
2629 free_percpu(clt->pcpu_path);
2630 put_device(&clt->dev);
2634 static void free_clt(struct rtrs_clt *clt)
2636 free_percpu(clt->pcpu_path);
2639 * release callback will free clt and destroy mutexes in last put
2641 device_unregister(&clt->dev);
2673 struct rtrs_clt *clt;
2676 clt = alloc_clt(sessname, paths_num, port, pdu_sz, ops->priv,
2680 if (IS_ERR(clt)) {
2681 err = PTR_ERR(clt);
2687 sess = alloc_sess(clt, &paths[i], nr_cpu_ids,
2695 list_add_tail_rcu(&sess->s.entry, &clt->paths_list);
2717 err = alloc_permits(clt);
2721 return clt;
2724 list_for_each_entry_safe(sess, tmp, &clt->paths_list, s.entry) {
2729 rtrs_clt_destroy_sysfs_root_files(clt);
2730 rtrs_clt_destroy_sysfs_root_folders(clt);
2731 free_clt(clt);
2740 * @clt: Session handle. Session is freed upon return.
2742 void rtrs_clt_close(struct rtrs_clt *clt)
2747 rtrs_clt_destroy_sysfs_root_files(clt);
2748 rtrs_clt_destroy_sysfs_root_folders(clt);
2751 list_for_each_entry_safe(sess, tmp, &clt->paths_list, s.entry) {
2756 free_permits(clt);
2757 free_clt(clt);
2825 void rtrs_clt_set_max_reconnect_attempts(struct rtrs_clt *clt, int value)
2827 clt->max_reconnect_attempts = (unsigned int)value;
2830 int rtrs_clt_get_max_reconnect_attempts(const struct rtrs_clt *clt)
2832 return (int)clt->max_reconnect_attempts;
2840 * @clt: Session
2860 struct rtrs_clt *clt, struct rtrs_permit *permit,
2886 for (path_it_init(&it, clt);
2887 (sess = it.next_path(&it)) && it.i < it.clt->paths_num; it.i++) {
2892 rtrs_wrn_rl(sess->clt,
2922 *@clt: session pointer
2928 int rtrs_clt_query(struct rtrs_clt *clt, struct rtrs_attrs *attr)
2930 if (!rtrs_clt_is_connected(clt))
2933 attr->queue_depth = clt->queue_depth;
2934 attr->max_io_size = clt->max_io_size;
2935 attr->sess_kobj = &clt->dev.kobj;
2936 strlcpy(attr->sessname, clt->sessname, sizeof(attr->sessname));
2942 int rtrs_clt_create_path_from_sysfs(struct rtrs_clt *clt,
2948 sess = alloc_sess(clt, addr, nr_cpu_ids, clt->max_segments,
2949 clt->max_segment_size);