Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * RDMA Transport Layer
0004  *
0005  * Copyright (c) 2014 - 2018 ProfitBricks GmbH. All rights reserved.
0006  * Copyright (c) 2018 - 2019 1&1 IONOS Cloud GmbH. All rights reserved.
0007  * Copyright (c) 2019 - 2020 1&1 IONOS SE. All rights reserved.
0008  */
0009 #undef pr_fmt
0010 #define pr_fmt(fmt) KBUILD_MODNAME " L" __stringify(__LINE__) ": " fmt
0011 
0012 #include "rtrs-pri.h"
0013 #include "rtrs-clt.h"
0014 #include "rtrs-log.h"
0015 
0016 #define MIN_MAX_RECONN_ATT -1
0017 #define MAX_MAX_RECONN_ATT 9999
0018 
0019 static void rtrs_clt_path_release(struct kobject *kobj)
0020 {
0021     struct rtrs_clt_path *clt_path;
0022 
0023     clt_path = container_of(kobj, struct rtrs_clt_path, kobj);
0024 
0025     free_path(clt_path);
0026 }
0027 
0028 static struct kobj_type ktype_sess = {
0029     .sysfs_ops = &kobj_sysfs_ops,
0030     .release = rtrs_clt_path_release
0031 };
0032 
0033 static void rtrs_clt_path_stats_release(struct kobject *kobj)
0034 {
0035     struct rtrs_clt_stats *stats;
0036 
0037     stats = container_of(kobj, struct rtrs_clt_stats, kobj_stats);
0038 
0039     free_percpu(stats->pcpu_stats);
0040 
0041     kfree(stats);
0042 }
0043 
0044 static struct kobj_type ktype_stats = {
0045     .sysfs_ops = &kobj_sysfs_ops,
0046     .release = rtrs_clt_path_stats_release,
0047 };
0048 
0049 static ssize_t max_reconnect_attempts_show(struct device *dev,
0050                        struct device_attribute *attr,
0051                        char *page)
0052 {
0053     struct rtrs_clt_sess *clt = container_of(dev, struct rtrs_clt_sess,
0054                          dev);
0055 
0056     return sysfs_emit(page, "%d\n",
0057               rtrs_clt_get_max_reconnect_attempts(clt));
0058 }
0059 
0060 static ssize_t max_reconnect_attempts_store(struct device *dev,
0061                         struct device_attribute *attr,
0062                         const char *buf,
0063                         size_t count)
0064 {
0065     int value;
0066     int ret;
0067     struct rtrs_clt_sess *clt  = container_of(dev, struct rtrs_clt_sess,
0068                           dev);
0069 
0070     ret = kstrtoint(buf, 10, &value);
0071     if (ret) {
0072         rtrs_err(clt, "%s: failed to convert string '%s' to int\n",
0073               attr->attr.name, buf);
0074         return ret;
0075     }
0076     if (value > MAX_MAX_RECONN_ATT ||
0077              value < MIN_MAX_RECONN_ATT) {
0078         rtrs_err(clt,
0079               "%s: invalid range (provided: '%s', accepted: min: %d, max: %d)\n",
0080               attr->attr.name, buf, MIN_MAX_RECONN_ATT,
0081               MAX_MAX_RECONN_ATT);
0082         return -EINVAL;
0083     }
0084     rtrs_clt_set_max_reconnect_attempts(clt, value);
0085 
0086     return count;
0087 }
0088 
0089 static DEVICE_ATTR_RW(max_reconnect_attempts);
0090 
0091 static ssize_t mpath_policy_show(struct device *dev,
0092                  struct device_attribute *attr,
0093                  char *page)
0094 {
0095     struct rtrs_clt_sess *clt;
0096 
0097     clt = container_of(dev, struct rtrs_clt_sess, dev);
0098 
0099     switch (clt->mp_policy) {
0100     case MP_POLICY_RR:
0101         return sysfs_emit(page, "round-robin (RR: %d)\n",
0102                   clt->mp_policy);
0103     case MP_POLICY_MIN_INFLIGHT:
0104         return sysfs_emit(page, "min-inflight (MI: %d)\n",
0105                   clt->mp_policy);
0106     case MP_POLICY_MIN_LATENCY:
0107         return sysfs_emit(page, "min-latency (ML: %d)\n",
0108                   clt->mp_policy);
0109     default:
0110         return sysfs_emit(page, "Unknown (%d)\n", clt->mp_policy);
0111     }
0112 }
0113 
0114 static ssize_t mpath_policy_store(struct device *dev,
0115                   struct device_attribute *attr,
0116                   const char *buf,
0117                   size_t count)
0118 {
0119     struct rtrs_clt_sess *clt;
0120     int value;
0121     int ret;
0122     size_t len = 0;
0123 
0124     clt = container_of(dev, struct rtrs_clt_sess, dev);
0125 
0126     ret = kstrtoint(buf, 10, &value);
0127     if (!ret && (value == MP_POLICY_RR ||
0128              value == MP_POLICY_MIN_INFLIGHT ||
0129              value == MP_POLICY_MIN_LATENCY)) {
0130         clt->mp_policy = value;
0131         return count;
0132     }
0133 
0134     /* distinguish "mi" and "min-latency" with length */
0135     len = strnlen(buf, NAME_MAX);
0136     if (buf[len - 1] == '\n')
0137         len--;
0138 
0139     if (!strncasecmp(buf, "round-robin", 11) ||
0140         (len == 2 && !strncasecmp(buf, "rr", 2)))
0141         clt->mp_policy = MP_POLICY_RR;
0142     else if (!strncasecmp(buf, "min-inflight", 12) ||
0143          (len == 2 && !strncasecmp(buf, "mi", 2)))
0144         clt->mp_policy = MP_POLICY_MIN_INFLIGHT;
0145     else if (!strncasecmp(buf, "min-latency", 11) ||
0146          (len == 2 && !strncasecmp(buf, "ml", 2)))
0147         clt->mp_policy = MP_POLICY_MIN_LATENCY;
0148     else
0149         return -EINVAL;
0150 
0151     return count;
0152 }
0153 
0154 static DEVICE_ATTR_RW(mpath_policy);
0155 
0156 static ssize_t add_path_show(struct device *dev,
0157                  struct device_attribute *attr, char *page)
0158 {
0159     return sysfs_emit(page,
0160         "Usage: echo [<source addr>@]<destination addr> > %s\n\n*addr ::= [ ip:<ipv4|ipv6> | gid:<gid> ]\n",
0161         attr->attr.name);
0162 }
0163 
0164 static ssize_t add_path_store(struct device *dev,
0165                   struct device_attribute *attr,
0166                   const char *buf, size_t count)
0167 {
0168     struct sockaddr_storage srcaddr, dstaddr;
0169     struct rtrs_addr addr = {
0170         .src = &srcaddr,
0171         .dst = &dstaddr
0172     };
0173     struct rtrs_clt_sess *clt;
0174     const char *nl;
0175     size_t len;
0176     int err;
0177 
0178     clt = container_of(dev, struct rtrs_clt_sess, dev);
0179 
0180     nl = strchr(buf, '\n');
0181     if (nl)
0182         len = nl - buf;
0183     else
0184         len = count;
0185     err = rtrs_addr_to_sockaddr(buf, len, clt->port, &addr);
0186     if (err)
0187         return -EINVAL;
0188 
0189     err = rtrs_clt_create_path_from_sysfs(clt, &addr);
0190     if (err)
0191         return err;
0192 
0193     return count;
0194 }
0195 
0196 static DEVICE_ATTR_RW(add_path);
0197 
0198 static ssize_t rtrs_clt_state_show(struct kobject *kobj,
0199                     struct kobj_attribute *attr, char *page)
0200 {
0201     struct rtrs_clt_path *clt_path;
0202 
0203     clt_path = container_of(kobj, struct rtrs_clt_path, kobj);
0204     if (clt_path->state == RTRS_CLT_CONNECTED)
0205         return sysfs_emit(page, "connected\n");
0206 
0207     return sysfs_emit(page, "disconnected\n");
0208 }
0209 
0210 static struct kobj_attribute rtrs_clt_state_attr =
0211     __ATTR(state, 0444, rtrs_clt_state_show, NULL);
0212 
0213 static ssize_t rtrs_clt_reconnect_show(struct kobject *kobj,
0214                        struct kobj_attribute *attr, char *buf)
0215 {
0216     return sysfs_emit(buf, "Usage: echo 1 > %s\n", attr->attr.name);
0217 }
0218 
0219 static ssize_t rtrs_clt_reconnect_store(struct kobject *kobj,
0220                      struct kobj_attribute *attr,
0221                      const char *buf, size_t count)
0222 {
0223     struct rtrs_clt_path *clt_path;
0224     int ret;
0225 
0226     clt_path = container_of(kobj, struct rtrs_clt_path, kobj);
0227     if (!sysfs_streq(buf, "1")) {
0228         rtrs_err(clt_path->clt, "%s: unknown value: '%s'\n",
0229               attr->attr.name, buf);
0230         return -EINVAL;
0231     }
0232     ret = rtrs_clt_reconnect_from_sysfs(clt_path);
0233     if (ret)
0234         return ret;
0235 
0236     return count;
0237 }
0238 
0239 static struct kobj_attribute rtrs_clt_reconnect_attr =
0240     __ATTR(reconnect, 0644, rtrs_clt_reconnect_show,
0241            rtrs_clt_reconnect_store);
0242 
0243 static ssize_t rtrs_clt_disconnect_show(struct kobject *kobj,
0244                     struct kobj_attribute *attr, char *buf)
0245 {
0246     return sysfs_emit(buf, "Usage: echo 1 > %s\n", attr->attr.name);
0247 }
0248 
0249 static ssize_t rtrs_clt_disconnect_store(struct kobject *kobj,
0250                       struct kobj_attribute *attr,
0251                       const char *buf, size_t count)
0252 {
0253     struct rtrs_clt_path *clt_path;
0254 
0255     clt_path = container_of(kobj, struct rtrs_clt_path, kobj);
0256     if (!sysfs_streq(buf, "1")) {
0257         rtrs_err(clt_path->clt, "%s: unknown value: '%s'\n",
0258               attr->attr.name, buf);
0259         return -EINVAL;
0260     }
0261     rtrs_clt_close_conns(clt_path, true);
0262 
0263     return count;
0264 }
0265 
0266 static struct kobj_attribute rtrs_clt_disconnect_attr =
0267     __ATTR(disconnect, 0644, rtrs_clt_disconnect_show,
0268            rtrs_clt_disconnect_store);
0269 
0270 static ssize_t rtrs_clt_remove_path_show(struct kobject *kobj,
0271                      struct kobj_attribute *attr, char *buf)
0272 {
0273     return sysfs_emit(buf, "Usage: echo 1 > %s\n", attr->attr.name);
0274 }
0275 
0276 static ssize_t rtrs_clt_remove_path_store(struct kobject *kobj,
0277                        struct kobj_attribute *attr,
0278                        const char *buf, size_t count)
0279 {
0280     struct rtrs_clt_path *clt_path;
0281     int ret;
0282 
0283     clt_path = container_of(kobj, struct rtrs_clt_path, kobj);
0284     if (!sysfs_streq(buf, "1")) {
0285         rtrs_err(clt_path->clt, "%s: unknown value: '%s'\n",
0286               attr->attr.name, buf);
0287         return -EINVAL;
0288     }
0289     ret = rtrs_clt_remove_path_from_sysfs(clt_path, &attr->attr);
0290     if (ret)
0291         return ret;
0292 
0293     return count;
0294 }
0295 
0296 static struct kobj_attribute rtrs_clt_remove_path_attr =
0297     __ATTR(remove_path, 0644, rtrs_clt_remove_path_show,
0298            rtrs_clt_remove_path_store);
0299 
0300 STAT_ATTR(struct rtrs_clt_stats, cpu_migration_from,
0301       rtrs_clt_stats_migration_from_cnt_to_str,
0302       rtrs_clt_reset_cpu_migr_stats);
0303 
0304 STAT_ATTR(struct rtrs_clt_stats, cpu_migration_to,
0305       rtrs_clt_stats_migration_to_cnt_to_str,
0306       rtrs_clt_reset_cpu_migr_stats);
0307 
0308 STAT_ATTR(struct rtrs_clt_stats, reconnects,
0309       rtrs_clt_stats_reconnects_to_str,
0310       rtrs_clt_reset_reconnects_stat);
0311 
0312 STAT_ATTR(struct rtrs_clt_stats, rdma,
0313       rtrs_clt_stats_rdma_to_str,
0314       rtrs_clt_reset_rdma_stats);
0315 
0316 STAT_ATTR(struct rtrs_clt_stats, reset_all,
0317       rtrs_clt_reset_all_help,
0318       rtrs_clt_reset_all_stats);
0319 
0320 static struct attribute *rtrs_clt_stats_attrs[] = {
0321     &cpu_migration_from_attr.attr,
0322     &cpu_migration_to_attr.attr,
0323     &reconnects_attr.attr,
0324     &rdma_attr.attr,
0325     &reset_all_attr.attr,
0326     NULL
0327 };
0328 
0329 static const struct attribute_group rtrs_clt_stats_attr_group = {
0330     .attrs = rtrs_clt_stats_attrs,
0331 };
0332 
0333 static ssize_t rtrs_clt_hca_port_show(struct kobject *kobj,
0334                        struct kobj_attribute *attr,
0335                        char *page)
0336 {
0337     struct rtrs_clt_path *clt_path;
0338 
0339     clt_path = container_of(kobj, typeof(*clt_path), kobj);
0340 
0341     return sysfs_emit(page, "%u\n", clt_path->hca_port);
0342 }
0343 
0344 static struct kobj_attribute rtrs_clt_hca_port_attr =
0345     __ATTR(hca_port, 0444, rtrs_clt_hca_port_show, NULL);
0346 
0347 static ssize_t rtrs_clt_hca_name_show(struct kobject *kobj,
0348                        struct kobj_attribute *attr,
0349                        char *page)
0350 {
0351     struct rtrs_clt_path *clt_path;
0352 
0353     clt_path = container_of(kobj, struct rtrs_clt_path, kobj);
0354 
0355     return sysfs_emit(page, "%s\n", clt_path->hca_name);
0356 }
0357 
0358 static struct kobj_attribute rtrs_clt_hca_name_attr =
0359     __ATTR(hca_name, 0444, rtrs_clt_hca_name_show, NULL);
0360 
0361 static ssize_t rtrs_clt_cur_latency_show(struct kobject *kobj,
0362                     struct kobj_attribute *attr,
0363                     char *page)
0364 {
0365     struct rtrs_clt_path *clt_path;
0366 
0367     clt_path = container_of(kobj, struct rtrs_clt_path, kobj);
0368 
0369     return sysfs_emit(page, "%lld ns\n",
0370               ktime_to_ns(clt_path->s.hb_cur_latency));
0371 }
0372 
0373 static struct kobj_attribute rtrs_clt_cur_latency_attr =
0374     __ATTR(cur_latency, 0444, rtrs_clt_cur_latency_show, NULL);
0375 
0376 static ssize_t rtrs_clt_src_addr_show(struct kobject *kobj,
0377                        struct kobj_attribute *attr,
0378                        char *page)
0379 {
0380     struct rtrs_clt_path *clt_path;
0381     int len;
0382 
0383     clt_path = container_of(kobj, struct rtrs_clt_path, kobj);
0384     len = sockaddr_to_str((struct sockaddr *)&clt_path->s.src_addr, page,
0385                   PAGE_SIZE);
0386     len += sysfs_emit_at(page, len, "\n");
0387     return len;
0388 }
0389 
0390 static struct kobj_attribute rtrs_clt_src_addr_attr =
0391     __ATTR(src_addr, 0444, rtrs_clt_src_addr_show, NULL);
0392 
0393 static ssize_t rtrs_clt_dst_addr_show(struct kobject *kobj,
0394                        struct kobj_attribute *attr,
0395                        char *page)
0396 {
0397     struct rtrs_clt_path *clt_path;
0398     int len;
0399 
0400     clt_path = container_of(kobj, struct rtrs_clt_path, kobj);
0401     len = sockaddr_to_str((struct sockaddr *)&clt_path->s.dst_addr, page,
0402                   PAGE_SIZE);
0403     len += sysfs_emit_at(page, len, "\n");
0404     return len;
0405 }
0406 
0407 static struct kobj_attribute rtrs_clt_dst_addr_attr =
0408     __ATTR(dst_addr, 0444, rtrs_clt_dst_addr_show, NULL);
0409 
0410 static struct attribute *rtrs_clt_path_attrs[] = {
0411     &rtrs_clt_hca_name_attr.attr,
0412     &rtrs_clt_hca_port_attr.attr,
0413     &rtrs_clt_src_addr_attr.attr,
0414     &rtrs_clt_dst_addr_attr.attr,
0415     &rtrs_clt_state_attr.attr,
0416     &rtrs_clt_reconnect_attr.attr,
0417     &rtrs_clt_disconnect_attr.attr,
0418     &rtrs_clt_remove_path_attr.attr,
0419     &rtrs_clt_cur_latency_attr.attr,
0420     NULL,
0421 };
0422 
0423 static const struct attribute_group rtrs_clt_path_attr_group = {
0424     .attrs = rtrs_clt_path_attrs,
0425 };
0426 
0427 int rtrs_clt_create_path_files(struct rtrs_clt_path *clt_path)
0428 {
0429     struct rtrs_clt_sess *clt = clt_path->clt;
0430     char str[NAME_MAX];
0431     int err;
0432     struct rtrs_addr path = {
0433         .src = &clt_path->s.src_addr,
0434         .dst = &clt_path->s.dst_addr,
0435     };
0436 
0437     rtrs_addr_to_str(&path, str, sizeof(str));
0438     err = kobject_init_and_add(&clt_path->kobj, &ktype_sess,
0439                    clt->kobj_paths,
0440                    "%s", str);
0441     if (err) {
0442         pr_err("kobject_init_and_add: %d\n", err);
0443         kobject_put(&clt_path->kobj);
0444         return err;
0445     }
0446     err = sysfs_create_group(&clt_path->kobj, &rtrs_clt_path_attr_group);
0447     if (err) {
0448         pr_err("sysfs_create_group(): %d\n", err);
0449         goto put_kobj;
0450     }
0451     err = kobject_init_and_add(&clt_path->stats->kobj_stats, &ktype_stats,
0452                    &clt_path->kobj, "stats");
0453     if (err) {
0454         pr_err("kobject_init_and_add: %d\n", err);
0455         kobject_put(&clt_path->stats->kobj_stats);
0456         goto remove_group;
0457     }
0458 
0459     err = sysfs_create_group(&clt_path->stats->kobj_stats,
0460                  &rtrs_clt_stats_attr_group);
0461     if (err) {
0462         pr_err("failed to create stats sysfs group, err: %d\n", err);
0463         goto put_kobj_stats;
0464     }
0465 
0466     return 0;
0467 
0468 put_kobj_stats:
0469     kobject_del(&clt_path->stats->kobj_stats);
0470     kobject_put(&clt_path->stats->kobj_stats);
0471 remove_group:
0472     sysfs_remove_group(&clt_path->kobj, &rtrs_clt_path_attr_group);
0473 put_kobj:
0474     kobject_del(&clt_path->kobj);
0475     kobject_put(&clt_path->kobj);
0476 
0477     return err;
0478 }
0479 
0480 void rtrs_clt_destroy_path_files(struct rtrs_clt_path *clt_path,
0481                   const struct attribute *sysfs_self)
0482 {
0483     kobject_del(&clt_path->stats->kobj_stats);
0484     kobject_put(&clt_path->stats->kobj_stats);
0485     if (sysfs_self)
0486         sysfs_remove_file_self(&clt_path->kobj, sysfs_self);
0487     kobject_del(&clt_path->kobj);
0488 }
0489 
0490 static struct attribute *rtrs_clt_attrs[] = {
0491     &dev_attr_max_reconnect_attempts.attr,
0492     &dev_attr_mpath_policy.attr,
0493     &dev_attr_add_path.attr,
0494     NULL,
0495 };
0496 
0497 static const struct attribute_group rtrs_clt_attr_group = {
0498     .attrs = rtrs_clt_attrs,
0499 };
0500 
0501 int rtrs_clt_create_sysfs_root_files(struct rtrs_clt_sess *clt)
0502 {
0503     return sysfs_create_group(&clt->dev.kobj, &rtrs_clt_attr_group);
0504 }
0505 
0506 void rtrs_clt_destroy_sysfs_root(struct rtrs_clt_sess *clt)
0507 {
0508     sysfs_remove_group(&clt->dev.kobj, &rtrs_clt_attr_group);
0509 
0510     if (clt->kobj_paths) {
0511         kobject_del(clt->kobj_paths);
0512         kobject_put(clt->kobj_paths);
0513     }
0514 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!