[DLM] Update DLM to the latest patch level
[linux-2.6] / fs / dlm / config.c
1 /******************************************************************************
2 *******************************************************************************
3 **
4 **  Copyright (C) Sistina Software, Inc.  1997-2003  All rights reserved.
5 **  Copyright (C) 2004-2005 Red Hat, Inc.  All rights reserved.
6 **
7 **  This copyrighted material is made available to anyone wishing to use,
8 **  modify, copy, or redistribute it subject to the terms and conditions
9 **  of the GNU General Public License v.2.
10 **
11 *******************************************************************************
12 ******************************************************************************/
13
14 #include <linux/kernel.h>
15 #include <linux/module.h>
16 #include <linux/configfs.h>
17 #include <net/sock.h>
18
19 #include "config.h"
20
21 /*
22  * /config/dlm/<cluster>/spaces/<space>/nodes/<node>/nodeid
23  * /config/dlm/<cluster>/spaces/<space>/nodes/<node>/weight
24  * /config/dlm/<cluster>/comms/<comm>/nodeid
25  * /config/dlm/<cluster>/comms/<comm>/local
26  * /config/dlm/<cluster>/comms/<comm>/addr
27  * The <cluster> level is useless, but I haven't figured out how to avoid it.
28  */
29
30 static struct config_group *space_list;
31 static struct config_group *comm_list;
32 static struct comm *local_comm;
33
34 struct clusters;
35 struct cluster;
36 struct spaces;
37 struct space;
38 struct comms;
39 struct comm;
40 struct nodes;
41 struct node;
42
43 static struct config_group *make_cluster(struct config_group *, const char *);
44 static void drop_cluster(struct config_group *, struct config_item *);
45 static void release_cluster(struct config_item *);
46 static struct config_group *make_space(struct config_group *, const char *);
47 static void drop_space(struct config_group *, struct config_item *);
48 static void release_space(struct config_item *);
49 static struct config_item *make_comm(struct config_group *, const char *);
50 static void drop_comm(struct config_group *, struct config_item *);
51 static void release_comm(struct config_item *);
52 static struct config_item *make_node(struct config_group *, const char *);
53 static void drop_node(struct config_group *, struct config_item *);
54 static void release_node(struct config_item *);
55
56 static ssize_t show_comm(struct config_item *i, struct configfs_attribute *a,
57                          char *buf);
58 static ssize_t store_comm(struct config_item *i, struct configfs_attribute *a,
59                           const char *buf, size_t len);
60 static ssize_t show_node(struct config_item *i, struct configfs_attribute *a,
61                          char *buf);
62 static ssize_t store_node(struct config_item *i, struct configfs_attribute *a,
63                           const char *buf, size_t len);
64
65 static ssize_t comm_nodeid_read(struct comm *cm, char *buf);
66 static ssize_t comm_nodeid_write(struct comm *cm, const char *buf, size_t len);
67 static ssize_t comm_local_read(struct comm *cm, char *buf);
68 static ssize_t comm_local_write(struct comm *cm, const char *buf, size_t len);
69 static ssize_t comm_addr_write(struct comm *cm, const char *buf, size_t len);
70 static ssize_t node_nodeid_read(struct node *nd, char *buf);
71 static ssize_t node_nodeid_write(struct node *nd, const char *buf, size_t len);
72 static ssize_t node_weight_read(struct node *nd, char *buf);
73 static ssize_t node_weight_write(struct node *nd, const char *buf, size_t len);
74
75 enum {
76         COMM_ATTR_NODEID = 0,
77         COMM_ATTR_LOCAL,
78         COMM_ATTR_ADDR,
79 };
80
81 struct comm_attribute {
82         struct configfs_attribute attr;
83         ssize_t (*show)(struct comm *, char *);
84         ssize_t (*store)(struct comm *, const char *, size_t);
85 };
86
87 static struct comm_attribute comm_attr_nodeid = {
88         .attr   = { .ca_owner = THIS_MODULE,
89                     .ca_name = "nodeid",
90                     .ca_mode = S_IRUGO | S_IWUSR },
91         .show   = comm_nodeid_read,
92         .store  = comm_nodeid_write,
93 };
94
95 static struct comm_attribute comm_attr_local = {
96         .attr   = { .ca_owner = THIS_MODULE,
97                     .ca_name = "local",
98                     .ca_mode = S_IRUGO | S_IWUSR },
99         .show   = comm_local_read,
100         .store  = comm_local_write,
101 };
102
103 static struct comm_attribute comm_attr_addr = {
104         .attr   = { .ca_owner = THIS_MODULE,
105                     .ca_name = "addr",
106                     .ca_mode = S_IRUGO | S_IWUSR },
107         .store  = comm_addr_write,
108 };
109
110 static struct configfs_attribute *comm_attrs[] = {
111         [COMM_ATTR_NODEID] = &comm_attr_nodeid.attr,
112         [COMM_ATTR_LOCAL] = &comm_attr_local.attr,
113         [COMM_ATTR_ADDR] = &comm_attr_addr.attr,
114         NULL,
115 };
116
117 enum {
118         NODE_ATTR_NODEID = 0,
119         NODE_ATTR_WEIGHT,
120 };
121
122 struct node_attribute {
123         struct configfs_attribute attr;
124         ssize_t (*show)(struct node *, char *);
125         ssize_t (*store)(struct node *, const char *, size_t);
126 };
127
128 static struct node_attribute node_attr_nodeid = {
129         .attr   = { .ca_owner = THIS_MODULE,
130                     .ca_name = "nodeid",
131                     .ca_mode = S_IRUGO | S_IWUSR },
132         .show   = node_nodeid_read,
133         .store  = node_nodeid_write,
134 };
135
136 static struct node_attribute node_attr_weight = {
137         .attr   = { .ca_owner = THIS_MODULE,
138                     .ca_name = "weight",
139                     .ca_mode = S_IRUGO | S_IWUSR },
140         .show   = node_weight_read,
141         .store  = node_weight_write,
142 };
143
144 static struct configfs_attribute *node_attrs[] = {
145         [NODE_ATTR_NODEID] = &node_attr_nodeid.attr,
146         [NODE_ATTR_WEIGHT] = &node_attr_weight.attr,
147         NULL,
148 };
149
150 struct clusters {
151         struct configfs_subsystem subsys;
152 };
153
154 struct cluster {
155         struct config_group group;
156 };
157
158 struct spaces {
159         struct config_group ss_group;
160 };
161
162 struct space {
163         struct config_group group;
164         struct list_head members;
165         struct mutex members_lock;
166         int members_count;
167 };
168
169 struct comms {
170         struct config_group cs_group;
171 };
172
173 struct comm {
174         struct config_item item;
175         int nodeid;
176         int local;
177         int addr_count;
178         struct sockaddr_storage *addr[DLM_MAX_ADDR_COUNT];
179 };
180
181 struct nodes {
182         struct config_group ns_group;
183 };
184
185 struct node {
186         struct config_item item;
187         struct list_head list; /* space->members */
188         int nodeid;
189         int weight;
190 };
191
192 static struct configfs_group_operations clusters_ops = {
193         .make_group = make_cluster,
194         .drop_item = drop_cluster,
195 };
196
197 static struct configfs_item_operations cluster_ops = {
198         .release = release_cluster,
199 };
200
201 static struct configfs_group_operations spaces_ops = {
202         .make_group = make_space,
203         .drop_item = drop_space,
204 };
205
206 static struct configfs_item_operations space_ops = {
207         .release = release_space,
208 };
209
210 static struct configfs_group_operations comms_ops = {
211         .make_item = make_comm,
212         .drop_item = drop_comm,
213 };
214
215 static struct configfs_item_operations comm_ops = {
216         .release = release_comm,
217         .show_attribute = show_comm,
218         .store_attribute = store_comm,
219 };
220
221 static struct configfs_group_operations nodes_ops = {
222         .make_item = make_node,
223         .drop_item = drop_node,
224 };
225
226 static struct configfs_item_operations node_ops = {
227         .release = release_node,
228         .show_attribute = show_node,
229         .store_attribute = store_node,
230 };
231
232 static struct config_item_type clusters_type = {
233         .ct_group_ops = &clusters_ops,
234         .ct_owner = THIS_MODULE,
235 };
236
237 static struct config_item_type cluster_type = {
238         .ct_item_ops = &cluster_ops,
239         .ct_owner = THIS_MODULE,
240 };
241
242 static struct config_item_type spaces_type = {
243         .ct_group_ops = &spaces_ops,
244         .ct_owner = THIS_MODULE,
245 };
246
247 static struct config_item_type space_type = {
248         .ct_item_ops = &space_ops,
249         .ct_owner = THIS_MODULE,
250 };
251
252 static struct config_item_type comms_type = {
253         .ct_group_ops = &comms_ops,
254         .ct_owner = THIS_MODULE,
255 };
256
257 static struct config_item_type comm_type = {
258         .ct_item_ops = &comm_ops,
259         .ct_attrs = comm_attrs,
260         .ct_owner = THIS_MODULE,
261 };
262
263 static struct config_item_type nodes_type = {
264         .ct_group_ops = &nodes_ops,
265         .ct_owner = THIS_MODULE,
266 };
267
268 static struct config_item_type node_type = {
269         .ct_item_ops = &node_ops,
270         .ct_attrs = node_attrs,
271         .ct_owner = THIS_MODULE,
272 };
273
274 static struct cluster *to_cluster(struct config_item *i)
275 {
276         return i ? container_of(to_config_group(i), struct cluster, group):NULL;
277 }
278
279 static struct space *to_space(struct config_item *i)
280 {
281         return i ? container_of(to_config_group(i), struct space, group) : NULL;
282 }
283
284 static struct comm *to_comm(struct config_item *i)
285 {
286         return i ? container_of(i, struct comm, item) : NULL;
287 }
288
289 static struct node *to_node(struct config_item *i)
290 {
291         return i ? container_of(i, struct node, item) : NULL;
292 }
293
294 static struct config_group *make_cluster(struct config_group *g,
295                                          const char *name)
296 {
297         struct cluster *cl = NULL;
298         struct spaces *sps = NULL;
299         struct comms *cms = NULL;
300         void *gps = NULL;
301
302         cl = kzalloc(sizeof(struct cluster), GFP_KERNEL);
303         gps = kcalloc(3, sizeof(struct config_group *), GFP_KERNEL);
304         sps = kzalloc(sizeof(struct spaces), GFP_KERNEL);
305         cms = kzalloc(sizeof(struct comms), GFP_KERNEL);
306
307         if (!cl || !gps || !sps || !cms)
308                 goto fail;
309
310         config_group_init_type_name(&cl->group, name, &cluster_type);
311         config_group_init_type_name(&sps->ss_group, "spaces", &spaces_type);
312         config_group_init_type_name(&cms->cs_group, "comms", &comms_type);
313
314         cl->group.default_groups = gps;
315         cl->group.default_groups[0] = &sps->ss_group;
316         cl->group.default_groups[1] = &cms->cs_group;
317         cl->group.default_groups[2] = NULL;
318
319         space_list = &sps->ss_group;
320         comm_list = &cms->cs_group;
321         return &cl->group;
322
323  fail:
324         kfree(cl);
325         kfree(gps);
326         kfree(sps);
327         kfree(cms);
328         return NULL;
329 }
330
331 static void drop_cluster(struct config_group *g, struct config_item *i)
332 {
333         struct cluster *cl = to_cluster(i);
334         struct config_item *tmp;
335         int j;
336
337         for (j = 0; cl->group.default_groups[j]; j++) {
338                 tmp = &cl->group.default_groups[j]->cg_item;
339                 cl->group.default_groups[j] = NULL;
340                 config_item_put(tmp);
341         }
342
343         space_list = NULL;
344         comm_list = NULL;
345
346         config_item_put(i);
347 }
348
349 static void release_cluster(struct config_item *i)
350 {
351         struct cluster *cl = to_cluster(i);
352         kfree(cl->group.default_groups);
353         kfree(cl);
354 }
355
356 static struct config_group *make_space(struct config_group *g, const char *name)
357 {
358         struct space *sp = NULL;
359         struct nodes *nds = NULL;
360         void *gps = NULL;
361
362         sp = kzalloc(sizeof(struct space), GFP_KERNEL);
363         gps = kcalloc(2, sizeof(struct config_group *), GFP_KERNEL);
364         nds = kzalloc(sizeof(struct nodes), GFP_KERNEL);
365
366         if (!sp || !gps || !nds)
367                 goto fail;
368
369         config_group_init_type_name(&sp->group, name, &space_type);
370         config_group_init_type_name(&nds->ns_group, "nodes", &nodes_type);
371
372         sp->group.default_groups = gps;
373         sp->group.default_groups[0] = &nds->ns_group;
374         sp->group.default_groups[1] = NULL;
375
376         INIT_LIST_HEAD(&sp->members);
377         mutex_init(&sp->members_lock);
378         sp->members_count = 0;
379         return &sp->group;
380
381  fail:
382         kfree(sp);
383         kfree(gps);
384         kfree(nds);
385         return NULL;
386 }
387
388 static void drop_space(struct config_group *g, struct config_item *i)
389 {
390         struct space *sp = to_space(i);
391         struct config_item *tmp;
392         int j;
393
394         /* assert list_empty(&sp->members) */
395
396         for (j = 0; sp->group.default_groups[j]; j++) {
397                 tmp = &sp->group.default_groups[j]->cg_item;
398                 sp->group.default_groups[j] = NULL;
399                 config_item_put(tmp);
400         }
401
402         config_item_put(i);
403 }
404
405 static void release_space(struct config_item *i)
406 {
407         struct space *sp = to_space(i);
408         kfree(sp->group.default_groups);
409         kfree(sp);
410 }
411
412 static struct config_item *make_comm(struct config_group *g, const char *name)
413 {
414         struct comm *cm;
415
416         cm = kzalloc(sizeof(struct comm), GFP_KERNEL);
417         if (!cm)
418                 return NULL;
419
420         config_item_init_type_name(&cm->item, name, &comm_type);
421         cm->nodeid = -1;
422         cm->local = 0;
423         cm->addr_count = 0;
424         return &cm->item;
425 }
426
427 static void drop_comm(struct config_group *g, struct config_item *i)
428 {
429         struct comm *cm = to_comm(i);
430         if (local_comm == cm)
431                 local_comm = NULL;
432         while (cm->addr_count--)
433                 kfree(cm->addr[cm->addr_count]);
434         config_item_put(i);
435 }
436
437 static void release_comm(struct config_item *i)
438 {
439         struct comm *cm = to_comm(i);
440         kfree(cm);
441 }
442
443 static struct config_item *make_node(struct config_group *g, const char *name)
444 {
445         struct space *sp = to_space(g->cg_item.ci_parent);
446         struct node *nd;
447
448         nd = kzalloc(sizeof(struct node), GFP_KERNEL);
449         if (!nd)
450                 return NULL;
451
452         config_item_init_type_name(&nd->item, name, &node_type);
453         nd->nodeid = -1;
454         nd->weight = 1;  /* default weight of 1 if none is set */
455
456         mutex_lock(&sp->members_lock);
457         list_add(&nd->list, &sp->members);
458         sp->members_count++;
459         mutex_unlock(&sp->members_lock);
460
461         return &nd->item;
462 }
463
464 static void drop_node(struct config_group *g, struct config_item *i)
465 {
466         struct space *sp = to_space(g->cg_item.ci_parent);
467         struct node *nd = to_node(i);
468
469         mutex_lock(&sp->members_lock);
470         list_del(&nd->list);
471         sp->members_count--;
472         mutex_unlock(&sp->members_lock);
473
474         config_item_put(i);
475 }
476
477 static void release_node(struct config_item *i)
478 {
479         struct node *nd = to_node(i);
480         kfree(nd);
481 }
482
483 static struct clusters clusters_root = {
484         .subsys = {
485                 .su_group = {
486                         .cg_item = {
487                                 .ci_namebuf = "dlm",
488                                 .ci_type = &clusters_type,
489                         },
490                 },
491         },
492 };
493
494 int dlm_config_init(void)
495 {
496         config_group_init(&clusters_root.subsys.su_group);
497         init_MUTEX(&clusters_root.subsys.su_sem);
498         return configfs_register_subsystem(&clusters_root.subsys);
499 }
500
501 void dlm_config_exit(void)
502 {
503         configfs_unregister_subsystem(&clusters_root.subsys);
504 }
505
506 /*
507  * Functions for user space to read/write attributes
508  */
509
510 static ssize_t show_comm(struct config_item *i, struct configfs_attribute *a,
511                          char *buf)
512 {
513         struct comm *cm = to_comm(i);
514         struct comm_attribute *cma =
515                         container_of(a, struct comm_attribute, attr);
516         return cma->show ? cma->show(cm, buf) : 0;
517 }
518
519 static ssize_t store_comm(struct config_item *i, struct configfs_attribute *a,
520                           const char *buf, size_t len)
521 {
522         struct comm *cm = to_comm(i);
523         struct comm_attribute *cma =
524                 container_of(a, struct comm_attribute, attr);
525         return cma->store ? cma->store(cm, buf, len) : -EINVAL;
526 }
527
528 static ssize_t comm_nodeid_read(struct comm *cm, char *buf)
529 {
530         return sprintf(buf, "%d\n", cm->nodeid);
531 }
532
533 static ssize_t comm_nodeid_write(struct comm *cm, const char *buf, size_t len)
534 {
535         cm->nodeid = simple_strtol(buf, NULL, 0);
536         return len;
537 }
538
539 static ssize_t comm_local_read(struct comm *cm, char *buf)
540 {
541         return sprintf(buf, "%d\n", cm->local);
542 }
543
544 static ssize_t comm_local_write(struct comm *cm, const char *buf, size_t len)
545 {
546         cm->local= simple_strtol(buf, NULL, 0);
547         if (cm->local && !local_comm)
548                 local_comm = cm;
549         return len;
550 }
551
552 static ssize_t comm_addr_write(struct comm *cm, const char *buf, size_t len)
553 {
554         struct sockaddr_storage *addr;
555
556         if (len != sizeof(struct sockaddr_storage))
557                 return -EINVAL;
558
559         if (cm->addr_count >= DLM_MAX_ADDR_COUNT)
560                 return -ENOSPC;
561
562         addr = kzalloc(sizeof(*addr), GFP_KERNEL);
563         if (!addr)
564                 return -ENOMEM;
565
566         memcpy(addr, buf, len);
567         cm->addr[cm->addr_count++] = addr;
568         return len;
569 }
570
571 static ssize_t show_node(struct config_item *i, struct configfs_attribute *a,
572                          char *buf)
573 {
574         struct node *nd = to_node(i);
575         struct node_attribute *nda =
576                         container_of(a, struct node_attribute, attr);
577         return nda->show ? nda->show(nd, buf) : 0;
578 }
579
580 static ssize_t store_node(struct config_item *i, struct configfs_attribute *a,
581                           const char *buf, size_t len)
582 {
583         struct node *nd = to_node(i);
584         struct node_attribute *nda =
585                 container_of(a, struct node_attribute, attr);
586         return nda->store ? nda->store(nd, buf, len) : -EINVAL;
587 }
588
589 static ssize_t node_nodeid_read(struct node *nd, char *buf)
590 {
591         return sprintf(buf, "%d\n", nd->nodeid);
592 }
593
594 static ssize_t node_nodeid_write(struct node *nd, const char *buf, size_t len)
595 {
596         nd->nodeid = simple_strtol(buf, NULL, 0);
597         return len;
598 }
599
600 static ssize_t node_weight_read(struct node *nd, char *buf)
601 {
602         return sprintf(buf, "%d\n", nd->weight);
603 }
604
605 static ssize_t node_weight_write(struct node *nd, const char *buf, size_t len)
606 {
607         nd->weight = simple_strtol(buf, NULL, 0);
608         return len;
609 }
610
611 /*
612  * Functions for the dlm to get the info that's been configured
613  */
614
615 static struct space *get_space(char *name)
616 {
617         if (!space_list)
618                 return NULL;
619         return to_space(config_group_find_obj(space_list, name));
620 }
621
622 static void put_space(struct space *sp)
623 {
624         config_item_put(&sp->group.cg_item);
625 }
626
627 static struct comm *get_comm(int nodeid, struct sockaddr_storage *addr)
628 {
629         struct config_item *i;
630         struct comm *cm = NULL;
631         int found = 0;
632
633         if (!comm_list)
634                 return NULL;
635
636         down(&clusters_root.subsys.su_sem);
637
638         list_for_each_entry(i, &comm_list->cg_children, ci_entry) {
639                 cm = to_comm(i);
640
641                 if (nodeid) {
642                         if (cm->nodeid != nodeid)
643                                 continue;
644                         found = 1;
645                         break;
646                 } else {
647                         if (!cm->addr_count ||
648                             memcmp(cm->addr[0], addr, sizeof(*addr)))
649                                 continue;
650                         found = 1;
651                         break;
652                 }
653         }
654         up(&clusters_root.subsys.su_sem);
655
656         if (found)
657                 config_item_get(i);
658         else
659                 cm = NULL;
660         return cm;
661 }
662
663 static void put_comm(struct comm *cm)
664 {
665         config_item_put(&cm->item);
666 }
667
668 /* caller must free mem */
669 int dlm_nodeid_list(char *lsname, int **ids_out)
670 {
671         struct space *sp;
672         struct node *nd;
673         int i = 0, rv = 0;
674         int *ids;
675
676         sp = get_space(lsname);
677         if (!sp)
678                 return -EEXIST;
679
680         mutex_lock(&sp->members_lock);
681         if (!sp->members_count) {
682                 rv = 0;
683                 goto out;
684         }
685
686         ids = kcalloc(sp->members_count, sizeof(int), GFP_KERNEL);
687         if (!ids) {
688                 rv = -ENOMEM;
689                 goto out;
690         }
691
692         rv = sp->members_count;
693         list_for_each_entry(nd, &sp->members, list)
694                 ids[i++] = nd->nodeid;
695
696         if (rv != i)
697                 printk("bad nodeid count %d %d\n", rv, i);
698
699         *ids_out = ids;
700  out:
701         mutex_unlock(&sp->members_lock);
702         put_space(sp);
703         return rv;
704 }
705
706 int dlm_node_weight(char *lsname, int nodeid)
707 {
708         struct space *sp;
709         struct node *nd;
710         int w = -EEXIST;
711
712         sp = get_space(lsname);
713         if (!sp)
714                 goto out;
715
716         mutex_lock(&sp->members_lock);
717         list_for_each_entry(nd, &sp->members, list) {
718                 if (nd->nodeid != nodeid)
719                         continue;
720                 w = nd->weight;
721                 break;
722         }
723         mutex_unlock(&sp->members_lock);
724         put_space(sp);
725  out:
726         return w;
727 }
728
729 int dlm_nodeid_to_addr(int nodeid, struct sockaddr_storage *addr)
730 {
731         struct comm *cm = get_comm(nodeid, NULL);
732         if (!cm)
733                 return -EEXIST;
734         if (!cm->addr_count)
735                 return -ENOENT;
736         memcpy(addr, cm->addr[0], sizeof(*addr));
737         put_comm(cm);
738         return 0;
739 }
740
741 int dlm_addr_to_nodeid(struct sockaddr_storage *addr, int *nodeid)
742 {
743         struct comm *cm = get_comm(0, addr);
744         if (!cm)
745                 return -EEXIST;
746         *nodeid = cm->nodeid;
747         put_comm(cm);
748         return 0;
749 }
750
751 int dlm_our_nodeid(void)
752 {
753         return local_comm ? local_comm->nodeid : 0;
754 }
755
756 /* num 0 is first addr, num 1 is second addr */
757 int dlm_our_addr(struct sockaddr_storage *addr, int num)
758 {
759         if (!local_comm)
760                 return -1;
761         if (num + 1 > local_comm->addr_count)
762                 return -1;
763         memcpy(addr, local_comm->addr[num], sizeof(*addr));
764         return 0;
765 }
766
767 /* Config file defaults */
768 #define DEFAULT_TCP_PORT       21064
769 #define DEFAULT_BUFFER_SIZE     4096
770 #define DEFAULT_RSBTBL_SIZE      256
771 #define DEFAULT_LKBTBL_SIZE     1024
772 #define DEFAULT_DIRTBL_SIZE      512
773 #define DEFAULT_RECOVER_TIMER      5
774 #define DEFAULT_TOSS_SECS         10
775 #define DEFAULT_SCAN_SECS          5
776
777 struct dlm_config_info dlm_config = {
778         .tcp_port = DEFAULT_TCP_PORT,
779         .buffer_size = DEFAULT_BUFFER_SIZE,
780         .rsbtbl_size = DEFAULT_RSBTBL_SIZE,
781         .lkbtbl_size = DEFAULT_LKBTBL_SIZE,
782         .dirtbl_size = DEFAULT_DIRTBL_SIZE,
783         .recover_timer = DEFAULT_RECOVER_TIMER,
784         .toss_secs = DEFAULT_TOSS_SECS,
785         .scan_secs = DEFAULT_SCAN_SECS
786 };
787