Whamcloud - gitweb
make sure libsysio is always disted
[fs/lustre-release.git] / lustre / utils / lustre_cfg.c
1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
2  * vim:expandtab:shiftwidth=8:tabstop=8:
3  *
4  *  Copyright (C) 2002 Cluster File Systems, Inc.
5  *   Author: Peter J. Braam <braam@clusterfs.com>
6  *   Author: Phil Schwan <phil@clusterfs.com>
7  *   Author: Andreas Dilger <adilger@clusterfs.com>
8  *   Author: Robert Read <rread@clusterfs.com>
9  *
10  *   This file is part of Lustre, http://www.lustre.org.
11  *
12  *   Lustre is free software; you can redistribute it and/or
13  *   modify it under the terms of version 2 of the GNU General Public
14  *   License as published by the Free Software Foundation.
15  *
16  *   Lustre is distributed in the hope that it will be useful,
17  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
18  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19  *   GNU General Public License for more details.
20  *
21  *   You should have received a copy of the GNU General Public License
22  *   along with Lustre; if not, write to the Free Software
23  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24  *
25  */
26
27
28 #include <stdlib.h>
29 #include <sys/ioctl.h>
30 #include <stdio.h>
31 #include <stdarg.h>
32
33 #ifndef __KERNEL__
34 #include <liblustre.h>
35 #endif
36 #include <linux/lustre_lib.h>
37 #include <linux/lustre_cfg.h>
38 #include <linux/lustre_idl.h>
39 #include <linux/lustre_dlm.h>
40 #include <linux/obd.h>          /* for struct lov_stripe_md */
41 #include <linux/lustre_build_version.h>
42
43 #include <unistd.h>
44 #include <sys/un.h>
45 #include <time.h>
46 #include <sys/time.h>
47 #include <errno.h>
48 #include <string.h>
49
50
51 #include "obdctl.h"
52 #include <portals/ptlctl.h>
53 #include "parser.h"
54 #include <stdio.h>
55
56 static char *lcfg_devname;
57
58 void lcfg_set_devname(char *name)
59 {
60         if (lcfg_devname)
61                 free(lcfg_devname);
62         lcfg_devname = strdup(name);
63 }
64
65
66 int jt_lcfg_device(int argc, char **argv)
67 {
68         char *name;
69
70         if (argc == 1) {
71                 printf("current device is %s\n", lcfg_devname? : "not set");
72                 return 0;
73         } else if (argc != 2) {
74                 return CMD_HELP;
75         }
76
77         name = argv[1];
78
79         /* quietly strip the unnecessary '$' */
80         if (*name == '$')
81                 name++;
82
83         lcfg_set_devname(name);
84
85         return 0;
86 }
87
88 /* NOOP */
89 int jt_lcfg_newdev(int argc, char **argv)
90 {
91         return 0;
92 }
93
94 int jt_lcfg_attach(int argc, char **argv)
95 {
96         struct lustre_cfg lcfg;
97         int rc;
98
99         LCFG_INIT(lcfg, LCFG_ATTACH, lcfg_devname);
100
101         if (argc != 2 && argc != 3 && argc != 4)
102                 return CMD_HELP;
103
104         lcfg.lcfg_inllen1 = strlen(argv[1]) + 1;
105         lcfg.lcfg_inlbuf1 = argv[1];
106         if (argc >= 3) {
107                 lcfg.lcfg_dev_namelen = strlen(argv[2]) + 1;
108                 lcfg.lcfg_dev_name = argv[2];
109         } else {
110                 fprintf(stderr, "error: %s: LCFG_ATTACH requires a name\n",
111                         jt_cmdname(argv[0]));
112                 return -EINVAL;
113         }
114
115         if (argc == 4) {
116                 lcfg.lcfg_inllen2 = strlen(argv[3]) + 1;
117                 lcfg.lcfg_inlbuf2 = argv[3];
118         }
119
120         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, &lcfg);
121         if (rc < 0) {
122                 fprintf(stderr, "error: %s: LCFG_ATTACH %s\n",
123                         jt_cmdname(argv[0]), strerror(rc = errno));
124         } else if (argc == 3) {
125                 char name[1024];
126
127                 lcfg_set_devname(argv[2]);
128                 if (strlen(argv[2]) > 128) {
129                         printf("Name too long to set environment\n");
130                         return -EINVAL;
131                 }
132                 snprintf(name, 512, "LUSTRE_DEV_%s", argv[2]);
133                 rc = setenv(name, argv[1], 1);
134                 if (rc) {
135                         printf("error setting env variable %s\n", name);
136                 }
137         } else {
138                 lcfg_set_devname(argv[2]);
139         }
140
141         return rc;
142 }
143
144 int jt_lcfg_setup(int argc, char **argv)
145 {
146         struct lustre_cfg lcfg;
147         int rc;
148
149         if (lcfg_devname == NULL) {
150                 fprintf(stderr, "%s: please use 'cfg_device name' to set the "
151                         "device name for config commands.\n",
152                         jt_cmdname(argv[0]));
153                 return -EINVAL;
154         }
155
156         LCFG_INIT(lcfg, LCFG_SETUP, lcfg_devname);
157
158         if (argc > 7)
159                 return CMD_HELP;
160
161         if (argc > 1) {
162                 lcfg.lcfg_inllen1 = strlen(argv[1]) + 1;
163                 lcfg.lcfg_inlbuf1 = argv[1];
164         }
165         if (argc > 2) {
166                 lcfg.lcfg_inllen2 = strlen(argv[2]) + 1;
167                 lcfg.lcfg_inlbuf2 = argv[2];
168         }
169         if (argc > 3) {
170                 lcfg.lcfg_inllen3 = strlen(argv[3]) + 1;
171                 lcfg.lcfg_inlbuf3 = argv[3];
172         }
173         if (argc > 4) {
174                 lcfg.lcfg_inllen4 = strlen(argv[4]) + 1;
175                 lcfg.lcfg_inlbuf4 = argv[4];
176         }
177         if (argc > 5) {
178                 lcfg.lcfg_inllen5 = strlen(argv[5]) + 1;
179                 lcfg.lcfg_inlbuf5 = argv[5];
180         }
181         if (argc > 6) {
182                 lcfg.lcfg_inllen6 = strlen(argv[6]) + 1;
183                 lcfg.lcfg_inlbuf6 = argv[6];
184         }
185         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, &lcfg);
186         if (rc < 0)
187                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
188                         strerror(rc = errno));
189
190         return rc;
191 }
192
193 int jt_obd_detach(int argc, char **argv)
194 {
195         struct lustre_cfg lcfg;
196         int rc;
197
198         if (lcfg_devname == NULL) {
199                 fprintf(stderr, "%s: please use 'cfg_device name' to set the "
200                         "device name for config commands.\n",
201                         jt_cmdname(argv[0]));
202                 return -EINVAL;
203         }
204
205         LCFG_INIT(lcfg, LCFG_DETACH, lcfg_devname);
206
207         if (argc != 1)
208                 return CMD_HELP;
209
210         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, &lcfg);
211         if (rc < 0)
212                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
213                         strerror(rc = errno));
214
215         return rc;
216 }
217
218 int jt_obd_cleanup(int argc, char **argv)
219 {
220         struct lustre_cfg lcfg;
221         char force = 'F';
222         char failover = 'A';
223         char flags[3];
224         int flag_cnt = 0, n;
225         int rc;
226
227         if (lcfg_devname == NULL) {
228                 fprintf(stderr, "%s: please use 'cfg_device name' to set the "
229                         "device name for config commands.\n",
230                         jt_cmdname(argv[0]));
231                 return -EINVAL;
232         }
233
234         LCFG_INIT(lcfg, LCFG_CLEANUP, lcfg_devname);
235
236         if (argc < 1 || argc > 3)
237                 return CMD_HELP;
238
239         for (n = 1; n < argc; n++)
240                 if (strcmp(argv[n], "force") == 0) {
241                         flags[flag_cnt++] = force;
242                 } else if (strcmp(argv[n], "failover") == 0) {
243                         flags[flag_cnt++] = failover;
244                 } else {
245                         fprintf(stderr, "unknown option: %s", argv[n]);
246                         return CMD_HELP;
247                 }
248
249         lcfg.lcfg_inllen1 = flag_cnt;
250         if (flag_cnt)
251                 lcfg.lcfg_inlbuf1 = flags;
252
253         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, &lcfg);
254         if (rc < 0)
255                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
256                         strerror(rc = errno));
257
258         return rc;
259 }
260
261 static
262 int do_add_uuid(char * func, char *uuid, ptl_nid_t nid, int nal)
263 {
264         char tmp[64];
265         int rc;
266         struct lustre_cfg lcfg;
267
268         LCFG_INIT(lcfg, LCFG_ADD_UUID, lcfg_devname);
269         lcfg.lcfg_nid = nid;
270         lcfg.lcfg_inllen1 = strlen(uuid) + 1;
271         lcfg.lcfg_inlbuf1 = uuid;
272         lcfg.lcfg_nal = nal;
273
274         rc = lcfg_ioctl(func, OBD_DEV_ID, &lcfg);
275         if (rc) {
276                 fprintf(stderr, "IOC_PORTAL_ADD_UUID failed: %s\n",
277                         strerror(errno));
278                 return -1;
279         }
280
281         printf ("Added uuid %s: %s\n", uuid, ptl_nid2str (tmp, nid));
282         return 0;
283 }
284
285 int jt_lcfg_add_uuid(int argc, char **argv)
286 {
287         ptl_nid_t nid = 0;
288         int nal;
289
290         if (argc != 4) {
291                 return CMD_HELP;
292         }
293
294         if (ptl_parse_nid (&nid, argv[2]) != 0) {
295                 fprintf (stderr, "Can't parse NID %s\n", argv[2]);
296                         return (-1);
297         }
298
299         nal = ptl_name2nal(argv[3]);
300
301         if (nal <= 0) {
302                 fprintf (stderr, "Can't parse NAL %s\n", argv[3]);
303                 return -1;
304         }
305
306         return do_add_uuid(argv[0], argv[1], nid, nal);
307 }
308
309 int obd_add_uuid(char *uuid, ptl_nid_t nid, int nal)
310 {
311         return do_add_uuid("obd_add_uuid", uuid, nid, nal);
312 }
313
314 int jt_lcfg_del_uuid(int argc, char **argv)
315 {
316         int rc;
317         struct lustre_cfg lcfg;
318
319         if (argc != 2) {
320                 fprintf(stderr, "usage: %s <uuid>\n", argv[0]);
321                 return 0;
322         }
323
324         LCFG_INIT(lcfg, LCFG_DEL_UUID, lcfg_devname);
325
326         if (strcmp (argv[1], "_all_"))
327         {
328                 lcfg.lcfg_inllen1 = strlen(argv[1]) + 1;
329                 lcfg.lcfg_inlbuf1 = argv[1];
330         }
331
332         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, &lcfg);
333         if (rc) {
334                 fprintf(stderr, "IOC_PORTAL_DEL_UUID failed: %s\n",
335                         strerror(errno));
336                 return -1;
337         }
338         return 0;
339 }
340
341 int jt_lcfg_lov_setup(int argc, char **argv)
342 {
343         struct lustre_cfg lcfg;
344         struct lov_desc desc;
345         int rc;
346         char *end;
347                                                                                                                                                                                                      
348         /* argv: lov_setup <LOV uuid> <stripe count> <stripe size>
349          *                 <stripe offset> <pattern> [ <max tgt index> ]
350          */
351         if (argc <= 6)
352                 return CMD_HELP;
353                                                                                                                                                                                                      
354         if (strlen(argv[1]) > sizeof(desc.ld_uuid) - 1) {
355                 fprintf(stderr,
356                         "error: %s: LOV uuid '%s' longer than "LPSZ" chars\n",
357                         jt_cmdname(argv[0]), argv[1], sizeof(desc.ld_uuid) - 1);
358                 return -EINVAL;
359         }
360                                                                                                                                                                                                      
361         memset(&desc, 0, sizeof(desc));
362         obd_str2uuid(&desc.ld_uuid, argv[1]);
363         desc.ld_default_stripe_count = strtoul(argv[2], &end, 0);
364         if (*end) {
365                 fprintf(stderr, "error: %s: bad default stripe count '%s'\n",
366                         jt_cmdname(argv[0]), argv[2]);
367                 return CMD_HELP;
368         }
369                                                                                                                                                                                                      
370         desc.ld_default_stripe_size = strtoull(argv[3], &end, 0);
371         if (*end) {
372                 fprintf(stderr, "error: %s: bad default stripe size '%s'\n",
373                         jt_cmdname(argv[0]), argv[3]);
374                 return CMD_HELP;
375         }
376         if (desc.ld_default_stripe_size < 4096) {
377                 fprintf(stderr,
378                         "error: %s: default stripe size "LPU64" too small\n",
379                         jt_cmdname(argv[0]), desc.ld_default_stripe_size);
380                 return -EINVAL;
381         } else if ((long)desc.ld_default_stripe_size <
382                    desc.ld_default_stripe_size) {
383                 fprintf(stderr,
384                         "error: %s: default stripe size "LPU64" too large\n",
385                         jt_cmdname(argv[0]), desc.ld_default_stripe_size);
386                 return -EINVAL;
387         }
388         desc.ld_default_stripe_offset = strtoull(argv[4], &end, 0);
389         if (*end) {
390                 fprintf(stderr, "error: %s: bad default stripe offset '%s'\n",
391                         jt_cmdname(argv[0]), argv[4]);
392                 return CMD_HELP;
393         }
394         desc.ld_pattern = strtoul(argv[5], &end, 0);
395         if (*end) {
396                 fprintf(stderr, "error: %s: bad stripe pattern '%s'\n",
397                         jt_cmdname(argv[0]), argv[5]);
398                 return CMD_HELP;
399         }
400                                                                                                                                                                                                      
401         if (argc > 7) {
402                 desc.ld_tgt_count = argc - 6;
403                 if (desc.ld_default_stripe_count > desc.ld_tgt_count) {
404                         fprintf(stderr,
405                                 "error: %s: default stripe count %u > "
406                                 "OST count %u\n", jt_cmdname(argv[0]),
407                                 desc.ld_default_stripe_count,
408                                 desc.ld_tgt_count);
409                         return -EINVAL;
410                 }
411         }
412                                                                                                                                                                                                      
413         LCFG_INIT(lcfg, LCFG_SETUP, lcfg_devname);
414                                                                                                                                                                                                      
415         lcfg.lcfg_inllen1 = sizeof(desc);
416         lcfg.lcfg_inlbuf1 = (char *)&desc;
417                                                                                                                                                                                                      
418         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, &lcfg);
419         if (rc)
420                 fprintf(stderr, "error: %s: ioctl error: %s\n",
421                         jt_cmdname(argv[0]), strerror(rc = errno));
422         return rc;
423 }
424
425 int jt_lcfg_lmv_setup(int argc, char **argv)
426 {
427         struct lustre_cfg lcfg;
428         struct lmv_desc desc;
429         struct obd_uuid *uuidarray, *ptr;
430         int rc, i;
431
432         LCFG_INIT(lcfg, LCFG_SETUP, lcfg_devname);
433
434         if (argc <= 2)
435                 return CMD_HELP;
436
437         if (strlen(argv[1]) > sizeof(desc.ld_uuid) - 1) {
438                 fprintf(stderr,
439                         "error: %s: LMV uuid '%s' longer than "LPSZ" chars\n",
440                         jt_cmdname(argv[0]), argv[1], sizeof(desc.ld_uuid) - 1);
441                 return -EINVAL;
442         }
443
444         memset(&desc, 0, sizeof(desc));
445         obd_str2uuid(&desc.ld_uuid, argv[1]);
446         desc.ld_tgt_count = argc - 2;
447         printf("LMV: %d uuids:\n", desc.ld_tgt_count);
448
449         /* NOTE: it is possible to overwrite the default striping parameters,
450          *       but EXTREME care must be taken when saving the OST UUID list.
451          *       It must be EXACTLY the same, or have only additions at the
452          *       end of the list, or only overwrite individual OST entries
453          *       that are restored from backups of the previous OST.
454          */
455         uuidarray = calloc(desc.ld_tgt_count, sizeof(*uuidarray));
456         if (!uuidarray) {
457                 fprintf(stderr, "error: %s: no memory for %d UUIDs\n",
458                         jt_cmdname(argv[0]), desc.ld_tgt_count);
459                 rc = -ENOMEM;
460                 goto out;
461         }
462         for (i = 2, ptr = uuidarray; i < argc; i++, ptr++) {
463                 if (strlen(argv[i]) >= sizeof(*ptr)) {
464                         fprintf(stderr, "error: %s: arg %d (%s) too long\n",
465                                 jt_cmdname(argv[0]), i, argv[i]);
466                         rc = -EINVAL;
467                         goto out;
468                 }
469                 printf("  %s\n", argv[i]);
470                 strcpy((char *)ptr, argv[i]);
471         }
472
473         lcfg.lcfg_inllen1 = sizeof(desc);
474         lcfg.lcfg_inlbuf1 = (char *)&desc;
475         lcfg.lcfg_inllen2 = desc.ld_tgt_count * sizeof(*uuidarray);
476         lcfg.lcfg_inlbuf2 = (char *)uuidarray;
477
478         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, &lcfg);
479         if (rc)
480                 fprintf(stderr, "error: %s: ioctl error: %s\n",
481                         jt_cmdname(argv[0]), strerror(rc = errno));
482 out:
483         free(uuidarray);
484         return rc;
485 }
486
487 int jt_lcfg_lov_modify_tgts(int argc, char **argv)
488 {
489         struct lustre_cfg lcfg;
490         char *end;
491         int index;
492         int gen;
493         int rc;
494
495         /* argv: lov_modify_tgts <op> <LOV name> <OBD uuid> <index> <gen> */
496         if (argc != 6)
497                 return CMD_HELP;
498
499         if (!strncmp(argv[1], "add", 4)) {
500                 LCFG_INIT(lcfg, LCFG_LOV_ADD_OBD, argv[2]);
501         } else if (!strncmp(argv[1], "del", 4)) {
502                 LCFG_INIT(lcfg, LCFG_LOV_DEL_OBD, argv[2]);
503         } else {
504                 fprintf(stderr, "error: %s: bad operation '%s'\n",
505                         jt_cmdname(argv[0]), argv[1]);
506                 return CMD_HELP;
507         }
508
509         lcfg.lcfg_inlbuf1 = argv[3];
510         lcfg.lcfg_inllen1 = strlen(lcfg.lcfg_inlbuf1) + 1;
511         if (lcfg.lcfg_inllen1 > sizeof(struct obd_uuid)) {
512                 fprintf(stderr,
513                         "error: %s: OBD uuid '%s' longer than "LPSZ" chars\n",
514                         jt_cmdname(argv[0]), argv[3],
515                         sizeof(struct obd_uuid) - 1);
516                 return -EINVAL;
517         }
518
519         index = strtoul(argv[4], &end, 0);
520         if (*end) {
521                 fprintf(stderr, "error: %s: bad OBD index '%s'\n",
522                         jt_cmdname(argv[0]), argv[4]);
523                 return CMD_HELP;
524         }
525         lcfg.lcfg_inlbuf2 = argv[4];
526         lcfg.lcfg_inllen2 = strlen(lcfg.lcfg_inlbuf2);
527
528         gen = strtoul(argv[5], &end, 0);
529         if (*end) {
530                 fprintf(stderr, "error: %s: bad OBD generation '%s'\n",
531                         jt_cmdname(argv[0]), argv[5]);
532                 return CMD_HELP;
533         }
534         lcfg.lcfg_inlbuf3 = argv[5];
535         lcfg.lcfg_inllen3 = strlen(lcfg.lcfg_inlbuf3);
536
537         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, &lcfg);
538         if (rc)
539                 fprintf(stderr, "error: %s: ioctl error: %s\n",
540                         jt_cmdname(argv[0]), strerror(rc = errno));
541
542         return rc;
543 }
544
545 int jt_lcfg_mount_option(int argc, char **argv)
546 {
547         int rc;
548         struct lustre_cfg lcfg;
549
550         LCFG_INIT(lcfg, LCFG_MOUNTOPT, lcfg_devname);
551
552         if (argc < 3 || argc > 4)
553                 return CMD_HELP;
554
555         /* profile name */
556         lcfg.lcfg_inllen1 = strlen(argv[1]) + 1;
557         lcfg.lcfg_inlbuf1 = argv[1];
558         /* osc name */
559         lcfg.lcfg_inllen2 = strlen(argv[2]) + 1;
560         lcfg.lcfg_inlbuf2 = argv[2];
561         if (argc == 4) {
562                 /* mdc name */
563                 lcfg.lcfg_inllen3 = strlen(argv[3]) + 1;
564                 lcfg.lcfg_inlbuf3 = argv[3];
565         }
566         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, &lcfg);
567         if (rc < 0) {
568                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
569                         strerror(rc = errno));
570         }
571
572         return rc;
573 }
574
575 int jt_lcfg_del_mount_option(int argc, char **argv)
576 {
577         int rc;
578         struct lustre_cfg lcfg;
579
580         LCFG_INIT(lcfg, LCFG_DEL_MOUNTOPT, lcfg_devname);
581
582         if (argc != 2)
583                 return CMD_HELP;
584
585         /* profile name */
586         lcfg.lcfg_inllen1 = strlen(argv[1]) + 1;
587         lcfg.lcfg_inlbuf1 = argv[1];
588
589         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, &lcfg);
590         if (rc < 0) {
591                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
592                         strerror(rc = errno));
593         }
594
595         return rc;
596 }
597
598 int jt_lcfg_set_timeout(int argc, char **argv)
599 {
600         int rc;
601         struct lustre_cfg lcfg;
602
603         LCFG_INIT(lcfg, LCFG_SET_TIMEOUT, lcfg_devname);
604
605         if (argc != 2)
606                 return CMD_HELP;
607
608         lcfg.lcfg_num = atoi(argv[1]);
609
610         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, &lcfg);
611         if (rc < 0) {
612                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
613                         strerror(rc = errno));
614         }
615
616         return rc;
617 }
618
619
620 int jt_lcfg_set_lustre_upcall(int argc, char **argv)
621 {
622         int rc;
623         struct lustre_cfg lcfg;
624
625         LCFG_INIT(lcfg, LCFG_SET_UPCALL, lcfg_devname);
626
627         if (argc != 2)
628                 return CMD_HELP;
629
630         /* profile name */
631         lcfg.lcfg_inllen1 = strlen(argv[1]) + 1;
632         lcfg.lcfg_inlbuf1 = argv[1];
633
634         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, &lcfg);
635         if (rc < 0) {
636                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
637                         strerror(rc = errno));
638         }
639
640         return rc;
641 }
642 int jt_lcfg_add_conn(int argc, char **argv)
643 {
644         struct lustre_cfg lcfg;
645         int priority;
646         int rc;
647
648         if (argc == 2)
649                 priority = 0;
650         else if (argc == 3)
651                 priority = 1;
652         else
653                 return CMD_HELP;
654
655         if (lcfg_devname == NULL) {
656                 fprintf(stderr, "%s: please use 'cfg_device name' to set the "
657                         "device name for config commands.\n",
658                         jt_cmdname(argv[0]));
659                return -EINVAL;
660         }
661
662         LCFG_INIT(lcfg, LCFG_ADD_CONN, lcfg_devname);
663
664         /* connection uuid */
665         lcfg.lcfg_inllen1 = strlen(argv[1]) + 1;
666         lcfg.lcfg_inlbuf1 = argv[1];
667         lcfg.lcfg_inllen2 = sizeof(int);
668         lcfg.lcfg_inlbuf2 = (char*) &priority;
669
670         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, &lcfg);
671         if (rc < 0) {
672                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
673                         strerror(rc = errno));
674         }
675
676         return rc;
677 }
678
679 int jt_lcfg_del_conn(int argc, char **argv)
680 {
681         struct lustre_cfg lcfg;
682         int rc;
683
684         if (argc != 2)
685                 return CMD_HELP;
686
687         if (lcfg_devname == NULL) {
688                 fprintf(stderr, "%s: please use 'cfg_device name' to set the "
689                         "device name for config commands.\n",
690                         jt_cmdname(argv[0]));
691                return -EINVAL;
692         }
693
694         LCFG_INIT(lcfg, LCFG_DEL_CONN, lcfg_devname);
695
696         /* connection uuid */
697         lcfg.lcfg_inllen1 = strlen(argv[1]) + 1;
698         lcfg.lcfg_inlbuf1 = argv[1];
699
700         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, &lcfg);
701         if (rc < 0) {
702                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
703                         strerror(rc = errno));
704         }
705
706         return rc;
707 }
708