1// SPDX-License-Identifier: GPL-2.0 2/* 3 * Copyright (c) 2020 Anna Schumaker <Anna.Schumaker@Netapp.com> 4 */ 5#include <linux/sunrpc/clnt.h> 6#include <linux/kobject.h> 7#include <linux/sunrpc/addr.h> 8#include <linux/sunrpc/xprtsock.h> 9 10#include "sysfs.h" 11 12struct xprt_addr { 13 const char *addr; 14 struct rcu_head rcu; 15}; 16 17static void free_xprt_addr(struct rcu_head *head) 18{ 19 struct xprt_addr *addr = container_of(head, struct xprt_addr, rcu); 20 21 kfree(addr->addr); 22 kfree(addr); 23} 24 25static struct kset *rpc_sunrpc_kset; 26static struct kobject *rpc_sunrpc_client_kobj, *rpc_sunrpc_xprt_switch_kobj; 27 28static void rpc_sysfs_object_release(struct kobject *kobj) 29{ 30 kfree(kobj); 31} 32 33static const struct kobj_ns_type_operations * 34rpc_sysfs_object_child_ns_type(const struct kobject *kobj) 35{ 36 return &net_ns_type_operations; 37} 38 39static const struct kobj_type rpc_sysfs_object_type = { 40 .release = rpc_sysfs_object_release, 41 .sysfs_ops = &kobj_sysfs_ops, 42 .child_ns_type = rpc_sysfs_object_child_ns_type, 43}; 44 45static struct kobject *rpc_sysfs_object_alloc(const char *name, 46 struct kset *kset, 47 struct kobject *parent) 48{ 49 struct kobject *kobj; 50 51 kobj = kzalloc(sizeof(*kobj), GFP_KERNEL); 52 if (kobj) { 53 kobj->kset = kset; 54 if (kobject_init_and_add(kobj, &rpc_sysfs_object_type, 55 parent, "%s", name) == 0) 56 return kobj; 57 kobject_put(kobj); 58 } 59 return NULL; 60} 61 62static inline struct rpc_xprt * 63rpc_sysfs_xprt_kobj_get_xprt(struct kobject *kobj) 64{ 65 struct rpc_sysfs_xprt *x = container_of(kobj, 66 struct rpc_sysfs_xprt, kobject); 67 68 return xprt_get(x->xprt); 69} 70 71static inline struct rpc_xprt_switch * 72rpc_sysfs_xprt_kobj_get_xprt_switch(struct kobject *kobj) 73{ 74 struct rpc_sysfs_xprt *x = container_of(kobj, 75 struct rpc_sysfs_xprt, kobject); 76 77 return xprt_switch_get(x->xprt_switch); 78} 79 80static inline struct rpc_xprt_switch * 81rpc_sysfs_xprt_switch_kobj_get_xprt(struct kobject *kobj) 82{ 83 struct rpc_sysfs_xprt_switch *x = container_of(kobj, 84 struct rpc_sysfs_xprt_switch, kobject); 85 86 return xprt_switch_get(x->xprt_switch); 87} 88 89static ssize_t rpc_sysfs_xprt_dstaddr_show(struct kobject *kobj, 90 struct kobj_attribute *attr, 91 char *buf) 92{ 93 struct rpc_xprt *xprt = rpc_sysfs_xprt_kobj_get_xprt(kobj); 94 ssize_t ret; 95 96 if (!xprt) { 97 ret = sprintf(buf, "<closed>\n"); 98 goto out; 99 } 100 ret = sprintf(buf, "%s\n", xprt->address_strings[RPC_DISPLAY_ADDR]); 101 xprt_put(xprt); 102out: 103 return ret; 104} 105 106static ssize_t rpc_sysfs_xprt_srcaddr_show(struct kobject *kobj, 107 struct kobj_attribute *attr, 108 char *buf) 109{ 110 struct rpc_xprt *xprt = rpc_sysfs_xprt_kobj_get_xprt(kobj); 111 size_t buflen = PAGE_SIZE; 112 ssize_t ret; 113 114 if (!xprt || !xprt_connected(xprt)) { 115 ret = sprintf(buf, "<closed>\n"); 116 } else if (xprt->ops->get_srcaddr) { 117 ret = xprt->ops->get_srcaddr(xprt, buf, buflen); 118 if (ret > 0) { 119 if (ret < buflen - 1) { 120 buf[ret] = '\n'; 121 ret++; 122 buf[ret] = '\0'; 123 } 124 } else 125 ret = sprintf(buf, "<closed>\n"); 126 } else 127 ret = sprintf(buf, "<not a socket>\n"); 128 xprt_put(xprt); 129 return ret; 130} 131 132static ssize_t rpc_sysfs_xprt_info_show(struct kobject *kobj, 133 struct kobj_attribute *attr, char *buf) 134{ 135 struct rpc_xprt *xprt = rpc_sysfs_xprt_kobj_get_xprt(kobj); 136 unsigned short srcport = 0; 137 size_t buflen = PAGE_SIZE; 138 ssize_t ret; 139 140 if (!xprt || !xprt_connected(xprt)) { 141 ret = sprintf(buf, "<closed>\n"); 142 goto out; 143 } 144 145 if (xprt->ops->get_srcport) 146 srcport = xprt->ops->get_srcport(xprt); 147 148 ret = snprintf(buf, buflen, 149 "last_used=%lu\ncur_cong=%lu\ncong_win=%lu\n" 150 "max_num_slots=%u\nmin_num_slots=%u\nnum_reqs=%u\n" 151 "binding_q_len=%u\nsending_q_len=%u\npending_q_len=%u\n" 152 "backlog_q_len=%u\nmain_xprt=%d\nsrc_port=%u\n" 153 "tasks_queuelen=%ld\ndst_port=%s\n", 154 xprt->last_used, xprt->cong, xprt->cwnd, xprt->max_reqs, 155 xprt->min_reqs, xprt->num_reqs, xprt->binding.qlen, 156 xprt->sending.qlen, xprt->pending.qlen, 157 xprt->backlog.qlen, xprt->main, srcport, 158 atomic_long_read(&xprt->queuelen), 159 xprt->address_strings[RPC_DISPLAY_PORT]); 160out: 161 xprt_put(xprt); 162 return ret; 163} 164 165static ssize_t rpc_sysfs_xprt_state_show(struct kobject *kobj, 166 struct kobj_attribute *attr, 167 char *buf) 168{ 169 struct rpc_xprt *xprt = rpc_sysfs_xprt_kobj_get_xprt(kobj); 170 ssize_t ret; 171 int locked, connected, connecting, close_wait, bound, binding, 172 closing, congested, cwnd_wait, write_space, offline, remove; 173 174 if (!(xprt && xprt->state)) { 175 ret = sprintf(buf, "state=CLOSED\n"); 176 } else { 177 locked = test_bit(XPRT_LOCKED, &xprt->state); 178 connected = test_bit(XPRT_CONNECTED, &xprt->state); 179 connecting = test_bit(XPRT_CONNECTING, &xprt->state); 180 close_wait = test_bit(XPRT_CLOSE_WAIT, &xprt->state); 181 bound = test_bit(XPRT_BOUND, &xprt->state); 182 binding = test_bit(XPRT_BINDING, &xprt->state); 183 closing = test_bit(XPRT_CLOSING, &xprt->state); 184 congested = test_bit(XPRT_CONGESTED, &xprt->state); 185 cwnd_wait = test_bit(XPRT_CWND_WAIT, &xprt->state); 186 write_space = test_bit(XPRT_WRITE_SPACE, &xprt->state); 187 offline = test_bit(XPRT_OFFLINE, &xprt->state); 188 remove = test_bit(XPRT_REMOVE, &xprt->state); 189 190 ret = sprintf(buf, "state=%s %s %s %s %s %s %s %s %s %s %s %s\n", 191 locked ? "LOCKED" : "", 192 connected ? "CONNECTED" : "", 193 connecting ? "CONNECTING" : "", 194 close_wait ? "CLOSE_WAIT" : "", 195 bound ? "BOUND" : "", 196 binding ? "BOUNDING" : "", 197 closing ? "CLOSING" : "", 198 congested ? "CONGESTED" : "", 199 cwnd_wait ? "CWND_WAIT" : "", 200 write_space ? "WRITE_SPACE" : "", 201 offline ? "OFFLINE" : "", 202 remove ? "REMOVE" : ""); 203 } 204 205 xprt_put(xprt); 206 return ret; 207} 208 209static ssize_t rpc_sysfs_xprt_switch_info_show(struct kobject *kobj, 210 struct kobj_attribute *attr, 211 char *buf) 212{ 213 struct rpc_xprt_switch *xprt_switch = 214 rpc_sysfs_xprt_switch_kobj_get_xprt(kobj); 215 ssize_t ret; 216 217 if (!xprt_switch) 218 return 0; 219 ret = sprintf(buf, "num_xprts=%u\nnum_active=%u\n" 220 "num_unique_destaddr=%u\nqueue_len=%ld\n", 221 xprt_switch->xps_nxprts, xprt_switch->xps_nactive, 222 xprt_switch->xps_nunique_destaddr_xprts, 223 atomic_long_read(&xprt_switch->xps_queuelen)); 224 xprt_switch_put(xprt_switch); 225 return ret; 226} 227 228static ssize_t rpc_sysfs_xprt_dstaddr_store(struct kobject *kobj, 229 struct kobj_attribute *attr, 230 const char *buf, size_t count) 231{ 232 struct rpc_xprt *xprt = rpc_sysfs_xprt_kobj_get_xprt(kobj); 233 struct sockaddr *saddr; 234 char *dst_addr; 235 int port; 236 struct xprt_addr *saved_addr; 237 size_t buf_len; 238 239 if (!xprt) 240 return 0; 241 if (!(xprt->xprt_class->ident == XPRT_TRANSPORT_TCP || 242 xprt->xprt_class->ident == XPRT_TRANSPORT_TCP_TLS || 243 xprt->xprt_class->ident == XPRT_TRANSPORT_RDMA)) { 244 xprt_put(xprt); 245 return -EOPNOTSUPP; 246 } 247 248 if (wait_on_bit_lock(&xprt->state, XPRT_LOCKED, TASK_KILLABLE)) { 249 count = -EINTR; 250 goto out_put; 251 } 252 saddr = (struct sockaddr *)&xprt->addr; 253 port = rpc_get_port(saddr); 254 255 /* buf_len is the len until the first occurence of either 256 * '\n' or '\0' 257 */ 258 buf_len = strcspn(buf, "\n"); 259 260 dst_addr = kstrndup(buf, buf_len, GFP_KERNEL); 261 if (!dst_addr) 262 goto out_err; 263 saved_addr = kzalloc(sizeof(*saved_addr), GFP_KERNEL); 264 if (!saved_addr) 265 goto out_err_free; 266 saved_addr->addr = 267 rcu_dereference_raw(xprt->address_strings[RPC_DISPLAY_ADDR]); 268 rcu_assign_pointer(xprt->address_strings[RPC_DISPLAY_ADDR], dst_addr); 269 call_rcu(&saved_addr->rcu, free_xprt_addr); 270 xprt->addrlen = rpc_pton(xprt->xprt_net, buf, buf_len, saddr, 271 sizeof(*saddr)); 272 rpc_set_port(saddr, port); 273 274 xprt_force_disconnect(xprt); 275out: 276 xprt_release_write(xprt, NULL); 277out_put: 278 xprt_put(xprt); 279 return count; 280out_err_free: 281 kfree(dst_addr); 282out_err: 283 count = -ENOMEM; 284 goto out; 285} 286 287static ssize_t rpc_sysfs_xprt_state_change(struct kobject *kobj, 288 struct kobj_attribute *attr, 289 const char *buf, size_t count) 290{ 291 struct rpc_xprt *xprt = rpc_sysfs_xprt_kobj_get_xprt(kobj); 292 int offline = 0, online = 0, remove = 0; 293 struct rpc_xprt_switch *xps = rpc_sysfs_xprt_kobj_get_xprt_switch(kobj); 294 295 if (!xprt || !xps) { 296 count = 0; 297 goto out_put; 298 } 299 300 if (!strncmp(buf, "offline", 7)) 301 offline = 1; 302 else if (!strncmp(buf, "online", 6)) 303 online = 1; 304 else if (!strncmp(buf, "remove", 6)) 305 remove = 1; 306 else { 307 count = -EINVAL; 308 goto out_put; 309 } 310 311 if (wait_on_bit_lock(&xprt->state, XPRT_LOCKED, TASK_KILLABLE)) { 312 count = -EINTR; 313 goto out_put; 314 } 315 if (xprt->main) { 316 count = -EINVAL; 317 goto release_tasks; 318 } 319 if (offline) { 320 xprt_set_offline_locked(xprt, xps); 321 } else if (online) { 322 xprt_set_online_locked(xprt, xps); 323 } else if (remove) { 324 if (test_bit(XPRT_OFFLINE, &xprt->state)) 325 xprt_delete_locked(xprt, xps); 326 else 327 count = -EINVAL; 328 } 329 330release_tasks: 331 xprt_release_write(xprt, NULL); 332out_put: 333 xprt_put(xprt); 334 xprt_switch_put(xps); 335 return count; 336} 337 338int rpc_sysfs_init(void) 339{ 340 rpc_sunrpc_kset = kset_create_and_add("sunrpc", NULL, kernel_kobj); 341 if (!rpc_sunrpc_kset) 342 return -ENOMEM; 343 rpc_sunrpc_client_kobj = 344 rpc_sysfs_object_alloc("rpc-clients", rpc_sunrpc_kset, NULL); 345 if (!rpc_sunrpc_client_kobj) 346 goto err_client; 347 rpc_sunrpc_xprt_switch_kobj = 348 rpc_sysfs_object_alloc("xprt-switches", rpc_sunrpc_kset, NULL); 349 if (!rpc_sunrpc_xprt_switch_kobj) 350 goto err_switch; 351 return 0; 352err_switch: 353 kobject_put(rpc_sunrpc_client_kobj); 354 rpc_sunrpc_client_kobj = NULL; 355err_client: 356 kset_unregister(rpc_sunrpc_kset); 357 rpc_sunrpc_kset = NULL; 358 return -ENOMEM; 359} 360 361static void rpc_sysfs_client_release(struct kobject *kobj) 362{ 363 struct rpc_sysfs_client *c; 364 365 c = container_of(kobj, struct rpc_sysfs_client, kobject); 366 kfree(c); 367} 368 369static void rpc_sysfs_xprt_switch_release(struct kobject *kobj) 370{ 371 struct rpc_sysfs_xprt_switch *xprt_switch; 372 373 xprt_switch = container_of(kobj, struct rpc_sysfs_xprt_switch, kobject); 374 kfree(xprt_switch); 375} 376 377static void rpc_sysfs_xprt_release(struct kobject *kobj) 378{ 379 struct rpc_sysfs_xprt *xprt; 380 381 xprt = container_of(kobj, struct rpc_sysfs_xprt, kobject); 382 kfree(xprt); 383} 384 385static const void *rpc_sysfs_client_namespace(const struct kobject *kobj) 386{ 387 return container_of(kobj, struct rpc_sysfs_client, kobject)->net; 388} 389 390static const void *rpc_sysfs_xprt_switch_namespace(const struct kobject *kobj) 391{ 392 return container_of(kobj, struct rpc_sysfs_xprt_switch, kobject)->net; 393} 394 395static const void *rpc_sysfs_xprt_namespace(const struct kobject *kobj) 396{ 397 return container_of(kobj, struct rpc_sysfs_xprt, 398 kobject)->xprt->xprt_net; 399} 400 401static struct kobj_attribute rpc_sysfs_xprt_dstaddr = __ATTR(dstaddr, 402 0644, rpc_sysfs_xprt_dstaddr_show, rpc_sysfs_xprt_dstaddr_store); 403 404static struct kobj_attribute rpc_sysfs_xprt_srcaddr = __ATTR(srcaddr, 405 0644, rpc_sysfs_xprt_srcaddr_show, NULL); 406 407static struct kobj_attribute rpc_sysfs_xprt_info = __ATTR(xprt_info, 408 0444, rpc_sysfs_xprt_info_show, NULL); 409 410static struct kobj_attribute rpc_sysfs_xprt_change_state = __ATTR(xprt_state, 411 0644, rpc_sysfs_xprt_state_show, rpc_sysfs_xprt_state_change); 412 413static struct attribute *rpc_sysfs_xprt_attrs[] = { 414 &rpc_sysfs_xprt_dstaddr.attr, 415 &rpc_sysfs_xprt_srcaddr.attr, 416 &rpc_sysfs_xprt_info.attr, 417 &rpc_sysfs_xprt_change_state.attr, 418 NULL, 419}; 420ATTRIBUTE_GROUPS(rpc_sysfs_xprt); 421 422static struct kobj_attribute rpc_sysfs_xprt_switch_info = 423 __ATTR(xprt_switch_info, 0444, rpc_sysfs_xprt_switch_info_show, NULL); 424 425static struct attribute *rpc_sysfs_xprt_switch_attrs[] = { 426 &rpc_sysfs_xprt_switch_info.attr, 427 NULL, 428}; 429ATTRIBUTE_GROUPS(rpc_sysfs_xprt_switch); 430 431static const struct kobj_type rpc_sysfs_client_type = { 432 .release = rpc_sysfs_client_release, 433 .sysfs_ops = &kobj_sysfs_ops, 434 .namespace = rpc_sysfs_client_namespace, 435}; 436 437static const struct kobj_type rpc_sysfs_xprt_switch_type = { 438 .release = rpc_sysfs_xprt_switch_release, 439 .default_groups = rpc_sysfs_xprt_switch_groups, 440 .sysfs_ops = &kobj_sysfs_ops, 441 .namespace = rpc_sysfs_xprt_switch_namespace, 442}; 443 444static const struct kobj_type rpc_sysfs_xprt_type = { 445 .release = rpc_sysfs_xprt_release, 446 .default_groups = rpc_sysfs_xprt_groups, 447 .sysfs_ops = &kobj_sysfs_ops, 448 .namespace = rpc_sysfs_xprt_namespace, 449}; 450 451void rpc_sysfs_exit(void) 452{ 453 kobject_put(rpc_sunrpc_client_kobj); 454 kobject_put(rpc_sunrpc_xprt_switch_kobj); 455 kset_unregister(rpc_sunrpc_kset); 456} 457 458static struct rpc_sysfs_client *rpc_sysfs_client_alloc(struct kobject *parent, 459 struct net *net, 460 int clid) 461{ 462 struct rpc_sysfs_client *p; 463 464 p = kzalloc(sizeof(*p), GFP_KERNEL); 465 if (p) { 466 p->net = net; 467 p->kobject.kset = rpc_sunrpc_kset; 468 if (kobject_init_and_add(&p->kobject, &rpc_sysfs_client_type, 469 parent, "clnt-%d", clid) == 0) 470 return p; 471 kobject_put(&p->kobject); 472 } 473 return NULL; 474} 475 476static struct rpc_sysfs_xprt_switch * 477rpc_sysfs_xprt_switch_alloc(struct kobject *parent, 478 struct rpc_xprt_switch *xprt_switch, 479 struct net *net, 480 gfp_t gfp_flags) 481{ 482 struct rpc_sysfs_xprt_switch *p; 483 484 p = kzalloc(sizeof(*p), gfp_flags); 485 if (p) { 486 p->net = net; 487 p->kobject.kset = rpc_sunrpc_kset; 488 if (kobject_init_and_add(&p->kobject, 489 &rpc_sysfs_xprt_switch_type, 490 parent, "switch-%d", 491 xprt_switch->xps_id) == 0) 492 return p; 493 kobject_put(&p->kobject); 494 } 495 return NULL; 496} 497 498static struct rpc_sysfs_xprt *rpc_sysfs_xprt_alloc(struct kobject *parent, 499 struct rpc_xprt *xprt, 500 gfp_t gfp_flags) 501{ 502 struct rpc_sysfs_xprt *p; 503 504 p = kzalloc(sizeof(*p), gfp_flags); 505 if (!p) 506 goto out; 507 p->kobject.kset = rpc_sunrpc_kset; 508 if (kobject_init_and_add(&p->kobject, &rpc_sysfs_xprt_type, 509 parent, "xprt-%d-%s", xprt->id, 510 xprt->address_strings[RPC_DISPLAY_PROTO]) == 0) 511 return p; 512 kobject_put(&p->kobject); 513out: 514 return NULL; 515} 516 517void rpc_sysfs_client_setup(struct rpc_clnt *clnt, 518 struct rpc_xprt_switch *xprt_switch, 519 struct net *net) 520{ 521 struct rpc_sysfs_client *rpc_client; 522 struct rpc_sysfs_xprt_switch *xswitch = 523 (struct rpc_sysfs_xprt_switch *)xprt_switch->xps_sysfs; 524 525 if (!xswitch) 526 return; 527 528 rpc_client = rpc_sysfs_client_alloc(rpc_sunrpc_client_kobj, 529 net, clnt->cl_clid); 530 if (rpc_client) { 531 char name[] = "switch"; 532 int ret; 533 534 clnt->cl_sysfs = rpc_client; 535 rpc_client->clnt = clnt; 536 rpc_client->xprt_switch = xprt_switch; 537 kobject_uevent(&rpc_client->kobject, KOBJ_ADD); 538 ret = sysfs_create_link_nowarn(&rpc_client->kobject, 539 &xswitch->kobject, name); 540 if (ret) 541 pr_warn("can't create link to %s in sysfs (%d)\n", 542 name, ret); 543 } 544} 545 546void rpc_sysfs_xprt_switch_setup(struct rpc_xprt_switch *xprt_switch, 547 struct rpc_xprt *xprt, 548 gfp_t gfp_flags) 549{ 550 struct rpc_sysfs_xprt_switch *rpc_xprt_switch; 551 struct net *net; 552 553 if (xprt_switch->xps_net) 554 net = xprt_switch->xps_net; 555 else 556 net = xprt->xprt_net; 557 rpc_xprt_switch = 558 rpc_sysfs_xprt_switch_alloc(rpc_sunrpc_xprt_switch_kobj, 559 xprt_switch, net, gfp_flags); 560 if (rpc_xprt_switch) { 561 xprt_switch->xps_sysfs = rpc_xprt_switch; 562 rpc_xprt_switch->xprt_switch = xprt_switch; 563 rpc_xprt_switch->xprt = xprt; 564 kobject_uevent(&rpc_xprt_switch->kobject, KOBJ_ADD); 565 } else { 566 xprt_switch->xps_sysfs = NULL; 567 } 568} 569 570void rpc_sysfs_xprt_setup(struct rpc_xprt_switch *xprt_switch, 571 struct rpc_xprt *xprt, 572 gfp_t gfp_flags) 573{ 574 struct rpc_sysfs_xprt *rpc_xprt; 575 struct rpc_sysfs_xprt_switch *switch_obj = 576 (struct rpc_sysfs_xprt_switch *)xprt_switch->xps_sysfs; 577 578 if (!switch_obj) 579 return; 580 581 rpc_xprt = rpc_sysfs_xprt_alloc(&switch_obj->kobject, xprt, gfp_flags); 582 if (rpc_xprt) { 583 xprt->xprt_sysfs = rpc_xprt; 584 rpc_xprt->xprt = xprt; 585 rpc_xprt->xprt_switch = xprt_switch; 586 kobject_uevent(&rpc_xprt->kobject, KOBJ_ADD); 587 } 588} 589 590void rpc_sysfs_client_destroy(struct rpc_clnt *clnt) 591{ 592 struct rpc_sysfs_client *rpc_client = clnt->cl_sysfs; 593 594 if (rpc_client) { 595 char name[] = "switch"; 596 597 sysfs_remove_link(&rpc_client->kobject, name); 598 kobject_uevent(&rpc_client->kobject, KOBJ_REMOVE); 599 kobject_del(&rpc_client->kobject); 600 kobject_put(&rpc_client->kobject); 601 clnt->cl_sysfs = NULL; 602 } 603} 604 605void rpc_sysfs_xprt_switch_destroy(struct rpc_xprt_switch *xprt_switch) 606{ 607 struct rpc_sysfs_xprt_switch *rpc_xprt_switch = xprt_switch->xps_sysfs; 608 609 if (rpc_xprt_switch) { 610 kobject_uevent(&rpc_xprt_switch->kobject, KOBJ_REMOVE); 611 kobject_del(&rpc_xprt_switch->kobject); 612 kobject_put(&rpc_xprt_switch->kobject); 613 xprt_switch->xps_sysfs = NULL; 614 } 615} 616 617void rpc_sysfs_xprt_destroy(struct rpc_xprt *xprt) 618{ 619 struct rpc_sysfs_xprt *rpc_xprt = xprt->xprt_sysfs; 620 621 if (rpc_xprt) { 622 kobject_uevent(&rpc_xprt->kobject, KOBJ_REMOVE); 623 kobject_del(&rpc_xprt->kobject); 624 kobject_put(&rpc_xprt->kobject); 625 xprt->xprt_sysfs = NULL; 626 } 627} 628