config.c 26 KB

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