Motr  M0
spiel_conf_ut.c
Go to the documentation of this file.
1 /* -*- C -*- */
2 /*
3  * Copyright (c) 2013-2020 Seagate Technology LLC and/or its Affiliates
4  *
5  * Licensed under the Apache License, Version 2.0 (the "License");
6  * you may not use this file except in compliance with the License.
7  * You may obtain a copy of the License at
8  *
9  * http://www.apache.org/licenses/LICENSE-2.0
10  *
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
16  *
17  * For any questions about this software or licensing,
18  * please email opensource@seagate.com or cortx-questions@seagate.com.
19  *
20  */
21 
22 
23 #define M0_TRACE_SUBSYSTEM M0_TRACE_SUBSYS_SPIEL
24 #include "lib/trace.h"
25 
26 #include <fcntl.h> /* open */
27 #include <unistd.h> /* close */
28 
29 #include "spiel/spiel.h"
30 #include "spiel/ut/spiel_ut_common.h"
31 #include "conf/cache.h" /* m0_conf_cache_from_string */
32 #include "conf/obj_ops.h" /* m0_conf_obj_create */
33 #include "conf/preload.h" /* m0_confx_string_free */
34 #include "conf/load_fop.h" /* m0_conf_segment_size */
35 #include "conf/helpers.h" /* m0_confc_expired_cb */
36 #include "conf/ut/common.h"
37 #include "lib/finject.h"
38 #include "lib/fs.h" /* m0_file_read */
39 #include "ut/misc.h" /* M0_UT_PATH */
40 #include "ut/ut.h"
41 
42 struct m0_spiel spiel;
43 extern struct m0_spiel_ut_reqh ut_reqh;
44 
45 enum {
46  SPIEL_UT_OBJ_PROFILE,
47  SPIEL_UT_OBJ_POOL,
48  SPIEL_UT_OBJ_PVER,
49  SPIEL_UT_OBJ_PVER_F,
50  SPIEL_UT_OBJ_NODE,
51  SPIEL_UT_OBJ_NODE2,
52  SPIEL_UT_OBJ_PROCESS,
53  SPIEL_UT_OBJ_PROCESS2,
54  SPIEL_UT_OBJ_SERVICE,
55  SPIEL_UT_OBJ_SERVICE2,
56  SPIEL_UT_OBJ_SERVICE3,
57  SPIEL_UT_OBJ_SERVICE4,
58  SPIEL_UT_OBJ_SERVICE5,
59  SPIEL_UT_OBJ_SERVICE6,
60  SPIEL_UT_OBJ_SERVICE7,
61  SPIEL_UT_OBJ_SERVICE8,
62  SPIEL_UT_OBJ_SERVICE9,
63  SPIEL_UT_OBJ_SERVICE10,
64  SPIEL_UT_OBJ_SERVICE11,
65  SPIEL_UT_OBJ_SERVICE12,
66  SPIEL_UT_OBJ_SERVICE13,
67  SPIEL_UT_OBJ_SDEV,
68  SPIEL_UT_OBJ_SDEV2,
69  SPIEL_UT_OBJ_SDEV3,
70  SPIEL_UT_OBJ_SDEV4,
71  SPIEL_UT_OBJ_SDEV5,
72  SPIEL_UT_OBJ_SDEV6,
73  SPIEL_UT_OBJ_SDEV7,
74  SPIEL_UT_OBJ_SDEV8,
75  SPIEL_UT_OBJ_SDEV9,
76  SPIEL_UT_OBJ_SDEV10,
77  SPIEL_UT_OBJ_SITE,
78  SPIEL_UT_OBJ_RACK,
79  SPIEL_UT_OBJ_RACK2,
80  SPIEL_UT_OBJ_ENCLOSURE,
81  SPIEL_UT_OBJ_ENCLOSURE2,
82  SPIEL_UT_OBJ_CONTROLLER,
83  SPIEL_UT_OBJ_CONTROLLER2,
84  SPIEL_UT_OBJ_DRIVE,
85  SPIEL_UT_OBJ_DRIVE2,
86  SPIEL_UT_OBJ_DRIVE3,
87  SPIEL_UT_OBJ_DRIVE4,
88  SPIEL_UT_OBJ_DRIVE5,
89  SPIEL_UT_OBJ_DRIVE6,
90  SPIEL_UT_OBJ_DRIVE7,
91  SPIEL_UT_OBJ_DRIVE8,
92  SPIEL_UT_OBJ_DRIVE9,
93  SPIEL_UT_OBJ_DRIVE10,
94  SPIEL_UT_OBJ_SITE_V,
95  SPIEL_UT_OBJ_RACK_V,
96  SPIEL_UT_OBJ_ENCLOSURE_V,
97  SPIEL_UT_OBJ_CONTROLLER_V,
98  SPIEL_UT_OBJ_DRIVE_V
99 };
100 
101 static struct m0_fid spiel_obj_fid[] = {
102  [SPIEL_UT_OBJ_PROFILE] = M0_FID_TINIT('p', 1, 0 ),
103  [SPIEL_UT_OBJ_POOL] = M0_FID_TINIT('o', 1, 4 ),
104  [SPIEL_UT_OBJ_PVER] = M0_FID_TINIT('v', 5, 5 ),
105  [SPIEL_UT_OBJ_PVER_F] = M0_FID_TINIT('v', 6, 6 ),
106  [SPIEL_UT_OBJ_NODE] = M0_FID_TINIT('n', 1, 2 ),
107  [SPIEL_UT_OBJ_NODE2] = M0_FID_TINIT('n', 1, 48),
108  [SPIEL_UT_OBJ_PROCESS] = M0_FID_TINIT('r', 1, 5 ),
109  [SPIEL_UT_OBJ_PROCESS2] = M0_FID_TINIT('r', 1, 49),
110  [SPIEL_UT_OBJ_SERVICE] = M0_FID_TINIT('s', 1, 9 ),
111  [SPIEL_UT_OBJ_SERVICE2] = M0_FID_TINIT('s', 1, 10),
112  [SPIEL_UT_OBJ_SERVICE3] = M0_FID_TINIT('s', 1, 20),
113  [SPIEL_UT_OBJ_SERVICE4] = M0_FID_TINIT('s', 1, 21),
114  [SPIEL_UT_OBJ_SERVICE5] = M0_FID_TINIT('s', 1, 22),
115  [SPIEL_UT_OBJ_SERVICE6] = M0_FID_TINIT('s', 1, 23),
116  [SPIEL_UT_OBJ_SERVICE7] = M0_FID_TINIT('s', 1, 24),
117  [SPIEL_UT_OBJ_SERVICE8] = M0_FID_TINIT('s', 1, 25),
118  [SPIEL_UT_OBJ_SERVICE9] = M0_FID_TINIT('s', 1, 26),
119  [SPIEL_UT_OBJ_SERVICE10] = M0_FID_TINIT('s', 1, 27),
120  [SPIEL_UT_OBJ_SERVICE11] = M0_FID_TINIT('s', 1, 28),
121  [SPIEL_UT_OBJ_SERVICE12] = M0_FID_TINIT('s', 1, 29),
122  [SPIEL_UT_OBJ_SERVICE13] = M0_FID_TINIT('s', 1, 100),
123  [SPIEL_UT_OBJ_SDEV] = M0_FID_TINIT('d', 1, 15),
124  [SPIEL_UT_OBJ_SDEV2] = M0_FID_TINIT('d', 1, 71),
125  [SPIEL_UT_OBJ_SDEV3] = M0_FID_TINIT('d', 1, 72),
126  [SPIEL_UT_OBJ_SDEV4] = M0_FID_TINIT('d', 1, 73),
127  [SPIEL_UT_OBJ_SDEV5] = M0_FID_TINIT('d', 1, 74),
128  [SPIEL_UT_OBJ_SDEV6] = M0_FID_TINIT('d', 1, 51),
129  [SPIEL_UT_OBJ_SDEV7] = M0_FID_TINIT('d', 1, 83),
130  [SPIEL_UT_OBJ_SDEV8] = M0_FID_TINIT('d', 1, 84),
131  [SPIEL_UT_OBJ_SDEV9] = M0_FID_TINIT('d', 1, 85),
132  [SPIEL_UT_OBJ_SDEV10] = M0_FID_TINIT('d', 1, 86),
133  [SPIEL_UT_OBJ_SITE] = M0_FID_TINIT('S', 1, 3 ),
134  [SPIEL_UT_OBJ_RACK] = M0_FID_TINIT('a', 1, 3 ),
135  [SPIEL_UT_OBJ_RACK2] = M0_FID_TINIT('a', 1, 52),
136  [SPIEL_UT_OBJ_ENCLOSURE] = M0_FID_TINIT('e', 1, 7 ),
137  [SPIEL_UT_OBJ_ENCLOSURE2] = M0_FID_TINIT('e', 1, 53),
138  [SPIEL_UT_OBJ_CONTROLLER] = M0_FID_TINIT('c', 1, 11),
139  [SPIEL_UT_OBJ_CONTROLLER2] = M0_FID_TINIT('c', 1, 54),
140  [SPIEL_UT_OBJ_DRIVE] = M0_FID_TINIT('k', 1, 16),
141  [SPIEL_UT_OBJ_DRIVE2] = M0_FID_TINIT('k', 1, 75),
142  [SPIEL_UT_OBJ_DRIVE3] = M0_FID_TINIT('k', 1, 76),
143  [SPIEL_UT_OBJ_DRIVE4] = M0_FID_TINIT('k', 1, 77),
144  [SPIEL_UT_OBJ_DRIVE5] = M0_FID_TINIT('k', 1, 78),
145  [SPIEL_UT_OBJ_DRIVE6] = M0_FID_TINIT('k', 1, 55),
146  [SPIEL_UT_OBJ_DRIVE7] = M0_FID_TINIT('k', 1, 87),
147  [SPIEL_UT_OBJ_DRIVE8] = M0_FID_TINIT('k', 1, 88),
148  [SPIEL_UT_OBJ_DRIVE9] = M0_FID_TINIT('k', 1, 89),
149  [SPIEL_UT_OBJ_DRIVE10] = M0_FID_TINIT('k', 1, 90),
150  [SPIEL_UT_OBJ_SITE_V] = M0_FID_TINIT('j', 13, 14),
151  [SPIEL_UT_OBJ_RACK_V] = M0_FID_TINIT('j', 14, 14),
152  [SPIEL_UT_OBJ_ENCLOSURE_V] = M0_FID_TINIT('j', 15, 15),
153  [SPIEL_UT_OBJ_CONTROLLER_V] = M0_FID_TINIT('j', 16, 16),
154  [SPIEL_UT_OBJ_DRIVE_V] = M0_FID_TINIT('j', 17, 17)
155 };
156 
157 static int spiel_copy_file(const char *source, const char* dest)
158 {
159  char buf[1024];
160  int in_fd;
161  int out_fd;
162  size_t result;
163  int rc = 0;
164 
165  in_fd = open(source, O_RDONLY);
166  if (in_fd < 0)
167  return -EINVAL;
168 
169  out_fd = open(dest, O_WRONLY | O_CREAT, 0666);
170  if (in_fd < 0) {
171  close(in_fd);
172  return -EINVAL;
173  }
174 
175  while (1) {
176  rc = (result = read(in_fd, &buf[0], sizeof(buf))) >= 0 ?
177  0 : -EINVAL;
178  if (result == 0 || rc != 0)
179  break;
180  rc = write(out_fd, &buf[0], result) == result ? 0 : -EINVAL;
181  if (rc != 0)
182  break;
183  }
184  close(in_fd);
185  close(out_fd);
186 
187  return rc;
188 }
189 
190 static void spiel_conf_ut_init(void)
191 {
192  struct m0_rconfc *rconfc =
193  &ut_reqh.sur_confd_srv.rsx_motr_ctx.cc_reqh_ctx.rc_reqh.rh_rconfc;
194  int rc;
195 
196  rc = m0_conf_ut_ast_thread_init();
197  M0_ASSERT(rc == 0);
198  spiel_copy_file(M0_UT_PATH("conf.xc"), "tmp-conf.xc");
199 
200  /* Use a copy of conf.xc file as confd path - file may have changed */
201  m0_spiel__ut_init(&spiel, "tmp-conf.xc", false);
202  m0_rconfc_lock(rconfc);
203  rconfc->rc_expired_cb = &m0_confc_expired_cb;
204  rconfc->rc_ready_cb = &m0_confc_ready_cb;
205  m0_rconfc_unlock(rconfc);
207  spiel_obj_fid[SPIEL_UT_OBJ_PVER_F].f_container |=
208  (uint64_t)1 << (64 - 10);
209 }
210 
211 static void spiel_conf_ut_fini(void)
212 {
213  int rc;
214 
215  m0_spiel__ut_fini(&spiel, false);
216 
217  rc = system("rm -rf confd");
218  M0_UT_ASSERT(rc != -1);
219  rc = unlink("tmp-conf.xc");
220  M0_UT_ASSERT(rc == 0);
221  rc = m0_conf_ut_ast_thread_fini();
222  M0_UT_ASSERT(rc == 0);
223 }
224 
225 enum spiel_conf_opts {
226  SCO_NO_CHANGE,
227  SCO_DROP_PROCESS = 1 << 1, /* unused */
228  SCO_DROP_SERVICE = 1 << 2,
229  SCO_DROP_SDEV = 1 << 3, /* unused */
230  SCO_ADD_PROCESS = 1 << (1 + 16), /* unused */
231  SCO_ADD_SERVICE = 1 << (2 + 16),
232  SCO_ADD_SDEV = 1 << (3 + 16), /* unused */
233 };
234 
235 static void spiel_conf_create_conf_with_opt(struct m0_spiel *spiel,
236  struct m0_spiel_tx *tx,
237  uint64_t opts)
238 {
239  int rc;
240  struct m0_pdclust_attr pdclust_attr = { .pa_N=1,
241  .pa_K=0,
242  .pa_S=0,
243  .pa_P=1};
244  const char *params[] = { "11111", "22222", NULL };
245  const char *ep[] = { SERVER_ENDPOINT_ADDR, NULL };
246  struct m0_spiel_service_info service_info = {.svi_endpoints=ep};
247  uint32_t tolerance[] = {0, 0, 0, 0, 1};
248  uint32_t allowance[] = {0, 0, 0, 0, 1};
249  struct m0_bitmap bitmap;
250 
251  m0_bitmap_init(&bitmap, 32);
252  m0_bitmap_set(&bitmap, 0, true);
253  m0_bitmap_set(&bitmap, 1, true);
254 
255  m0_spiel_tx_open(spiel, tx);
256 
257  rc = m0_spiel_root_add(tx,
258  &M0_FID0,
259  &spiel_obj_fid[SPIEL_UT_OBJ_POOL],
260  &spiel_obj_fid[SPIEL_UT_OBJ_PVER],
261  10, params);
262  M0_UT_ASSERT(rc == 0);
263 
264  rc = m0_spiel_profile_add(tx, &spiel_obj_fid[SPIEL_UT_OBJ_PROFILE]);
265  M0_UT_ASSERT(rc == 0);
266 
267  rc = m0_spiel_profile_pool_add(tx, &spiel_obj_fid[SPIEL_UT_OBJ_PROFILE],
268  &spiel_obj_fid[SPIEL_UT_OBJ_POOL]);
269  M0_UT_ASSERT(rc == 0);
270 
271  rc = m0_spiel_pool_add(tx, &spiel_obj_fid[SPIEL_UT_OBJ_POOL], 0);
272  M0_UT_ASSERT(rc == 0);
273 
274  rc = m0_spiel_site_add(tx, &spiel_obj_fid[SPIEL_UT_OBJ_SITE]);
275  M0_UT_ASSERT(rc == 0);
276 
277  rc = m0_spiel_rack_add(tx, &spiel_obj_fid[SPIEL_UT_OBJ_RACK],
278  &spiel_obj_fid[SPIEL_UT_OBJ_SITE]);
279  M0_UT_ASSERT(rc == 0);
280 
281  rc = m0_spiel_rack_add(tx, &spiel_obj_fid[SPIEL_UT_OBJ_RACK2],
282  &spiel_obj_fid[SPIEL_UT_OBJ_SITE]);
283  M0_UT_ASSERT(rc == 0);
284 
285  rc = m0_spiel_node_add(tx,
286  &spiel_obj_fid[SPIEL_UT_OBJ_NODE],
287  256,
288  2,
289  10,
290  0xff00ff00);
291  M0_UT_ASSERT(rc == 0);
292 
293  rc = m0_spiel_node_add(tx,
294  &spiel_obj_fid[SPIEL_UT_OBJ_NODE2],
295  256,
296  2,
297  10,
298  0xff00ff00);
299  M0_UT_ASSERT(rc == 0);
300 
301  rc = m0_spiel_enclosure_add(tx, &spiel_obj_fid[SPIEL_UT_OBJ_ENCLOSURE],
302  &spiel_obj_fid[SPIEL_UT_OBJ_RACK],
303  &spiel_obj_fid[SPIEL_UT_OBJ_NODE]);
304  M0_UT_ASSERT(rc == 0);
305 
306  rc = m0_spiel_enclosure_add(tx, &spiel_obj_fid[SPIEL_UT_OBJ_ENCLOSURE2],
307  &spiel_obj_fid[SPIEL_UT_OBJ_RACK2],
308  &spiel_obj_fid[SPIEL_UT_OBJ_NODE2]);
309  M0_UT_ASSERT(rc == 0);
310 
311  rc = m0_spiel_controller_add(tx,
312  &spiel_obj_fid[SPIEL_UT_OBJ_CONTROLLER],
313  &spiel_obj_fid[SPIEL_UT_OBJ_ENCLOSURE]);
314  M0_UT_ASSERT(rc == 0);
315 
316  rc = m0_spiel_controller_add(tx,
317  &spiel_obj_fid[SPIEL_UT_OBJ_CONTROLLER2],
318  &spiel_obj_fid[SPIEL_UT_OBJ_ENCLOSURE2]);
319  M0_UT_ASSERT(rc == 0);
320 
321  rc = m0_spiel_drive_add(tx,
322  &spiel_obj_fid[SPIEL_UT_OBJ_DRIVE],
323  &spiel_obj_fid[SPIEL_UT_OBJ_CONTROLLER]);
324  M0_UT_ASSERT(rc == 0);
325 
326  rc = m0_spiel_drive_add(tx,
327  &spiel_obj_fid[SPIEL_UT_OBJ_DRIVE2],
328  &spiel_obj_fid[SPIEL_UT_OBJ_CONTROLLER]);
329  M0_UT_ASSERT(rc == 0);
330 
331  rc = m0_spiel_drive_add(tx,
332  &spiel_obj_fid[SPIEL_UT_OBJ_DRIVE3],
333  &spiel_obj_fid[SPIEL_UT_OBJ_CONTROLLER]);
334  M0_UT_ASSERT(rc == 0);
335 
336  rc = m0_spiel_drive_add(tx,
337  &spiel_obj_fid[SPIEL_UT_OBJ_DRIVE4],
338  &spiel_obj_fid[SPIEL_UT_OBJ_CONTROLLER]);
339  M0_UT_ASSERT(rc == 0);
340 
341  rc = m0_spiel_drive_add(tx,
342  &spiel_obj_fid[SPIEL_UT_OBJ_DRIVE5],
343  &spiel_obj_fid[SPIEL_UT_OBJ_CONTROLLER]);
344  M0_UT_ASSERT(rc == 0);
345 
346  rc = m0_spiel_drive_add(tx,
347  &spiel_obj_fid[SPIEL_UT_OBJ_DRIVE6],
348  &spiel_obj_fid[SPIEL_UT_OBJ_CONTROLLER2]);
349  M0_UT_ASSERT(rc == 0);
350 
351  rc = m0_spiel_drive_add(tx,
352  &spiel_obj_fid[SPIEL_UT_OBJ_DRIVE7],
353  &spiel_obj_fid[SPIEL_UT_OBJ_CONTROLLER2]);
354  M0_UT_ASSERT(rc == 0);
355 
356  rc = m0_spiel_drive_add(tx,
357  &spiel_obj_fid[SPIEL_UT_OBJ_DRIVE8],
358  &spiel_obj_fid[SPIEL_UT_OBJ_CONTROLLER2]);
359  M0_UT_ASSERT(rc == 0);
360 
361  rc = m0_spiel_drive_add(tx,
362  &spiel_obj_fid[SPIEL_UT_OBJ_DRIVE9],
363  &spiel_obj_fid[SPIEL_UT_OBJ_CONTROLLER2]);
364  M0_UT_ASSERT(rc == 0);
365 
366  rc = m0_spiel_drive_add(tx,
367  &spiel_obj_fid[SPIEL_UT_OBJ_DRIVE10],
368  &spiel_obj_fid[SPIEL_UT_OBJ_CONTROLLER2]);
369  M0_UT_ASSERT(rc == 0);
370 
371  rc = m0_spiel_pver_actual_add(tx,
372  &spiel_obj_fid[SPIEL_UT_OBJ_PVER],
373  &spiel_obj_fid[SPIEL_UT_OBJ_POOL],
374  &pdclust_attr,
375  tolerance, ARRAY_SIZE(tolerance));
376  M0_UT_ASSERT(rc == 0);
377  rc = m0_spiel_pver_formulaic_add(tx,
378  &spiel_obj_fid[SPIEL_UT_OBJ_PVER_F],
379  &spiel_obj_fid[SPIEL_UT_OBJ_POOL],
380  1,
381  &spiel_obj_fid[SPIEL_UT_OBJ_PVER],
382  allowance, ARRAY_SIZE(allowance));
383  M0_UT_ASSERT(rc == 0);
384 
385  rc = m0_spiel_site_v_add(tx,
386  &spiel_obj_fid[SPIEL_UT_OBJ_SITE_V],
387  &spiel_obj_fid[SPIEL_UT_OBJ_PVER],
388  &spiel_obj_fid[SPIEL_UT_OBJ_SITE]);
389  M0_UT_ASSERT(rc == 0);
390 
391  rc = m0_spiel_rack_v_add(tx,
392  &spiel_obj_fid[SPIEL_UT_OBJ_RACK_V],
393  &spiel_obj_fid[SPIEL_UT_OBJ_SITE_V],
394  &spiel_obj_fid[SPIEL_UT_OBJ_RACK]);
395  M0_UT_ASSERT(rc == 0);
396 
397  rc = m0_spiel_enclosure_v_add(tx,
398  &spiel_obj_fid[SPIEL_UT_OBJ_ENCLOSURE_V],
399  &spiel_obj_fid[SPIEL_UT_OBJ_RACK_V],
400  &spiel_obj_fid[SPIEL_UT_OBJ_ENCLOSURE]);
401  M0_UT_ASSERT(rc == 0);
402 
403  rc = m0_spiel_controller_v_add(tx,
404  &spiel_obj_fid[SPIEL_UT_OBJ_CONTROLLER_V],
405  &spiel_obj_fid[SPIEL_UT_OBJ_ENCLOSURE_V],
406  &spiel_obj_fid[SPIEL_UT_OBJ_CONTROLLER]);
407  M0_UT_ASSERT(rc == 0);
408 
409  rc = m0_spiel_drive_v_add(tx,
410  &spiel_obj_fid[SPIEL_UT_OBJ_DRIVE_V],
411  &spiel_obj_fid[SPIEL_UT_OBJ_CONTROLLER_V],
412  &spiel_obj_fid[SPIEL_UT_OBJ_DRIVE]);
413  M0_UT_ASSERT(rc == 0);
414 
415  rc = m0_spiel_pool_version_done(tx, &spiel_obj_fid[SPIEL_UT_OBJ_PVER]);
416  M0_UT_ASSERT(rc == 0);
417 
418  rc = m0_spiel_process_add(tx,
419  &spiel_obj_fid[SPIEL_UT_OBJ_PROCESS],
420  &spiel_obj_fid[SPIEL_UT_OBJ_NODE],
421  &bitmap, 4000, 1, 2, 3, ep[0]);
422  M0_UT_ASSERT(rc == 0);
423 
424  rc = m0_spiel_process_add(tx,
425  &spiel_obj_fid[SPIEL_UT_OBJ_PROCESS2],
426  &spiel_obj_fid[SPIEL_UT_OBJ_NODE],
427  &bitmap, 4000, 1, 2, 3, ep[0]);
428  M0_UT_ASSERT(rc == 0);
429 
430  service_info.svi_type = M0_CST_IOS;
431  rc = m0_spiel_service_add(tx,
432  &spiel_obj_fid[SPIEL_UT_OBJ_SERVICE],
433  &spiel_obj_fid[SPIEL_UT_OBJ_PROCESS],
434  &service_info);
435  M0_UT_ASSERT(rc == 0);
436 
437  service_info.svi_type = M0_CST_MDS;
438  rc = m0_spiel_service_add(tx,
439  &spiel_obj_fid[SPIEL_UT_OBJ_SERVICE2],
440  &spiel_obj_fid[SPIEL_UT_OBJ_PROCESS],
441  &service_info);
442  M0_UT_ASSERT(rc == 0);
443 
444  service_info.svi_type = M0_CST_CONFD;
445  rc = m0_spiel_service_add(tx,
446  &spiel_obj_fid[SPIEL_UT_OBJ_SERVICE3],
447  &spiel_obj_fid[SPIEL_UT_OBJ_PROCESS],
448  &service_info);
449  M0_UT_ASSERT(rc == 0);
450 
451  service_info.svi_type = M0_CST_ADDB2;
452  rc = m0_spiel_service_add(tx,
453  &spiel_obj_fid[SPIEL_UT_OBJ_SERVICE4],
454  &spiel_obj_fid[SPIEL_UT_OBJ_PROCESS],
455  &service_info);
456  M0_UT_ASSERT(rc == 0);
457 
458  service_info.svi_type = M0_CST_RMS;
459  rc = m0_spiel_service_add(tx,
460  &spiel_obj_fid[SPIEL_UT_OBJ_SERVICE5],
461  &spiel_obj_fid[SPIEL_UT_OBJ_PROCESS],
462  &service_info);
463  M0_UT_ASSERT(rc == 0);
464 
465  service_info.svi_type = M0_CST_HA;
466  rc = m0_spiel_service_add(tx,
467  &spiel_obj_fid[SPIEL_UT_OBJ_SERVICE6],
468  &spiel_obj_fid[SPIEL_UT_OBJ_PROCESS],
469  &service_info);
470  M0_UT_ASSERT(rc == 0);
471 
472  service_info.svi_type = M0_CST_SNS_REP;
473  rc = m0_spiel_service_add(tx,
474  &spiel_obj_fid[SPIEL_UT_OBJ_SERVICE7],
475  &spiel_obj_fid[SPIEL_UT_OBJ_PROCESS],
476  &service_info);
477  M0_UT_ASSERT(rc == 0);
478 
479  service_info.svi_type = M0_CST_SNS_REB;
480  rc = m0_spiel_service_add(tx,
481  &spiel_obj_fid[SPIEL_UT_OBJ_SERVICE8],
482  &spiel_obj_fid[SPIEL_UT_OBJ_PROCESS],
483  &service_info);
484  M0_UT_ASSERT(rc == 0);
485 
486  service_info.svi_type = M0_CST_DS1;
487  rc = m0_spiel_service_add(tx,
488  &spiel_obj_fid[SPIEL_UT_OBJ_SERVICE9],
489  &spiel_obj_fid[SPIEL_UT_OBJ_PROCESS],
490  &service_info);
491  M0_UT_ASSERT(rc == 0);
492 
493  service_info.svi_type = M0_CST_IOS;
494  rc = m0_spiel_service_add(tx,
495  &spiel_obj_fid[SPIEL_UT_OBJ_SERVICE10],
496  &spiel_obj_fid[SPIEL_UT_OBJ_PROCESS2],
497  &service_info);
498  M0_UT_ASSERT(rc == 0);
499 
500  if ((opts & SCO_DROP_SERVICE) == 0) {
501  service_info.svi_type = M0_CST_DS2;
502  rc = m0_spiel_service_add(tx,
503  &spiel_obj_fid[SPIEL_UT_OBJ_SERVICE11],
504  &spiel_obj_fid[SPIEL_UT_OBJ_PROCESS2],
505  &service_info);
506  M0_UT_ASSERT(rc == 0);
507  }
508 
509  if ((opts & SCO_ADD_SERVICE) != 0) {
510  service_info.svi_type = M0_CST_DS2;
511  rc = m0_spiel_service_add(tx,
512  &spiel_obj_fid[SPIEL_UT_OBJ_SERVICE12],
513  &spiel_obj_fid[SPIEL_UT_OBJ_PROCESS2],
514  &service_info);
515  M0_UT_ASSERT(rc == 0);
516  }
517 
518  service_info.svi_type = M0_CST_FDMI;
519  rc = m0_spiel_service_add(tx,
520  &spiel_obj_fid[SPIEL_UT_OBJ_SERVICE13],
521  &spiel_obj_fid[SPIEL_UT_OBJ_PROCESS],
522  &service_info);
523  M0_UT_ASSERT(rc == 0);
524 
525  rc = m0_spiel_device_add(tx,
526  &spiel_obj_fid[SPIEL_UT_OBJ_SDEV],
527  &spiel_obj_fid[SPIEL_UT_OBJ_SERVICE],
528  &spiel_obj_fid[SPIEL_UT_OBJ_DRIVE],
529  1, M0_CFG_DEVICE_INTERFACE_SCSI,
530  M0_CFG_DEVICE_MEDIA_SSD,
531  1024, 512, 123, 0x55, "/dev/sdev2");
532  M0_UT_ASSERT(rc == 0);
533 
534  rc = m0_spiel_device_add(tx,
535  &spiel_obj_fid[SPIEL_UT_OBJ_SDEV2],
536  &spiel_obj_fid[SPIEL_UT_OBJ_SERVICE],
537  &spiel_obj_fid[SPIEL_UT_OBJ_DRIVE2],
538  1, M0_CFG_DEVICE_INTERFACE_SCSI,
539  M0_CFG_DEVICE_MEDIA_SSD,
540  1024, 512, 123, 0x55, "/dev/sdev2");
541  M0_UT_ASSERT(rc == 0);
542  rc = m0_spiel_device_add(tx,
543  &spiel_obj_fid[SPIEL_UT_OBJ_SDEV3],
544  &spiel_obj_fid[SPIEL_UT_OBJ_SERVICE],
545  &spiel_obj_fid[SPIEL_UT_OBJ_DRIVE3],
546  1, M0_CFG_DEVICE_INTERFACE_SCSI,
547  M0_CFG_DEVICE_MEDIA_SSD,
548  1024, 512, 123, 0x55, "/dev/sdev3");
549  M0_UT_ASSERT(rc == 0);
550  rc = m0_spiel_device_add(tx,
551  &spiel_obj_fid[SPIEL_UT_OBJ_SDEV4],
552  &spiel_obj_fid[SPIEL_UT_OBJ_SERVICE],
553  &spiel_obj_fid[SPIEL_UT_OBJ_DRIVE4],
554  1, M0_CFG_DEVICE_INTERFACE_SCSI,
555  M0_CFG_DEVICE_MEDIA_SSD,
556  1024, 512, 123, 0x55, "/dev/sdev4");
557  M0_UT_ASSERT(rc == 0);
558  rc = m0_spiel_device_add(tx,
559  &spiel_obj_fid[SPIEL_UT_OBJ_SDEV5],
560  &spiel_obj_fid[SPIEL_UT_OBJ_SERVICE],
561  &spiel_obj_fid[SPIEL_UT_OBJ_DRIVE5],
562  1, M0_CFG_DEVICE_INTERFACE_SCSI,
563  M0_CFG_DEVICE_MEDIA_SSD,
564  1024, 512, 123, 0x55, "/dev/sdev5");
565  M0_UT_ASSERT(rc == 0);
566  rc = m0_spiel_device_add(tx,
567  &spiel_obj_fid[SPIEL_UT_OBJ_SDEV6],
568  &spiel_obj_fid[SPIEL_UT_OBJ_SERVICE],
569  &spiel_obj_fid[SPIEL_UT_OBJ_DRIVE6],
570  1, M0_CFG_DEVICE_INTERFACE_SCSI,
571  M0_CFG_DEVICE_MEDIA_SSD,
572  1024, 512, 123, 0x55, "/dev/sdev0");
573  M0_UT_ASSERT(rc == 0);
574  rc = m0_spiel_device_add(tx,
575  &spiel_obj_fid[SPIEL_UT_OBJ_SDEV7],
576  &spiel_obj_fid[SPIEL_UT_OBJ_SERVICE],
577  &spiel_obj_fid[SPIEL_UT_OBJ_DRIVE7],
578  1, M0_CFG_DEVICE_INTERFACE_SCSI,
579  M0_CFG_DEVICE_MEDIA_SSD,
580  1024, 512, 123, 0x55, "/dev/sdev1");
581  M0_UT_ASSERT(rc == 0);
582  rc = m0_spiel_device_add(tx,
583  &spiel_obj_fid[SPIEL_UT_OBJ_SDEV8],
584  &spiel_obj_fid[SPIEL_UT_OBJ_SERVICE],
585  &spiel_obj_fid[SPIEL_UT_OBJ_DRIVE8],
586  1, M0_CFG_DEVICE_INTERFACE_SCSI,
587  M0_CFG_DEVICE_MEDIA_SSD,
588  1024, 512, 123, 0x55, "/dev/sdev2");
589  M0_UT_ASSERT(rc == 0);
590  rc = m0_spiel_device_add(tx,
591  &spiel_obj_fid[SPIEL_UT_OBJ_SDEV9],
592  &spiel_obj_fid[SPIEL_UT_OBJ_SERVICE],
593  &spiel_obj_fid[SPIEL_UT_OBJ_DRIVE9],
594  1, M0_CFG_DEVICE_INTERFACE_SCSI,
595  M0_CFG_DEVICE_MEDIA_SSD,
596  1024, 512, 123, 0x55, "/dev/sdev3");
597  M0_UT_ASSERT(rc == 0);
598  rc = m0_spiel_device_add(tx,
599  &spiel_obj_fid[SPIEL_UT_OBJ_SDEV10],
600  &spiel_obj_fid[SPIEL_UT_OBJ_SERVICE],
601  &spiel_obj_fid[SPIEL_UT_OBJ_DRIVE10],
602  1, M0_CFG_DEVICE_INTERFACE_SCSI,
603  M0_CFG_DEVICE_MEDIA_SSD,
604  1024, 512, 123, 0x55, "/dev/sdev4");
605  M0_UT_ASSERT(rc == 0);
606  m0_bitmap_fini(&bitmap);
607 }
608 
612 static void spiel_conf_create_configuration(struct m0_spiel *spiel,
613  struct m0_spiel_tx *tx)
614 {
615  spiel_conf_create_conf_with_opt(spiel, tx, SCO_NO_CHANGE);
616 }
617 
618 #define FID_MOVE(fid, step) \
619  &M0_FID_INIT((fid).f_container, (fid).f_key + (step))
620 
621 static void spiel_conf_create_invalid_configuration(struct m0_spiel *spiel,
622  struct m0_spiel_tx *tx)
623 {
624  int rc;
625  struct m0_pdclust_attr pdclust_attr = { .pa_N=0,
626  .pa_K=0,
627  .pa_S=0,
628  .pa_P=0};
629  const char *params[] = { "11111", "22222", NULL };
630  const char *ep[] = { SERVER_ENDPOINT_ADDR, NULL };
631  struct m0_spiel_service_info service_info = {.svi_endpoints=ep};
632  uint32_t tolerance[] = {0, 0, 0, 0, 1};
633  struct m0_bitmap bitmap;
634 
635  m0_bitmap_init(&bitmap, 32);
636  m0_bitmap_set(&bitmap, 0, true);
637  m0_bitmap_set(&bitmap, 1, true);
638 
639  m0_spiel_tx_open(spiel, tx);
640  rc = m0_spiel_root_add(tx,
641  &spiel_obj_fid[SPIEL_UT_OBJ_PROFILE],
642  &spiel_obj_fid[SPIEL_UT_OBJ_POOL],
643  &spiel_obj_fid[SPIEL_UT_OBJ_PVER],
644  10, params);
645  M0_UT_ASSERT(rc == 0);
646 
647  rc = m0_spiel_profile_add(tx,
648  FID_MOVE(spiel_obj_fid[SPIEL_UT_OBJ_PROFILE], 1));
649  M0_UT_ASSERT(rc == 0);
650 
651  rc = m0_spiel_pool_add(tx,
652  FID_MOVE(spiel_obj_fid[SPIEL_UT_OBJ_POOL], 3),
653  0);
654  M0_UT_ASSERT(rc == 0);
655 
656  rc = m0_spiel_site_add(tx,
657  FID_MOVE(spiel_obj_fid[SPIEL_UT_OBJ_SITE], 4));
658  M0_UT_ASSERT(rc == 0);
659 
660  rc = m0_spiel_rack_add(tx,
661  FID_MOVE(spiel_obj_fid[SPIEL_UT_OBJ_RACK], 4),
662  &spiel_obj_fid[SPIEL_UT_OBJ_SITE]);
663  M0_UT_ASSERT(rc == 0);
664 
665  rc = m0_spiel_node_add(tx,
666  FID_MOVE(spiel_obj_fid[SPIEL_UT_OBJ_NODE], 6),
667  256,
668  2,
669  10,
670  0xff00ff00);
671  M0_UT_ASSERT(rc == 0);
672 
673  rc = m0_spiel_enclosure_add(tx,
674  FID_MOVE(spiel_obj_fid[SPIEL_UT_OBJ_ENCLOSURE], 5),
675  &spiel_obj_fid[SPIEL_UT_OBJ_RACK],
676  &spiel_obj_fid[SPIEL_UT_OBJ_NODE]);
677  M0_UT_ASSERT(rc == 0);
678 
679  rc = m0_spiel_controller_add(tx,
680  FID_MOVE(spiel_obj_fid[SPIEL_UT_OBJ_CONTROLLER], 7),
681  &spiel_obj_fid[SPIEL_UT_OBJ_ENCLOSURE]);
682  M0_UT_ASSERT(rc == 0);
683 
684  rc = m0_spiel_drive_add(tx,
685  FID_MOVE(spiel_obj_fid[SPIEL_UT_OBJ_DRIVE], 8),
686  &spiel_obj_fid[SPIEL_UT_OBJ_CONTROLLER]);
687  M0_UT_ASSERT(rc == 0);
688 
689  rc = m0_spiel_pver_actual_add(tx,
690  FID_MOVE(spiel_obj_fid[SPIEL_UT_OBJ_PVER], 9),
691  &spiel_obj_fid[SPIEL_UT_OBJ_POOL],
692  &pdclust_attr,
693  tolerance, ARRAY_SIZE(tolerance));
694  M0_UT_ASSERT(rc == 0);
695 
696  rc = m0_spiel_site_v_add(tx,
697  FID_MOVE(spiel_obj_fid[SPIEL_UT_OBJ_SITE_V], 10),
698  &spiel_obj_fid[SPIEL_UT_OBJ_PVER],
699  &spiel_obj_fid[SPIEL_UT_OBJ_SITE]);
700  M0_UT_ASSERT(rc == 0);
701 
702  rc = m0_spiel_rack_v_add(tx,
703  FID_MOVE(spiel_obj_fid[SPIEL_UT_OBJ_RACK_V], 10),
704  &spiel_obj_fid[SPIEL_UT_OBJ_SITE_V],
705  &spiel_obj_fid[SPIEL_UT_OBJ_RACK]);
706  M0_UT_ASSERT(rc == 0);
707 
708  rc = m0_spiel_process_add(tx,
709  FID_MOVE(spiel_obj_fid[SPIEL_UT_OBJ_PROCESS], 11),
710  &spiel_obj_fid[SPIEL_UT_OBJ_NODE],
711  &bitmap, 4000, 1, 2, 3, ep[0]);
712  M0_UT_ASSERT(rc == 0);
713 
714  service_info.svi_type = M0_CST_IOS;
715  rc = m0_spiel_service_add(tx,
716  FID_MOVE(spiel_obj_fid[SPIEL_UT_OBJ_SERVICE], 12),
717  &spiel_obj_fid[SPIEL_UT_OBJ_PROCESS],
718  &service_info);
719  M0_UT_ASSERT(rc == 0);
720 
721  rc = m0_spiel_device_add(tx,
722  FID_MOVE(spiel_obj_fid[SPIEL_UT_OBJ_SDEV], 13),
723  &spiel_obj_fid[SPIEL_UT_OBJ_SERVICE],
724  &spiel_obj_fid[SPIEL_UT_OBJ_DRIVE],
725  2, M0_CFG_DEVICE_INTERFACE_SCSI,
726  M0_CFG_DEVICE_MEDIA_SSD,
727  1024, 512, 123, 0x55, "fake_filename");
728  M0_UT_ASSERT(rc == 0);
729 
730  m0_bitmap_fini(&bitmap);
731 }
732 
733 static void spiel_conf_create_ok(void)
734 {
735  struct m0_spiel_tx tx;
736 
737  spiel_conf_ut_init();
738  spiel_conf_create_configuration(&spiel, &tx);
739  m0_spiel_tx_close(&tx);
740  spiel_conf_ut_fini();
741 }
742 
743 static void spiel_conf_pver_check(struct m0_spiel_tx *tx)
744 {
745  struct m0_conf_obj *obj;
746  struct m0_conf_pver *pver;
747  struct m0_conf_rack *rack;
748  struct m0_conf_enclosure *enclosure;
749  struct m0_conf_controller *controller;
750 
751  m0_mutex_lock(&tx->spt_lock);
752  obj = m0_conf_cache_lookup(&tx->spt_cache,
753  &spiel_obj_fid[SPIEL_UT_OBJ_PVER]);
754  pver = M0_CONF_CAST(obj, m0_conf_pver);
755  M0_UT_ASSERT(pver != NULL);
756 
757  obj = m0_conf_cache_lookup(&tx->spt_cache,
758  &spiel_obj_fid[SPIEL_UT_OBJ_RACK]);
759  rack = M0_CONF_CAST(obj, m0_conf_rack);
760  M0_UT_ASSERT(rack != NULL);
761  M0_UT_ASSERT(rack->cr_pvers != NULL);
762  M0_UT_ASSERT(rack->cr_pvers[0] == pver);
763  M0_UT_ASSERT(rack->cr_pvers[1] == NULL);
764 
765  obj = m0_conf_cache_lookup(&tx->spt_cache,
766  &spiel_obj_fid[SPIEL_UT_OBJ_ENCLOSURE]);
767  enclosure = M0_CONF_CAST(obj, m0_conf_enclosure);
768  M0_UT_ASSERT(enclosure != NULL);
769  M0_UT_ASSERT(enclosure->ce_pvers != NULL);
770  M0_UT_ASSERT(enclosure->ce_pvers[0] == pver);
771  M0_UT_ASSERT(enclosure->ce_pvers[1] == NULL);
772 
773  obj = m0_conf_cache_lookup(&tx->spt_cache,
774  &spiel_obj_fid[SPIEL_UT_OBJ_CONTROLLER]);
775  controller = M0_CONF_CAST(obj, m0_conf_controller);
776  M0_UT_ASSERT(controller != NULL);
777  M0_UT_ASSERT(controller->cc_pvers != NULL);
778  M0_UT_ASSERT(controller->cc_pvers[0] == pver);
779  M0_UT_ASSERT(controller->cc_pvers[1] == NULL);
780 
781  obj = m0_conf_cache_lookup(&tx->spt_cache,
782  &spiel_obj_fid[SPIEL_UT_OBJ_PVER_F]);
783  pver = M0_CONF_CAST(obj, m0_conf_pver);
784  M0_UT_ASSERT(pver != NULL);
785 
786  m0_mutex_unlock(&tx->spt_lock);
787 }
788 
789 static void spiel_conf_pver_delete_check(struct m0_spiel_tx *tx)
790 {
791  struct m0_conf_obj *obj;
792 
793  m0_mutex_lock(&tx->spt_lock);
794  obj = m0_conf_cache_lookup(&tx->spt_cache,
795  &spiel_obj_fid[SPIEL_UT_OBJ_PVER]);
796  M0_UT_ASSERT(obj == NULL);
797 
798  obj = m0_conf_cache_lookup(&tx->spt_cache,
799  &spiel_obj_fid[SPIEL_UT_OBJ_PVER_F]);
800  M0_UT_ASSERT(obj == NULL);
801 
802  obj = m0_conf_cache_lookup(&tx->spt_cache,
803  &spiel_obj_fid[SPIEL_UT_OBJ_RACK_V]);
804  M0_UT_ASSERT(obj == NULL);
805 
806  obj = m0_conf_cache_lookup(&tx->spt_cache,
807  &spiel_obj_fid[SPIEL_UT_OBJ_ENCLOSURE_V]);
808  M0_UT_ASSERT(obj == NULL);
809 
810  obj = m0_conf_cache_lookup(&tx->spt_cache,
811  &spiel_obj_fid[SPIEL_UT_OBJ_CONTROLLER_V]);
812  M0_UT_ASSERT(obj == NULL);
813 
814  m0_mutex_unlock(&tx->spt_lock);
815 }
816 
817 static void spiel_conf_create_pver_tree(struct m0_spiel_tx *tx)
818 {
819  int rc;
820  struct m0_fid fake_fid = spiel_obj_fid[SPIEL_UT_OBJ_PROFILE];
821  struct m0_pdclust_attr pdclust_attr = { .pa_N=1, .pa_K=1, .pa_S=1,
822  .pa_P=3};
823  struct m0_pdclust_attr pdclust_attr_invalid = { .pa_N=1, .pa_K=2,
824  .pa_S=2, .pa_P=3};
825  uint32_t tolerance[] = {0, 0, 0, 0, 1};
826  uint32_t allowance[] = {0, 0, 0, 0, 1};
827 
828  /* Actual Pool version */
829  rc = m0_spiel_pver_actual_add(tx,
830  &fake_fid,
831  &spiel_obj_fid[SPIEL_UT_OBJ_POOL],
832  &pdclust_attr,
833  tolerance, ARRAY_SIZE(tolerance));
834  M0_UT_ASSERT(rc == -EINVAL);
835 
836  rc = m0_spiel_pver_actual_add(tx,
837  &spiel_obj_fid[SPIEL_UT_OBJ_PVER],
838  &fake_fid,
839  &pdclust_attr,
840  tolerance, ARRAY_SIZE(tolerance));
841  M0_UT_ASSERT(rc == -EINVAL);
842 
843  rc = m0_spiel_pver_actual_add(tx,
844  &spiel_obj_fid[SPIEL_UT_OBJ_PVER],
845  &spiel_obj_fid[SPIEL_UT_OBJ_POOL],
846  &pdclust_attr,
847  NULL,
848  0);
849  M0_UT_ASSERT(rc == -EINVAL);
850 
851  rc = m0_spiel_pver_actual_add(tx,
852  &spiel_obj_fid[SPIEL_UT_OBJ_PVER],
853  &spiel_obj_fid[SPIEL_UT_OBJ_POOL],
854  &pdclust_attr_invalid,
855  tolerance, ARRAY_SIZE(tolerance));
856  M0_UT_ASSERT(rc == -EINVAL);
857 
858  rc = m0_spiel_pver_actual_add(tx,
859  &spiel_obj_fid[SPIEL_UT_OBJ_PVER],
860  &spiel_obj_fid[SPIEL_UT_OBJ_POOL],
861  &pdclust_attr,
862  tolerance, ARRAY_SIZE(tolerance));
863  M0_UT_ASSERT(rc == 0);
864 
865  /* Formulaic pool version */
866  rc = m0_spiel_pver_formulaic_add(tx,
867  &fake_fid,
868  &spiel_obj_fid[SPIEL_UT_OBJ_POOL],
869  1,
870  &spiel_obj_fid[SPIEL_UT_OBJ_PVER],
871  allowance, ARRAY_SIZE(allowance));
872  M0_UT_ASSERT(rc == -EINVAL);
873 
874  rc = m0_spiel_pver_formulaic_add(tx,
875  &spiel_obj_fid[SPIEL_UT_OBJ_PVER_F],
876  &fake_fid,
877  1,
878  &spiel_obj_fid[SPIEL_UT_OBJ_PVER],
879  allowance, ARRAY_SIZE(allowance));
880  M0_UT_ASSERT(rc == -EINVAL);
881 
882  rc = m0_spiel_pver_formulaic_add(tx,
883  &spiel_obj_fid[SPIEL_UT_OBJ_PVER_F],
884  &spiel_obj_fid[SPIEL_UT_OBJ_POOL],
885  1,
886  &fake_fid,
887  allowance, ARRAY_SIZE(allowance));
888  M0_UT_ASSERT(rc == -EINVAL);
889 
890  rc = m0_spiel_pver_formulaic_add(tx,
891  &spiel_obj_fid[SPIEL_UT_OBJ_PVER_F],
892  &spiel_obj_fid[SPIEL_UT_OBJ_POOL],
893  1,
894  &spiel_obj_fid[SPIEL_UT_OBJ_PVER],
895  NULL, 0);
896  M0_UT_ASSERT(rc == -EINVAL);
897 
898  rc = m0_spiel_pver_formulaic_add(tx,
899  &spiel_obj_fid[SPIEL_UT_OBJ_PVER_F],
900  &spiel_obj_fid[SPIEL_UT_OBJ_POOL],
901  1,
902  &spiel_obj_fid[SPIEL_UT_OBJ_PVER],
903  allowance, ARRAY_SIZE(allowance));
904  M0_UT_ASSERT(rc == 0);
905 
906  /* site-v */
907  rc = m0_spiel_site_v_add(tx,
908  &spiel_obj_fid[SPIEL_UT_OBJ_SITE_V],
909  &spiel_obj_fid[SPIEL_UT_OBJ_PVER],
910  &fake_fid);
911  M0_UT_ASSERT(rc == -EINVAL);
912 
913  rc = m0_spiel_site_v_add(tx,
914  &fake_fid,
915  &spiel_obj_fid[SPIEL_UT_OBJ_PVER],
916  &spiel_obj_fid[SPIEL_UT_OBJ_SITE]);
917  M0_UT_ASSERT(rc == -EINVAL);
918 
919  rc = m0_spiel_site_v_add(tx,
920  &spiel_obj_fid[SPIEL_UT_OBJ_SITE_V],
921  &fake_fid,
922  &spiel_obj_fid[SPIEL_UT_OBJ_SITE]);
923  M0_UT_ASSERT(rc == -EINVAL);
924 
925  rc = m0_spiel_site_v_add(tx,
926  &spiel_obj_fid[SPIEL_UT_OBJ_SITE_V],
927  &spiel_obj_fid[SPIEL_UT_OBJ_PVER],
928  &spiel_obj_fid[SPIEL_UT_OBJ_SITE]);
929  M0_UT_ASSERT(rc == 0);
930 
931  /* rack-v */
932  rc = m0_spiel_rack_v_add(tx,
933  &spiel_obj_fid[SPIEL_UT_OBJ_RACK_V],
934  &spiel_obj_fid[SPIEL_UT_OBJ_SITE_V],
935  &fake_fid);
936  M0_UT_ASSERT(rc == -EINVAL);
937 
938  rc = m0_spiel_rack_v_add(tx,
939  &fake_fid,
940  &spiel_obj_fid[SPIEL_UT_OBJ_SITE_V],
941  &spiel_obj_fid[SPIEL_UT_OBJ_RACK]);
942  M0_UT_ASSERT(rc == -EINVAL);
943 
944  rc = m0_spiel_rack_v_add(tx,
945  &spiel_obj_fid[SPIEL_UT_OBJ_RACK_V],
946  &fake_fid,
947  &spiel_obj_fid[SPIEL_UT_OBJ_RACK]);
948  M0_UT_ASSERT(rc == -EINVAL);
949 
950  rc = m0_spiel_rack_v_add(tx,
951  &spiel_obj_fid[SPIEL_UT_OBJ_RACK_V],
952  &spiel_obj_fid[SPIEL_UT_OBJ_SITE_V],
953  &spiel_obj_fid[SPIEL_UT_OBJ_RACK]);
954  M0_UT_ASSERT(rc == 0);
955 
956  /* enclosure-v */
957  rc = m0_spiel_enclosure_v_add(tx,
958  &spiel_obj_fid[SPIEL_UT_OBJ_ENCLOSURE_V],
959  &spiel_obj_fid[SPIEL_UT_OBJ_RACK_V],
960  &fake_fid);
961  M0_UT_ASSERT(rc == -EINVAL);
962 
963  rc = m0_spiel_enclosure_v_add(tx,
964  &fake_fid,
965  &spiel_obj_fid[SPIEL_UT_OBJ_RACK_V],
966  &spiel_obj_fid[SPIEL_UT_OBJ_ENCLOSURE]);
967  M0_UT_ASSERT(rc == -EINVAL);
968 
969  rc = m0_spiel_enclosure_v_add(tx,
970  &spiel_obj_fid[SPIEL_UT_OBJ_ENCLOSURE_V],
971  &fake_fid,
972  &spiel_obj_fid[SPIEL_UT_OBJ_ENCLOSURE]);
973  M0_UT_ASSERT(rc == -EINVAL);
974 
975  rc = m0_spiel_enclosure_v_add(tx,
976  &spiel_obj_fid[SPIEL_UT_OBJ_ENCLOSURE_V],
977  &spiel_obj_fid[SPIEL_UT_OBJ_RACK_V],
978  &spiel_obj_fid[SPIEL_UT_OBJ_ENCLOSURE]);
979  M0_UT_ASSERT(rc == 0);
980 
981  /* controller-v */
982  rc = m0_spiel_controller_v_add(tx,
983  &spiel_obj_fid[SPIEL_UT_OBJ_CONTROLLER_V],
984  &spiel_obj_fid[SPIEL_UT_OBJ_ENCLOSURE_V],
985  &fake_fid);
986  M0_UT_ASSERT(rc == -EINVAL);
987 
988  rc = m0_spiel_controller_v_add(tx,
989  &fake_fid,
990  &spiel_obj_fid[SPIEL_UT_OBJ_ENCLOSURE_V],
991  &spiel_obj_fid[SPIEL_UT_OBJ_CONTROLLER]);
992  M0_UT_ASSERT(rc == -EINVAL);
993 
994  rc = m0_spiel_controller_v_add(tx,
995  &spiel_obj_fid[SPIEL_UT_OBJ_CONTROLLER_V],
996  &fake_fid,
997  &spiel_obj_fid[SPIEL_UT_OBJ_CONTROLLER]);
998  M0_UT_ASSERT(rc == -EINVAL);
999 
1000  rc = m0_spiel_controller_v_add(tx,
1001  &spiel_obj_fid[SPIEL_UT_OBJ_CONTROLLER_V],
1002  &spiel_obj_fid[SPIEL_UT_OBJ_ENCLOSURE_V],
1003  &spiel_obj_fid[SPIEL_UT_OBJ_CONTROLLER]);
1004  M0_UT_ASSERT(rc == 0);
1005 
1006  /* drive-v */
1007  rc = m0_spiel_drive_v_add(tx,
1008  &spiel_obj_fid[SPIEL_UT_OBJ_DRIVE_V],
1009  &spiel_obj_fid[SPIEL_UT_OBJ_CONTROLLER_V],
1010  &fake_fid);
1011  M0_UT_ASSERT(rc == -EINVAL);
1012 
1013  rc = m0_spiel_drive_v_add(tx,
1014  &fake_fid,
1015  &spiel_obj_fid[SPIEL_UT_OBJ_CONTROLLER_V],
1016  &spiel_obj_fid[SPIEL_UT_OBJ_DRIVE]);
1017  M0_UT_ASSERT(rc == -EINVAL);
1018 
1019  rc = m0_spiel_drive_v_add(tx,
1020  &spiel_obj_fid[SPIEL_UT_OBJ_DRIVE_V],
1021  &fake_fid,
1022  &spiel_obj_fid[SPIEL_UT_OBJ_DRIVE]);
1023  M0_UT_ASSERT(rc == -EINVAL);
1024 
1025  rc = m0_spiel_drive_v_add(tx,
1026  &spiel_obj_fid[SPIEL_UT_OBJ_DRIVE_V],
1027  &spiel_obj_fid[SPIEL_UT_OBJ_CONTROLLER_V],
1028  &spiel_obj_fid[SPIEL_UT_OBJ_DRIVE]);
1029  M0_UT_ASSERT(rc == 0);
1030 }
1031 
1032 static void spiel_conf_create_fail(void)
1033 {
1034  struct m0_spiel_tx tx;
1035  const char *ep[] = { SERVER_ENDPOINT_ADDR, NULL };
1036  int rc;
1037  const char *params[] = { "11111", "22222", NULL };
1038  struct m0_spiel_service_info service_info = {
1039  .svi_endpoints = params };
1040  struct m0_fid fake_profile_fid =
1041  spiel_obj_fid[SPIEL_UT_OBJ_NODE];
1042  struct m0_fid fake_fid =
1043  spiel_obj_fid[SPIEL_UT_OBJ_PROFILE];
1044  struct m0_bitmap bitmap;
1045  uint64_t zero_mask[] = {0, 0};
1046  struct m0_bitmap zero_bitmap = {
1047  .b_nr = 2,
1048  .b_words = zero_mask
1049  };
1050 
1051  spiel_conf_ut_init();
1052  m0_bitmap_init(&bitmap, 32);
1053  m0_bitmap_set(&bitmap, 0, true);
1054  m0_bitmap_set(&bitmap, 1, true);
1055 
1056  m0_spiel_tx_open(&spiel, &tx);
1066  m0_fi_enable("m0_alloc", "fail_allocation");
1067  rc = m0_spiel_root_add(&tx,
1068  &spiel_obj_fid[SPIEL_UT_OBJ_PROFILE],
1069  &spiel_obj_fid[SPIEL_UT_OBJ_POOL],
1070  &spiel_obj_fid[SPIEL_UT_OBJ_PVER],
1071  10, params);
1072  m0_fi_disable("m0_alloc", "fail_allocation");
1073  M0_UT_ASSERT(rc == -ENOMEM);
1074 
1075  /* alloc fail for rt_params */
1076  m0_fi_enable_off_n_on_m("m0_strings_dup",
1077  "strdup_failed", 1, 1);
1078  rc = m0_spiel_root_add(&tx,
1079  &spiel_obj_fid[SPIEL_UT_OBJ_PROFILE],
1080  &spiel_obj_fid[SPIEL_UT_OBJ_POOL],
1081  &spiel_obj_fid[SPIEL_UT_OBJ_PVER],
1082  10, params);
1083  m0_fi_disable("m0_strings_dup", "strdup_failed");
1084  M0_UT_ASSERT(rc == -ENOMEM);
1085 
1086  /* Check that M0_FID0 can be passed as imeta_pver. */
1087  rc = m0_spiel_root_add(&tx,
1088  &spiel_obj_fid[SPIEL_UT_OBJ_PROFILE],
1089  &spiel_obj_fid[SPIEL_UT_OBJ_POOL],
1090  &M0_FID0,
1091  10, params);
1092  M0_UT_ASSERT(rc == 0);
1093 
1094  /* Profile */
1095  rc = m0_spiel_profile_add(&tx, &fake_profile_fid);
1096  M0_UT_ASSERT(rc == -EINVAL);
1097 
1098  rc = m0_spiel_profile_add(&tx, NULL);
1099  M0_UT_ASSERT(rc == -EINVAL);
1100 
1101  rc = m0_spiel_profile_add(&tx, &spiel_obj_fid[SPIEL_UT_OBJ_NODE]);
1102  M0_UT_ASSERT(rc == -EINVAL);
1103 
1104  rc = m0_spiel_profile_add(&tx, &spiel_obj_fid[SPIEL_UT_OBJ_PROFILE]);
1105  M0_UT_ASSERT(rc == 0);
1106 
1107  rc = m0_spiel_profile_add(&tx, &spiel_obj_fid[SPIEL_UT_OBJ_PROFILE]);
1108  M0_UT_ASSERT(rc == -EEXIST);
1109 
1110  rc = m0_spiel_root_add(&tx,
1111  &spiel_obj_fid[SPIEL_UT_OBJ_PROFILE],
1112  &fake_fid,
1113  &spiel_obj_fid[SPIEL_UT_OBJ_PVER],
1114  10, params);
1115  M0_UT_ASSERT(rc == -EINVAL);
1116  rc = m0_spiel_root_add(&tx,
1117  &spiel_obj_fid[SPIEL_UT_OBJ_PROFILE],
1118  &spiel_obj_fid[SPIEL_UT_OBJ_POOL],
1119  &fake_fid,
1120  10, params);
1121  M0_UT_ASSERT(rc == -EINVAL);
1122 
1123  /* Pool */
1124  rc = m0_spiel_pool_add(&tx, &fake_fid, 0);
1125  M0_UT_ASSERT(rc == -EINVAL);
1126 
1127  rc = m0_spiel_pool_add(&tx, &spiel_obj_fid[SPIEL_UT_OBJ_POOL], 0);
1128  M0_UT_ASSERT(rc == 0);
1129 
1130  /* Pool at profile */
1131  rc = m0_spiel_profile_pool_add(&tx, &spiel_obj_fid[SPIEL_UT_OBJ_PROFILE],
1132  &spiel_obj_fid[SPIEL_UT_OBJ_POOL]);
1133  M0_UT_ASSERT(rc == 0);
1134  rc = m0_spiel_profile_pool_add(&tx, &spiel_obj_fid[SPIEL_UT_OBJ_PROFILE],
1135  &spiel_obj_fid[SPIEL_UT_OBJ_POOL]);
1136  M0_UT_ASSERT(rc == -EEXIST);
1137 
1138  /* Site */
1139  rc = m0_spiel_site_add(&tx, &fake_fid);
1140  M0_UT_ASSERT(rc == -EINVAL);
1141 
1142  rc = m0_spiel_site_add(&tx, &spiel_obj_fid[SPIEL_UT_OBJ_SITE]);
1143  M0_UT_ASSERT(rc == 0);
1144 
1145  /* Rack */
1146  rc = m0_spiel_rack_add(&tx, &fake_fid,
1147  &spiel_obj_fid[SPIEL_UT_OBJ_SITE]);
1148  M0_UT_ASSERT(rc == -EINVAL);
1149 
1150  rc = m0_spiel_rack_add(&tx, &spiel_obj_fid[SPIEL_UT_OBJ_RACK],
1151  &fake_fid);
1152  M0_UT_ASSERT(rc == -EINVAL);
1153 
1154  rc = m0_spiel_rack_add(&tx, &spiel_obj_fid[SPIEL_UT_OBJ_RACK],
1155  &spiel_obj_fid[SPIEL_UT_OBJ_SITE]);
1156  M0_UT_ASSERT(rc == 0);
1157 
1158  /* Node */
1159  rc = m0_spiel_node_add(&tx,
1160  &fake_fid,
1161  256, 2, 10, 0xff00ff00);
1162  M0_UT_ASSERT(rc == -EINVAL);
1163 
1164  rc = m0_spiel_node_add(&tx,
1165  &spiel_obj_fid[SPIEL_UT_OBJ_NODE],
1166  256, 2, 10, 0xff00ff00);
1167  M0_UT_ASSERT(rc == 0);
1168 
1169  /* Enclosure */
1170  rc = m0_spiel_enclosure_add(&tx,
1171  &fake_fid,
1172  &spiel_obj_fid[SPIEL_UT_OBJ_RACK],
1173  &spiel_obj_fid[SPIEL_UT_OBJ_NODE]);
1174  M0_UT_ASSERT(rc == -EINVAL);
1175 
1176  rc = m0_spiel_enclosure_add(&tx,
1177  &spiel_obj_fid[SPIEL_UT_OBJ_ENCLOSURE],
1178  &fake_fid,
1179  &spiel_obj_fid[SPIEL_UT_OBJ_NODE]);
1180  M0_UT_ASSERT(rc == -EINVAL);
1181 
1182  rc = m0_spiel_enclosure_add(&tx,
1183  &spiel_obj_fid[SPIEL_UT_OBJ_ENCLOSURE],
1184  &spiel_obj_fid[SPIEL_UT_OBJ_RACK],
1185  &fake_fid);
1186  M0_UT_ASSERT(rc == -EINVAL);
1187 
1188  rc = m0_spiel_enclosure_add(&tx,
1189  &spiel_obj_fid[SPIEL_UT_OBJ_ENCLOSURE],
1190  &spiel_obj_fid[SPIEL_UT_OBJ_RACK],
1191  &spiel_obj_fid[SPIEL_UT_OBJ_NODE]);
1192  M0_UT_ASSERT(rc == 0);
1193 
1194  /* Controller */
1195  rc = m0_spiel_controller_add(&tx,
1196  &fake_fid,
1197  &spiel_obj_fid[SPIEL_UT_OBJ_ENCLOSURE]);
1198  M0_UT_ASSERT(rc == -EINVAL);
1199 
1200  rc = m0_spiel_controller_add(&tx,
1201  &spiel_obj_fid[SPIEL_UT_OBJ_CONTROLLER],
1202  &fake_fid);
1203  M0_UT_ASSERT(rc == -EINVAL);
1204 
1205  rc = m0_spiel_controller_add(&tx,
1206  &spiel_obj_fid[SPIEL_UT_OBJ_CONTROLLER],
1207  &spiel_obj_fid[SPIEL_UT_OBJ_ENCLOSURE]);
1208  M0_UT_ASSERT(rc == 0);
1209 
1210  /* drive */
1211  rc = m0_spiel_drive_add(&tx,
1212  &fake_fid,
1213  &spiel_obj_fid[SPIEL_UT_OBJ_CONTROLLER]);
1214  M0_UT_ASSERT(rc == -EINVAL);
1215 
1216  rc = m0_spiel_drive_add(&tx,
1217  &spiel_obj_fid[SPIEL_UT_OBJ_DRIVE],
1218  &fake_fid);
1219  M0_UT_ASSERT(rc == -EINVAL);
1220 
1221  rc = m0_spiel_drive_add(&tx,
1222  &spiel_obj_fid[SPIEL_UT_OBJ_DRIVE],
1223  &spiel_obj_fid[SPIEL_UT_OBJ_CONTROLLER]);
1224  M0_UT_ASSERT(rc == 0);
1225 
1226  /* Finish pool version */
1227  /* Pver done error */
1228  spiel_conf_create_pver_tree(&tx);
1229  m0_fi_enable_off_n_on_m("spiel_pver_add", "fail_allocation", 1, 1);
1230  rc = m0_spiel_pool_version_done(&tx, &spiel_obj_fid[SPIEL_UT_OBJ_PVER]);
1231  m0_fi_disable("spiel_pver_add", "fail_allocation");
1232  M0_UT_ASSERT(rc == -ENOMEM);
1233 
1234  m0_spiel_element_del(&tx, &spiel_obj_fid[SPIEL_UT_OBJ_PVER_F]);
1235 
1236  spiel_conf_pver_delete_check(&tx);
1237 
1238  /* Pver done OK */
1239  spiel_conf_create_pver_tree(&tx);
1240  rc = m0_spiel_pool_version_done(&tx, &spiel_obj_fid[SPIEL_UT_OBJ_PVER]);
1241  M0_UT_ASSERT(rc == 0);
1242  spiel_conf_pver_check(&tx);
1243 
1244  /* Process */
1245  rc = m0_spiel_process_add(&tx,
1246  &fake_fid,
1247  &spiel_obj_fid[SPIEL_UT_OBJ_NODE],
1248  &bitmap, 4000, 1, 2, 3, ep[0]);
1249  M0_UT_ASSERT(rc == -EINVAL);
1250 
1251  rc = m0_spiel_process_add(&tx,
1252  &spiel_obj_fid[SPIEL_UT_OBJ_PROCESS],
1253  &fake_fid,
1254  &bitmap, 4000, 1, 2, 3, ep[0]);
1255  M0_UT_ASSERT(rc == -EINVAL);
1256 
1257  rc = m0_spiel_process_add(&tx,
1258  &spiel_obj_fid[SPIEL_UT_OBJ_PROCESS],
1259  &spiel_obj_fid[SPIEL_UT_OBJ_NODE],
1260  NULL, 4000, 1, 2, 3, ep[0]);
1261  M0_UT_ASSERT(rc == -EINVAL);
1262 
1263  rc = m0_spiel_process_add(&tx,
1264  &spiel_obj_fid[SPIEL_UT_OBJ_PROCESS],
1265  &spiel_obj_fid[SPIEL_UT_OBJ_NODE],
1266  &bitmap, 4000, 1, 2, 3, NULL);
1267  M0_UT_ASSERT(rc == -EINVAL);
1268 
1269  rc = m0_spiel_process_add(&tx,
1270  &spiel_obj_fid[SPIEL_UT_OBJ_PROCESS],
1271  &spiel_obj_fid[SPIEL_UT_OBJ_NODE],
1272  &zero_bitmap, 4000, 1, 2, 3, ep[0]);
1273  M0_UT_ASSERT(rc == -EINVAL);
1274 
1275  rc = m0_spiel_process_add(&tx,
1276  &spiel_obj_fid[SPIEL_UT_OBJ_PROCESS],
1277  &spiel_obj_fid[SPIEL_UT_OBJ_NODE],
1278  &bitmap, 4000, 1, 2, 3, ep[0]);
1279  M0_UT_ASSERT(rc == 0);
1280 
1281  /* Service */
1282  service_info.svi_endpoints = ep;
1283  service_info.svi_type = M0_CST_CONFD;
1284  rc = m0_spiel_service_add(&tx,
1285  &fake_fid,
1286  &spiel_obj_fid[SPIEL_UT_OBJ_PROCESS],
1287  &service_info);
1288  M0_UT_ASSERT(rc == -EINVAL);
1289 
1290  rc = m0_spiel_service_add(&tx,
1291  &spiel_obj_fid[SPIEL_UT_OBJ_SERVICE],
1292  &fake_fid,
1293  &service_info);
1294  M0_UT_ASSERT(rc == -EINVAL);
1295 
1296  rc = m0_spiel_service_add(&tx,
1297  &spiel_obj_fid[SPIEL_UT_OBJ_SERVICE],
1298  &spiel_obj_fid[SPIEL_UT_OBJ_PROCESS],
1299  NULL);
1300  M0_UT_ASSERT(rc == -EINVAL);
1301 
1302  /* Check copy endpoints parameter */
1303  m0_fi_enable("m0_alloc", "fail_allocation");
1304  rc = m0_spiel_service_add(&tx,
1305  &spiel_obj_fid[SPIEL_UT_OBJ_SERVICE],
1306  &spiel_obj_fid[SPIEL_UT_OBJ_PROCESS],
1307  &service_info);
1308  M0_UT_ASSERT(rc == -ENOMEM);
1309  m0_fi_disable("m0_alloc", "fail_allocation");
1310 
1311  /* Check copy cs_u parameter & switch by type */
1312  service_info.svi_type = M0_CST_MDS;
1313  rc = m0_spiel_service_add(&tx,
1314  &spiel_obj_fid[SPIEL_UT_OBJ_SERVICE],
1315  &spiel_obj_fid[SPIEL_UT_OBJ_PROCESS],
1316  &service_info);
1317  M0_UT_ASSERT(rc == 0);
1318 
1319  service_info.svi_type = M0_CST_IOS;
1320  spiel_obj_fid[SPIEL_UT_OBJ_SERVICE].f_container += 0x0100;
1321  spiel_obj_fid[SPIEL_UT_OBJ_SERVICE].f_key += 0x0100;
1322  rc = m0_spiel_service_add(&tx,
1323  &spiel_obj_fid[SPIEL_UT_OBJ_SERVICE],
1324  &spiel_obj_fid[SPIEL_UT_OBJ_PROCESS],
1325  &service_info);
1326  M0_UT_ASSERT(rc == 0);
1327 
1328  service_info.svi_type = M0_CST_CONFD;
1329  spiel_obj_fid[SPIEL_UT_OBJ_SERVICE].f_container += 0x0100;
1330  spiel_obj_fid[SPIEL_UT_OBJ_SERVICE].f_key += 0x0100;
1331  rc = m0_spiel_service_add(&tx,
1332  &spiel_obj_fid[SPIEL_UT_OBJ_SERVICE],
1333  &spiel_obj_fid[SPIEL_UT_OBJ_PROCESS],
1334  &service_info);
1335  M0_UT_ASSERT(rc == 0);
1336 
1337  service_info.svi_type = M0_CST_RMS;
1338  spiel_obj_fid[SPIEL_UT_OBJ_SERVICE].f_container += 0x0100;
1339  spiel_obj_fid[SPIEL_UT_OBJ_SERVICE].f_key += 0x0100;
1340  rc = m0_spiel_service_add(&tx,
1341  &spiel_obj_fid[SPIEL_UT_OBJ_SERVICE],
1342  &spiel_obj_fid[SPIEL_UT_OBJ_PROCESS],
1343  &service_info);
1344  M0_UT_ASSERT(rc == 0);
1345 
1346  service_info.svi_type = M0_CST_SSS;
1347  spiel_obj_fid[SPIEL_UT_OBJ_SERVICE].f_container += 0x0100;
1348  spiel_obj_fid[SPIEL_UT_OBJ_SERVICE].f_key += 0x0100;
1349  rc = m0_spiel_service_add(&tx,
1350  &spiel_obj_fid[SPIEL_UT_OBJ_SERVICE],
1351  &spiel_obj_fid[SPIEL_UT_OBJ_PROCESS],
1352  &service_info);
1353  M0_UT_ASSERT(rc == 0);
1354 
1355  service_info.svi_type = M0_CST_HA;
1356  spiel_obj_fid[SPIEL_UT_OBJ_SERVICE].f_container += 0x0100;
1357  spiel_obj_fid[SPIEL_UT_OBJ_SERVICE].f_key += 0x0100;
1358  rc = m0_spiel_service_add(&tx,
1359  &spiel_obj_fid[SPIEL_UT_OBJ_SERVICE],
1360  &spiel_obj_fid[SPIEL_UT_OBJ_PROCESS],
1361  &service_info);
1362  M0_UT_ASSERT(rc == 0);
1363 
1364  service_info.svi_type = M0_CST_NR;
1365  spiel_obj_fid[SPIEL_UT_OBJ_SERVICE].f_container += 0x0100;
1366  spiel_obj_fid[SPIEL_UT_OBJ_SERVICE].f_key += 0x0100;
1367  rc = m0_spiel_service_add(&tx,
1368  &spiel_obj_fid[SPIEL_UT_OBJ_SERVICE],
1369  &spiel_obj_fid[SPIEL_UT_OBJ_PROCESS],
1370  &service_info);
1371  M0_UT_ASSERT(rc == -EINVAL);
1372 
1373  /* Normal */
1374  service_info.svi_type = M0_CST_CONFD;
1375  spiel_obj_fid[SPIEL_UT_OBJ_SERVICE].f_container += 0x0100;
1376  spiel_obj_fid[SPIEL_UT_OBJ_SERVICE].f_key += 0x0100;
1377  rc = m0_spiel_service_add(&tx,
1378  &spiel_obj_fid[SPIEL_UT_OBJ_SERVICE],
1379  &spiel_obj_fid[SPIEL_UT_OBJ_PROCESS],
1380  &service_info);
1381  M0_UT_ASSERT(rc == 0);
1382 
1383  /* Device */
1384  rc = m0_spiel_device_add(&tx,
1385  &fake_fid,
1386  &spiel_obj_fid[SPIEL_UT_OBJ_SERVICE],
1387  &spiel_obj_fid[SPIEL_UT_OBJ_DRIVE],
1388  1, M0_CFG_DEVICE_INTERFACE_SCSI,
1389  M0_CFG_DEVICE_MEDIA_SSD,
1390  1024, 512, 123, 0x55, "fake_filename");
1391  M0_UT_ASSERT(rc == -EINVAL);
1392 
1393  rc = m0_spiel_device_add(&tx,
1394  &spiel_obj_fid[SPIEL_UT_OBJ_SDEV],
1395  &fake_fid,
1396  &fake_fid,
1397  1, M0_CFG_DEVICE_INTERFACE_SCSI,
1398  M0_CFG_DEVICE_MEDIA_SSD,
1399  1024, 512, 123, 0x55, "fake_filename");
1400  M0_UT_ASSERT(rc == -EINVAL);
1401 
1402  rc = m0_spiel_device_add(&tx,
1403  &spiel_obj_fid[SPIEL_UT_OBJ_SDEV],
1404  &spiel_obj_fid[SPIEL_UT_OBJ_SERVICE],
1405  &spiel_obj_fid[SPIEL_UT_OBJ_DRIVE],
1406  1, M0_CFG_DEVICE_INTERFACE_NR,
1407  M0_CFG_DEVICE_MEDIA_SSD,
1408  1024, 512, 123, 0x55, "fake_filename");
1409  M0_UT_ASSERT(rc == -EINVAL);
1410 
1411  rc = m0_spiel_device_add(&tx,
1412  &spiel_obj_fid[SPIEL_UT_OBJ_SDEV],
1413  &spiel_obj_fid[SPIEL_UT_OBJ_SERVICE],
1414  &spiel_obj_fid[SPIEL_UT_OBJ_DRIVE],
1415  1, M0_CFG_DEVICE_INTERFACE_SCSI,
1416  M0_CFG_DEVICE_MEDIA_NR,
1417  1024, 512, 123, 0x55, "fake_filename");
1418  M0_UT_ASSERT(rc == -EINVAL);
1419 
1420  rc = m0_spiel_device_add(&tx,
1421  &spiel_obj_fid[SPIEL_UT_OBJ_SDEV],
1422  &spiel_obj_fid[SPIEL_UT_OBJ_SERVICE],
1423  &spiel_obj_fid[SPIEL_UT_OBJ_DRIVE],
1424  1, M0_CFG_DEVICE_INTERFACE_SCSI,
1425  M0_CFG_DEVICE_MEDIA_SSD,
1426  1024, 512, 123, 0x55, NULL);
1427  M0_UT_ASSERT(rc == -EINVAL);
1428 
1429  rc = m0_spiel_device_add(&tx,
1430  &spiel_obj_fid[SPIEL_UT_OBJ_SDEV],
1431  &spiel_obj_fid[SPIEL_UT_OBJ_SERVICE],
1432  &spiel_obj_fid[SPIEL_UT_OBJ_DRIVE],
1433  1, M0_CFG_DEVICE_INTERFACE_SCSI,
1434  M0_CFG_DEVICE_MEDIA_SSD,
1435  1024, 512, 123, 0x55, "fake_filename");
1436  M0_UT_ASSERT(rc == 0);
1437 
1438  m0_spiel_tx_close(&tx);
1439 
1440  m0_bitmap_fini(&bitmap);
1441  spiel_obj_fid[SPIEL_UT_OBJ_SERVICE].f_container -= 0x0700;
1442  spiel_obj_fid[SPIEL_UT_OBJ_SERVICE].f_key -= 0x0700;
1443 
1444  spiel_conf_ut_fini();
1445 }
1446 
1447 static void spiel_conf_delete(void)
1448 {
1449  struct m0_spiel_tx tx;
1450  int rc;
1451  struct m0_conf_obj *obj;
1452  struct m0_conf_enclosure *enclosure;
1453 
1454  spiel_conf_ut_init();
1455 
1456  spiel_conf_create_configuration(&spiel, &tx);
1457  obj = m0_conf_cache_lookup(&tx.spt_cache,
1458  &spiel_obj_fid[SPIEL_UT_OBJ_ENCLOSURE]);
1459  enclosure = M0_CONF_CAST(obj, m0_conf_enclosure);
1460  M0_UT_ASSERT(enclosure != NULL);
1461 
1462  rc = m0_spiel_element_del(&tx, &spiel_obj_fid[SPIEL_UT_OBJ_CONTROLLER]);
1463  M0_UT_ASSERT(rc == 0);
1464 
1465  M0_UT_ASSERT(enclosure->ce_pvers[0] != NULL);
1466  rc = m0_spiel_element_del(&tx, &spiel_obj_fid[SPIEL_UT_OBJ_PVER]);
1467  M0_UT_ASSERT(rc == 0);
1468  M0_UT_ASSERT(enclosure->ce_pvers[0] == NULL);
1469 
1470  m0_spiel_tx_close(&tx);
1471 
1472  spiel_conf_ut_fini();
1473 }
1474 
1480 static void spiel_conf_file_create_tree(struct m0_spiel_tx *tx)
1481 {
1482  int rc;
1483  const char *ep[] = { SERVER_ENDPOINT_ADDR,
1484  NULL };
1485  const char *ep_service1[] = { "addr-0",
1486  "addr-1",
1487  "addr-2",
1488  NULL };
1489  const char *ep_service2[] = { "addr-3", NULL };
1490  const char *ep_service3[] = { "addr-3", NULL };
1491  struct m0_pdclust_attr pdclust_attr = { 0, 0, 0, 0 };
1492  const char *params[] = { "param-0",
1493  "param-1",
1494  "param-2",
1495  NULL };
1496  struct m0_spiel_service_info service_info1 = {
1497  .svi_endpoints = ep_service1 };
1498  struct m0_spiel_service_info service_info2 = {
1499  .svi_endpoints = ep_service2 };
1500  struct m0_spiel_service_info service_info3 = {
1501  .svi_endpoints = ep_service3 };
1502  /* @todo Add support for fdmi objects (filters group and filters) */
1503  struct m0_fid fid_profile = M0_FID_TINIT('p', 1, 0);
1504  struct m0_fid fid_node = M0_FID_TINIT('n', 1, 2);
1505  struct m0_fid fid_site = M0_FID_TINIT('S', 1, 3);
1506  struct m0_fid fid_rack = M0_FID_TINIT('a', 1, 3);
1507  struct m0_fid fid_pool = M0_FID_TINIT('o', 1, 4);
1508  struct m0_fid fid_process1 = M0_FID_TINIT('r', 1, 5);
1509  struct m0_fid fid_process2 = M0_FID_TINIT('r', 1, 6);
1510  struct m0_fid fid_process3 = M0_FID_TINIT('r', 1, 7);
1511  struct m0_fid fid_enclosure = M0_FID_TINIT('e', 1, 8);
1512  struct m0_fid fid_pver = M0_FID_TINIT('v', 1, 9);
1513  struct m0_fid fid_service1 = M0_FID_TINIT('s', 1, 10);
1514  struct m0_fid fid_service2 = M0_FID_TINIT('s', 1, 11);
1515  struct m0_fid fid_service3 = M0_FID_TINIT('s', 1, 12);
1516  struct m0_fid fid_controller = M0_FID_TINIT('c', 1, 13);
1517  struct m0_fid fid_drive1 = M0_FID_TINIT('k', 1, 14);
1518  struct m0_fid fid_drive2 = M0_FID_TINIT('k', 1, 15);
1519  struct m0_fid fid_drive3 = M0_FID_TINIT('k', 1, 16);
1520  struct m0_fid fid_site_v = M0_FID_TINIT('j', 2, 17);
1521  struct m0_fid fid_rack_v = M0_FID_TINIT('j', 1, 17);
1522  struct m0_fid fid_sdev1 = M0_FID_TINIT('d', 1, 18);
1523  struct m0_fid fid_sdev2 = M0_FID_TINIT('d', 1, 19);
1524  struct m0_fid fid_sdev3 = M0_FID_TINIT('d', 1, 20);
1525  struct m0_fid fid_enclosure_v = M0_FID_TINIT('j', 1, 21);
1526  struct m0_fid fid_controller_v = M0_FID_TINIT('j', 1, 22);
1527  struct m0_fid fid_drive_v1 = M0_FID_TINIT('j', 1, 23);
1528  struct m0_fid fid_drive_v2 = M0_FID_TINIT('j', 1, 24);
1529  struct m0_fid fid_drive_v3 = M0_FID_TINIT('j', 1, 25);
1530  uint32_t tolerance[] = {0, 0, 0, 0, 1};
1531  struct m0_bitmap bitmap;
1532 
1533  m0_bitmap_init(&bitmap, 32);
1534  m0_bitmap_set(&bitmap, 0, true);
1535  m0_bitmap_set(&bitmap, 1, true);
1536 
1537  rc = m0_spiel_root_add(tx, &fid_profile, &fid_pool,
1538  &fid_pver, 41212, params);
1539  M0_UT_ASSERT(rc == 0);
1540 
1541  rc = m0_spiel_profile_add(tx, &fid_profile);
1542  M0_UT_ASSERT(rc == 0);
1543 
1544  rc = m0_spiel_pool_add(tx, &fid_pool, 0);
1545  M0_UT_ASSERT(rc == 0);
1546 
1547  rc = m0_spiel_site_add(tx, &fid_site);
1548  M0_UT_ASSERT(rc == 0);
1549 
1550  rc = m0_spiel_rack_add(tx, &fid_rack, &fid_site);
1551  M0_UT_ASSERT(rc == 0);
1552 
1553  rc = m0_spiel_node_add(tx, &fid_node, 16000, 2, 3, 2);
1554  M0_UT_ASSERT(rc == 0);
1555 
1556  rc = m0_spiel_enclosure_add(tx, &fid_enclosure, &fid_rack,
1557  &fid_node);
1558  M0_UT_ASSERT(rc == 0);
1559 
1560  rc = m0_spiel_controller_add(tx, &fid_controller, &fid_enclosure);
1561  M0_UT_ASSERT(rc == 0);
1562 
1563  rc = m0_spiel_drive_add(tx, &fid_drive1, &fid_controller);
1564  M0_UT_ASSERT(rc == 0);
1565 
1566  rc = m0_spiel_drive_add(tx, &fid_drive2, &fid_controller);
1567  M0_UT_ASSERT(rc == 0);
1568 
1569  rc = m0_spiel_drive_add(tx, &fid_drive3, &fid_controller);
1570  M0_UT_ASSERT(rc == 0);
1571 
1572  rc = m0_spiel_pver_actual_add(tx, &fid_pver, &fid_pool, &pdclust_attr,
1573  tolerance, ARRAY_SIZE(tolerance));
1574  M0_UT_ASSERT(rc == 0);
1575 
1576  rc = m0_spiel_site_v_add(tx, &fid_site_v, &fid_pver, &fid_site);
1577  M0_UT_ASSERT(rc == 0);
1578 
1579  rc = m0_spiel_rack_v_add(tx, &fid_rack_v, &fid_site_v, &fid_rack);
1580  M0_UT_ASSERT(rc == 0);
1581 
1582  rc = m0_spiel_enclosure_v_add(tx, &fid_enclosure_v, &fid_rack_v,
1583  &fid_enclosure);
1584  M0_UT_ASSERT(rc == 0);
1585 
1586  rc = m0_spiel_controller_v_add(tx, &fid_controller_v, &fid_enclosure_v,
1587  &fid_controller);
1588  M0_UT_ASSERT(rc == 0);
1589 
1590  rc = m0_spiel_drive_v_add(tx, &fid_drive_v1, &fid_controller_v,
1591  &fid_drive1);
1592  M0_UT_ASSERT(rc == 0);
1593 
1594  rc = m0_spiel_drive_v_add(tx, &fid_drive_v2, &fid_controller_v,
1595  &fid_drive2);
1596  M0_UT_ASSERT(rc == 0);
1597 
1598  rc = m0_spiel_drive_v_add(tx, &fid_drive_v3, &fid_controller_v,
1599  &fid_drive3);
1600  M0_UT_ASSERT(rc == 0);
1601 
1602  rc = m0_spiel_pool_version_done(tx, &fid_pver);
1603  M0_UT_ASSERT(rc == 0);
1604 
1605  rc = m0_spiel_process_add(tx, &fid_process1, &fid_node,
1606  &bitmap, 4000, 1, 2, 3, ep[0]);
1607  M0_UT_ASSERT(rc == 0);
1608 
1609  rc = m0_spiel_process_add(tx, &fid_process2, &fid_node,
1610  &bitmap, 4000, 1, 2, 3, ep[0]);
1611  M0_UT_ASSERT(rc == 0);
1612 
1613  rc = m0_spiel_process_add(tx, &fid_process3, &fid_node,
1614  &bitmap, 4000, 1, 2, 3, ep[0]);
1615  M0_UT_ASSERT(rc == 0);
1616 
1617  service_info1.svi_type = M0_CST_CONFD;
1618  rc = m0_spiel_service_add(tx, &fid_service1, &fid_process1,
1619  &service_info1);
1620  M0_UT_ASSERT(rc == 0);
1621 
1622  service_info2.svi_type = M0_CST_MDS;
1623  rc = m0_spiel_service_add(tx, &fid_service2, &fid_process2,
1624  &service_info2);
1625  M0_UT_ASSERT(rc == 0);
1626 
1627  service_info3.svi_type = M0_CST_FDMI;
1628  rc = m0_spiel_service_add(tx, &fid_service3, &fid_process3,
1629  &service_info3);
1630  M0_UT_ASSERT(rc == 0);
1631 
1632  rc = m0_spiel_device_add(tx, &fid_sdev1, &fid_service1, &fid_drive1, 1,
1633  4, 1, 4096, 596000000000, 3, 4, "/dev/sdev0");
1634  M0_UT_ASSERT(rc == 0);
1635 
1636  rc = m0_spiel_device_add(tx, &fid_sdev2, &fid_service1, &fid_drive2, 2,
1637  4, 1, 4096, 596000000000, 3, 4, "/dev/sdev1");
1638  M0_UT_ASSERT(rc == 0);
1639 
1640  rc = m0_spiel_device_add(tx, &fid_sdev3, &fid_service2, &fid_drive3, 3,
1641  7, 2, 8192, 320000000000, 2, 4, "/dev/sdev2");
1642  M0_UT_ASSERT(rc == 0);
1643 
1644  m0_bitmap_fini(&bitmap);
1645 }
1646 
1647 static void spiel_conf_file(void)
1648 {
1649  int rc;
1650  struct m0_spiel_tx tx;
1651  char *confstr = NULL;
1652  const char filename[] = "spiel-conf.xc";
1653  const int ver_forced = 10;
1654  struct m0_conf_cache cache;
1655  struct m0_mutex lock;
1656 
1657  spiel_conf_ut_init();
1658 
1659  m0_spiel_tx_open(&spiel, &tx);
1660  spiel_conf_file_create_tree(&tx);
1661 
1662  /* Convert to file */
1663  rc = m0_spiel_tx_dump(&tx, ver_forced, filename);
1664  M0_UT_ASSERT(rc == 0);
1665  M0_UT_ASSERT(m0_conf_version(&tx.spt_cache) == ver_forced);
1666  m0_spiel_tx_close(&tx);
1667 
1668  /* Load file */
1669  rc = m0_file_read(filename, &confstr);
1670  M0_UT_ASSERT(rc == 0);
1671  rc = unlink(filename);
1672  M0_UT_ASSERT(rc == 0);
1673 
1674  m0_mutex_init(&lock);
1675  m0_conf_cache_init(&cache, &lock);
1676 
1677  m0_mutex_lock(&lock);
1678 
1679  rc = m0_conf_cache_from_string(&cache, confstr);
1680  m0_free(confstr);
1681  M0_UT_ASSERT(rc == 0);
1682  m0_mutex_unlock(&lock);
1683 
1684  m0_conf_cache_fini(&cache);
1685  m0_mutex_fini(&lock);
1686  spiel_conf_ut_fini();
1687 }
1688 
1689 static void spiel_conf_cancel(void)
1690 {
1691  struct m0_spiel_tx tx;
1692 
1693  spiel_conf_ut_init();
1694  spiel_conf_create_configuration(&spiel, &tx);
1695  m0_spiel_tx_close(&tx);
1696  spiel_conf_ut_fini();
1697 }
1698 
1702 static void spiel_conf_load_send(void)
1703 {
1704  struct m0_spiel_tx tx;
1705  int i;
1706  int rc;
1707 
1708  spiel_conf_ut_init();
1709  /*
1710  * Check that the second commit is possible and there is no panic.
1711  * See MOTR-2311.
1712  */
1713  m0_fi_enable("storage_devs_conf_expired_cb", "skip_storage_devs_expired_cb");
1714  m0_fi_enable("storage_devs_conf_ready_async_cb",
1715  "skip_storage_devs_ready_cb");
1716  for (i = 0; i < 2; i++) {
1717  spiel_conf_create_configuration(&spiel, &tx);
1718  rc = m0_spiel_tx_commit(&tx);
1719  M0_UT_ASSERT(rc == 0);
1720  m0_spiel_tx_close(&tx);
1721  }
1722  m0_fi_disable("storage_devs_conf_expired_cb", "skip_storage_devs_expired_cb");
1723  m0_fi_disable("storage_devs_conf_ready_async_cb",
1724  "skip_storage_devs_ready_cb");
1725  spiel_conf_ut_fini();
1726 }
1727 
1731 static void spiel_conf_drop_svc(void)
1732 {
1733  struct m0_spiel_tx tx;
1734  int rc;
1735 
1736  spiel_conf_ut_init();
1737  spiel_conf_create_conf_with_opt(&spiel, &tx, SCO_DROP_SERVICE);
1738  rc = m0_spiel_tx_commit(&tx);
1739  M0_UT_ASSERT(rc == 0);
1740  m0_spiel_tx_close(&tx);
1741  spiel_conf_ut_fini();
1742 }
1743 
1747 static void spiel_conf_add_svc(void)
1748 {
1749  struct m0_spiel_tx tx;
1750  int rc;
1751 
1752  spiel_conf_ut_init();
1753  spiel_conf_create_conf_with_opt(&spiel, &tx, SCO_ADD_SERVICE);
1754  rc = m0_spiel_tx_commit(&tx);
1755  M0_UT_ASSERT(rc == 0);
1756  m0_spiel_tx_close(&tx);
1757  spiel_conf_ut_fini();
1758 }
1759 
1763 static void spiel_conf_big_db(void)
1764 {
1765 #define SVC_EP "0@lo:12345:41:201"
1766  struct m0_spiel_tx tx;
1767  int rc;
1768  int i;
1769  int svc_nr;
1770  struct m0_fid fid = spiel_obj_fid[SPIEL_UT_OBJ_SERVICE11];
1771  const char *svc_ep[] = { SVC_EP, NULL };
1772  struct m0_spiel_service_info svc_info = {
1773  .svi_type = M0_CST_DS1,
1774  .svi_endpoints = svc_ep
1775  };
1776  m0_bcount_t seg_size;
1777  char *cache_str;
1778  uint32_t svc_str_size =
1779  sizeof("{0x73|((^s|1:0), @M0_CST_MDS, [1: "SVC_EP"], [0],"
1780  " [0])},") - 1;
1781 
1782  spiel_conf_ut_init();
1783  spiel_conf_create_configuration(&spiel, &tx);
1788  m0_fi_enable("m0_conf_segment_size", "const_size");
1789  seg_size = m0_conf_segment_size(NULL);
1790  m0_fi_disable("m0_conf_segment_size", "const_size");
1791  svc_nr = seg_size/svc_str_size + 1;
1792  for (i = 0; i < svc_nr; i++) {
1793  fid.f_key++;
1794  rc = m0_spiel_service_add(&tx, &fid,
1795  &spiel_obj_fid[SPIEL_UT_OBJ_PROCESS],
1796  &svc_info);
1797  M0_UT_ASSERT(rc == 0);
1798  }
1799  rc = m0_conf_cache_to_string(&tx.spt_cache, &cache_str, false);
1800  M0_UT_ASSERT(rc == 0);
1801  M0_UT_ASSERT(strlen(cache_str) > seg_size);
1802  rc = m0_spiel_tx_commit(&tx);
1803  M0_UT_ASSERT(rc == 0);
1804  m0_confx_string_free(cache_str);
1805  m0_spiel_tx_close(&tx);
1806  spiel_conf_ut_fini();
1807 }
1808 
1809 static void spiel_conf_flip_fail(void)
1810 {
1811  struct m0_spiel_tx tx;
1812  int rc;
1813 
1814  spiel_conf_ut_init();
1815  spiel_conf_create_configuration(&spiel, &tx);
1816  m0_fi_enable_once("conf_flip_confd_config_save", "fcreate_failed");
1817  rc = m0_spiel_tx_commit(&tx);
1818  M0_UT_ASSERT(rc == -ENOENT);
1819  m0_spiel_tx_close(&tx);
1820  spiel_conf_ut_fini();
1821 }
1822 
1823 static void spiel_conf_check_fail(void)
1824 {
1825  struct m0_spiel_tx tx;
1826  int rc;
1827  struct m0_conf_obj *obj = NULL;
1828  struct m0_conf_obj *obj_parent;
1829  struct m0_conf_cache *cache = &tx.spt_cache;
1830  struct m0_fid fake_fid = M0_FID_TINIT('n', 6, 600 );
1831 
1832  spiel_conf_ut_init();
1833  spiel_conf_create_configuration(&spiel, &tx);
1834 
1835  m0_tl_for(m0_conf_cache, &cache->ca_registry, obj) {
1836  if (m0_conf_obj_type(obj) == &M0_CONF_PROCESS_TYPE)
1837  break;
1838  } m0_tl_endfor;
1839 
1840  /* spiel_check_cache(tx) test */
1841  obj->co_status = M0_CS_MISSING;
1842  rc = m0_spiel_tx_commit(&tx);
1843  obj->co_status = M0_CS_READY;
1844  M0_UT_ASSERT(rc == -EBUSY);
1845 
1846  obj_parent = obj->co_parent;
1847 
1848  obj->co_parent = NULL;
1849  rc = m0_spiel_tx_commit(&tx);
1850  M0_UT_ASSERT(rc == -ENOENT);
1851 
1852  obj->co_parent = m0_conf_obj_create(&fake_fid, cache);
1853  rc = m0_spiel_tx_commit(&tx);
1854  M0_UT_ASSERT(rc == -ENOENT);
1855 
1856  obj->co_parent->co_ops->coo_delete(obj->co_parent);
1857  obj->co_parent = obj_parent;
1858 
1859  /* conf_cache_encode test */
1860  m0_fi_enable_once("m0_spiel_tx_commit_forced", "encode_fail");
1861  rc = m0_spiel_tx_commit(&tx);
1862  M0_UT_ASSERT(rc == -ENOMEM);
1863 
1864  m0_spiel_tx_close(&tx);
1865  spiel_conf_ut_fini();
1866 }
1867 
1868 static void spiel_conf_load_fail(void)
1869 {
1870  struct m0_spiel_tx tx;
1871  int rc;
1872 
1873  spiel_conf_ut_init();
1874  spiel_conf_create_configuration(&spiel, &tx);
1875  m0_fi_enable_once("m0_spiel_tx_commit_forced", "cmd_alloc_fail");
1876  rc = m0_spiel_tx_commit(&tx);
1877  M0_UT_ASSERT(rc == -ENOMEM);
1878 
1879  m0_spiel_tx_close(&tx);
1880  spiel_conf_ut_fini();
1881 }
1882 
1883 static void spiel_conf_dump(void)
1884 {
1885  struct m0_spiel_tx tx;
1886  struct m0_spiel_tx tx_bad;
1887  const char *filename = "config.xc";
1888  const char *filename_bad = "config_b.xc";
1889  const int ver_forced = 10;
1890  int rc;
1891 
1892  spiel_conf_ut_init();
1893 
1894  spiel_conf_create_configuration(&spiel, &tx);
1895  rc = m0_spiel_tx_validate(&tx);
1896  M0_UT_ASSERT(rc == 0);
1897  rc = m0_spiel_tx_dump(&tx, ver_forced, filename);
1898  M0_UT_ASSERT(rc == 0);
1899  M0_UT_ASSERT(m0_conf_version(&tx.spt_cache) == ver_forced);
1900 
1901  spiel_conf_create_invalid_configuration(&spiel, &tx_bad);
1902  rc = m0_spiel_tx_validate(&tx_bad);
1903  M0_UT_ASSERT(rc != 0);
1904  rc = m0_spiel_tx_dump_debug(&tx_bad, 2, filename_bad);
1905  M0_UT_ASSERT(rc == 0);
1906 
1907  spiel_conf_ut_fini();
1908 }
1909 
1910 static void spiel_conf_tx_invalid(void)
1911 {
1912  struct m0_spiel_tx tx;
1913  int rc;
1914 
1915  spiel_conf_ut_init();
1916  spiel_conf_create_invalid_configuration(&spiel, &tx);
1917  rc = m0_spiel_tx_validate(&tx);
1918  M0_UT_ASSERT(rc != 0);
1919  spiel_conf_ut_fini();
1920 }
1921 
1922 static void spiel_conf_tx_no_spiel(void)
1923 {
1924  struct m0_spiel_tx tx;
1925  const int ver_forced = 10;
1926  char *local_conf;
1927  int rc;
1928 
1929  spiel_conf_create_configuration(NULL, &tx);
1930  rc = m0_spiel_tx_validate(&tx);
1931  M0_UT_ASSERT(rc == 0);
1932  rc = m0_spiel_tx_to_str(&tx, ver_forced, &local_conf);
1933  M0_UT_ASSERT(rc == 0);
1934  M0_UT_ASSERT(m0_conf_version(&tx.spt_cache) == ver_forced);
1935  m0_spiel_tx_str_free(local_conf);
1936  m0_spiel_tx_close(&tx);
1937 }
1938 
1939 static void spiel_conf_expired(void)
1940 {
1941  struct m0_confc *confc = m0_motr2confc(
1942  &ut_reqh.sur_confd_srv.rsx_motr_ctx);
1943  struct m0_spiel_tx tx;
1944  struct m0_rm_ha_tracker tracker;
1945  char *rm_ep = "0@lo:12345:34:1";
1946  int rc;
1947 
1948  m0_fi_enable("rm_ha_sbscr_diter_next", "subscribe");
1949  spiel_conf_ut_init();
1950  m0_rm_ha_tracker_init(&tracker, NULL);
1951  m0_rm_ha_subscribe_sync(confc, rm_ep, &tracker);
1952  spiel_conf_create_configuration(&spiel, &tx);
1953  rc = m0_spiel_tx_commit(&tx);
1954  M0_UT_ASSERT(rc == 0);
1955  m0_spiel_tx_close(&tx);
1956  m0_rm_ha_tracker_fini(&tracker);
1957  spiel_conf_ut_fini();
1958  m0_fi_disable("rm_ha_sbscr_diter_next", "subscribe");
1959 }
1960 
1961 static void spiel_conf_wlock_get_fail(void)
1962 {
1963  struct m0_spiel_tx tx;
1964  int rc;
1965 
1966  spiel_conf_ut_init();
1967  spiel_conf_create_configuration(&spiel, &tx);
1968  m0_fi_enable_once("spiel_tx_write_lock_get", "borrow-request-failure");
1969  rc = m0_spiel_tx_commit(&tx);
1970  M0_UT_ASSERT(rc == -EIO);
1971  m0_spiel_tx_close(&tx);
1972  spiel_conf_ut_fini();
1973 }
1974 
1975 struct m0_ut_suite spiel_conf_ut = {
1976  .ts_name = "spiel-conf-ut",
1977  .ts_tests = {
1978  { "create-ok", spiel_conf_create_ok },
1979  { "create-fail", spiel_conf_create_fail },
1980  { "delete", spiel_conf_delete },
1981  { "file", spiel_conf_file },
1982  { "cancel", spiel_conf_cancel },
1983  { "load-send", spiel_conf_load_send },
1984  { "big-db", spiel_conf_big_db },
1985  { "flip-fail", spiel_conf_flip_fail },
1986  { "check-fail", spiel_conf_check_fail },
1987  { "load-fail", spiel_conf_load_fail },
1988  { "dump", spiel_conf_dump },
1989  { "tx-invalid", spiel_conf_tx_invalid },
1990  { "tx-no-spiel", spiel_conf_tx_no_spiel },
1991  { "drop-svc", spiel_conf_drop_svc },
1992  { "add-svc", spiel_conf_add_svc },
1993  { "conf-expired", spiel_conf_expired },
1994  { "wlock-get-fail", spiel_conf_wlock_get_fail },
1995  { NULL, NULL },
1996  },
1997 };
1998 M0_EXPORTED(spiel_conf_ut);
1999 
2000 #undef M0_TRACE_SUBSYSTEM
2001 
2002 /*
2003  * Local variables:
2004  * c-indentation-style: "K&R"
2005  * c-basic-offset: 8
2006  * tab-width: 8
2007  * fill-column: 80
2008  * scroll-step: 1
2009  * End:
2010  */
seg_size
static m0_bcount_t seg_size
Definition: net.c:118
m0_conf_obj_type
const struct m0_conf_obj_type * m0_conf_obj_type(const struct m0_conf_obj *obj)
Definition: obj.c:363
m0_spiel_pver_formulaic_add
int m0_spiel_pver_formulaic_add(struct m0_spiel_tx *tx, const struct m0_fid *fid, const struct m0_fid *parent, uint32_t index, const struct m0_fid *base_pver, uint32_t *allowance, uint32_t allowance_len)
Definition: conf_mgmt.c:1659
SPIEL_UT_OBJ_SDEV9
Definition: spiel_conf_ut.c:75
cache
Definition: beck.c:235
lock
static struct m0_mutex lock
Definition: transmit.c:326
SPIEL_UT_OBJ_ENCLOSURE
Definition: spiel_conf_ut.c:80
SPIEL_UT_OBJ_DRIVE9
Definition: spiel_conf_ut.c:92
SCO_DROP_SDEV
Definition: spiel_conf_ut.c:229
SPIEL_UT_OBJ_SERVICE2
Definition: spiel_conf_ut.c:55
m0_conf_rack::cr_pvers
struct m0_conf_pver ** cr_pvers
Definition: obj.h:675
spiel_conf_add_svc
static void spiel_conf_add_svc(void)
Definition: spiel_conf_ut.c:1747
SPIEL_UT_OBJ_NODE
Definition: spiel_conf_ut.c:50
m0_conf_version
m0_conf_version
Definition: cache.h:75
m0_bitmap_init
M0_INTERNAL int m0_bitmap_init(struct m0_bitmap *map, size_t nr)
Definition: bitmap.c:86
SPIEL_UT_OBJ_SDEV4
Definition: spiel_conf_ut.c:70
m0_mutex_unlock
M0_INTERNAL void m0_mutex_unlock(struct m0_mutex *mutex)
Definition: mutex.c:66
spiel_conf_load_send
static void spiel_conf_load_send(void)
Definition: spiel_conf_ut.c:1702
m0_spiel_tx_dump_debug
int m0_spiel_tx_dump_debug(struct m0_spiel_tx *tx, uint64_t ver_forced, const char *filename)
Definition: conf_mgmt.c:2212
m0_spiel_tx_commit
int m0_spiel_tx_commit(struct m0_spiel_tx *tx)
Definition: conf_mgmt.c:723
NULL
#define NULL
Definition: misc.h:38
SPIEL_UT_OBJ_CONTROLLER2
Definition: spiel_conf_ut.c:83
spiel_conf_wlock_get_fail
static void spiel_conf_wlock_get_fail(void)
Definition: spiel_conf_ut.c:1961
spiel_conf_file_create_tree
static void spiel_conf_file_create_tree(struct m0_spiel_tx *tx)
Definition: spiel_conf_ut.c:1480
SPIEL_UT_OBJ_SDEV3
Definition: spiel_conf_ut.c:69
m0_bitmap_fini
M0_INTERNAL void m0_bitmap_fini(struct m0_bitmap *map)
Definition: bitmap.c:97
m0_spiel_tx_validate
int m0_spiel_tx_validate(struct m0_spiel_tx *tx)
Definition: conf_mgmt.c:136
m0_spiel_service_add
int m0_spiel_service_add(struct m0_spiel_tx *tx, const struct m0_fid *fid, const struct m0_fid *parent, const struct m0_spiel_service_info *service_info)
Definition: conf_mgmt.c:1101
SPIEL_UT_OBJ_NODE2
Definition: spiel_conf_ut.c:51
m0_spiel_profile_add
int m0_spiel_profile_add(struct m0_spiel_tx *tx, const struct m0_fid *fid)
Definition: conf_mgmt.c:1236
m0_spiel_pool_add
int m0_spiel_pool_add(struct m0_spiel_tx *tx, const struct m0_fid *fid, uint32_t pver_policy)
Definition: conf_mgmt.c:1339
SPIEL_UT_OBJ_DRIVE7
Definition: spiel_conf_ut.c:90
spiel_conf_tx_no_spiel
static void spiel_conf_tx_no_spiel(void)
Definition: spiel_conf_ut.c:1922
SPIEL_UT_OBJ_POOL
Definition: spiel_conf_ut.c:47
spiel_conf_create_invalid_configuration
static void spiel_conf_create_invalid_configuration(struct m0_spiel *spiel, struct m0_spiel_tx *tx)
Definition: spiel_conf_ut.c:621
m0_pdclust_attr::pa_N
uint32_t pa_N
Definition: pdclust.h:104
spiel_conf_ut_fini
static void spiel_conf_ut_fini(void)
Definition: spiel_conf_ut.c:211
SPIEL_UT_OBJ_RACK
Definition: spiel_conf_ut.c:78
m0_conf_cache_lookup
M0_INTERNAL struct m0_conf_obj * m0_conf_cache_lookup(const struct m0_conf_cache *cache, const struct m0_fid *id)
Definition: cache.c:106
SPIEL_UT_OBJ_DRIVE4
Definition: spiel_conf_ut.c:87
SPIEL_UT_OBJ_PVER
Definition: spiel_conf_ut.c:48
m0_file_read
M0_INTERNAL int m0_file_read(const char *path, char **out)
Definition: fs.c:61
spiel_conf_tx_invalid
static void spiel_conf_tx_invalid(void)
Definition: spiel_conf_ut.c:1910
m0_confx_string_free
M0_INTERNAL void m0_confx_string_free(char *str)
Definition: preload.c:86
spiel_conf_check_fail
static void spiel_conf_check_fail(void)
Definition: spiel_conf_ut.c:1823
m0_conf_cache
Definition: cache.h:94
spiel_conf_opts
spiel_conf_opts
Definition: spiel_conf_ut.c:225
m0_conf_controller::cc_pvers
struct m0_conf_pver ** cc_pvers
Definition: obj.h:703
m0_conf_enclosure::ce_pvers
struct m0_conf_pver ** ce_pvers
Definition: obj.h:690
m0_spiel_ut_reqh::sur_confd_srv
struct m0_rpc_server_ctx sur_confd_srv
Definition: spiel_ut_common.h:53
spiel_conf_create_configuration
static void spiel_conf_create_configuration(struct m0_spiel *spiel, struct m0_spiel_tx *tx)
Definition: spiel_conf_ut.c:612
m0_spiel_tx_str_free
void m0_spiel_tx_str_free(char *str)
Definition: conf_mgmt.c:2182
spiel_conf_pver_check
static void spiel_conf_pver_check(struct m0_spiel_tx *tx)
Definition: spiel_conf_ut.c:743
M0_CFG_DEVICE_MEDIA_SSD
Definition: schema.h:141
obj_ops.h
m0_spiel_pool_version_done
int m0_spiel_pool_version_done(struct m0_spiel_tx *tx, const struct m0_fid *fid)
Definition: conf_mgmt.c:2075
SPIEL_UT_OBJ_DRIVE3
Definition: spiel_conf_ut.c:86
m0_spiel_root_add
int m0_spiel_root_add(struct m0_spiel_tx *tx, const struct m0_fid *rootfid, const struct m0_fid *mdpool, const struct m0_fid *imeta_pver, uint32_t mdredundancy, const char **params)
Definition: conf_mgmt.c:902
SPIEL_UT_OBJ_ENCLOSURE_V
Definition: spiel_conf_ut.c:96
m0_spiel_service_info::svi_endpoints
const char ** svi_endpoints
Definition: spiel.h:445
SPIEL_UT_OBJ_SDEV
Definition: spiel_conf_ut.c:67
SCO_DROP_PROCESS
Definition: spiel_conf_ut.c:227
M0_CS_MISSING
Definition: obj.h:194
m0_bcount_t
uint64_t m0_bcount_t
Definition: types.h:77
m0_mutex_lock
M0_INTERNAL void m0_mutex_lock(struct m0_mutex *mutex)
Definition: mutex.c:49
SPIEL_UT_OBJ_SITE
Definition: spiel_conf_ut.c:77
SVC_EP
#define SVC_EP
m0_ut_suite
Definition: ut.h:77
m0_conf_pver
Definition: obj.h:532
SPIEL_UT_OBJ_ENCLOSURE2
Definition: spiel_conf_ut.c:81
m0_conf_segment_size
M0_INTERNAL m0_bcount_t m0_conf_segment_size(struct m0_fop *fop)
Definition: load_fop.c:65
obj
static struct foo * obj
Definition: tlist.c:302
buf
Definition: sock.c:887
SPIEL_UT_OBJ_SDEV10
Definition: spiel_conf_ut.c:76
m0_tl_endfor
#define m0_tl_endfor
Definition: tlist.h:700
fid
struct m0_fid fid
Definition: di.c:46
m0_spiel_tx_close
void m0_spiel_tx_close(struct m0_spiel_tx *tx)
Definition: conf_mgmt.c:171
SPIEL_UT_OBJ_SDEV7
Definition: spiel_conf_ut.c:73
m0_spiel_site_add
int m0_spiel_site_add(struct m0_spiel_tx *tx, const struct m0_fid *fid)
Definition: conf_mgmt.c:1382
ep
Definition: sock.c:754
SPIEL_UT_OBJ_SERVICE13
Definition: spiel_conf_ut.c:66
m0_spiel__ut_fini
M0_INTERNAL void m0_spiel__ut_fini(struct m0_spiel *spiel, bool cmd_iface)
Definition: spiel_ut_common.c:179
SPIEL_UT_OBJ_SERVICE10
Definition: spiel_conf_ut.c:63
SPIEL_UT_OBJ_DRIVE_V
Definition: spiel_conf_ut.c:98
i
int i
Definition: dir.c:1033
SPIEL_UT_OBJ_PROCESS
Definition: spiel_conf_ut.c:52
spiel_conf_ut_init
static void spiel_conf_ut_init(void)
Definition: spiel_conf_ut.c:190
m0_rm_ha_tracker_fini
M0_INTERNAL void m0_rm_ha_tracker_fini(struct m0_rm_ha_tracker *tracker)
Definition: rm_ha.c:408
spiel_conf_load_fail
static void spiel_conf_load_fail(void)
Definition: spiel_conf_ut.c:1868
m0_rconfc
Definition: rconfc.h:220
SCO_ADD_PROCESS
Definition: spiel_conf_ut.c:230
m0_spiel_enclosure_v_add
int m0_spiel_enclosure_v_add(struct m0_spiel_tx *tx, const struct m0_fid *fid, const struct m0_fid *parent, const struct m0_fid *real)
Definition: conf_mgmt.c:1816
M0_FID_TINIT
#define M0_FID_TINIT(type, container, key)
Definition: fid.h:90
m0_spiel_drive_add
int m0_spiel_drive_add(struct m0_spiel_tx *tx, const struct m0_fid *fid, const struct m0_fid *parent)
Definition: conf_mgmt.c:1562
m0_spiel_tx_dump
int m0_spiel_tx_dump(struct m0_spiel_tx *tx, uint64_t ver_forced, const char *filename)
Definition: conf_mgmt.c:2205
m0_fi_disable
M0_INTERNAL void m0_fi_disable(const char *fp_func, const char *fp_tag)
Definition: finject.c:485
m0_conf_ut_ast_thread_fini
M0_INTERNAL int m0_conf_ut_ast_thread_fini(void)
Definition: common.c:96
spiel_conf_drop_svc
static void spiel_conf_drop_svc(void)
Definition: spiel_conf_ut.c:1731
m0_fi_enable
static void m0_fi_enable(const char *func, const char *tag)
Definition: finject.h:276
m0_rm_ha_tracker
Definition: rm_ha.h:99
M0_ASSERT
#define M0_ASSERT(cond)
SPIEL_UT_OBJ_SDEV5
Definition: spiel_conf_ut.c:71
m0_conf_cache_to_string
M0_INTERNAL int m0_conf_cache_to_string(struct m0_conf_cache *cache, char **str, bool debug)
Definition: cache.c:257
m0_conf_controller
Definition: obj.h:694
confc
static struct m0_confc * confc
Definition: file.c:94
SPIEL_UT_OBJ_DRIVE8
Definition: spiel_conf_ut.c:91
m0_spiel_profile_pool_add
int m0_spiel_profile_pool_add(struct m0_spiel_tx *tx, const struct m0_fid *profile, const struct m0_fid *pool)
Definition: conf_mgmt.c:1304
ut_reqh
struct m0_spiel_ut_reqh ut_reqh
Definition: spiel_ut_common.c:31
pver
struct m0_fid pver
Definition: idx_dix.c:74
m0_pdclust_attr
Definition: pdclust.h:102
spiel_conf_create_ok
static void spiel_conf_create_ok(void)
Definition: spiel_conf_ut.c:733
spiel_conf_create_pver_tree
static void spiel_conf_create_pver_tree(struct m0_spiel_tx *tx)
Definition: spiel_conf_ut.c:817
SPIEL_UT_OBJ_CONTROLLER
Definition: spiel_conf_ut.c:82
M0_CST_NR
Definition: schema.h:198
spiel_conf_ut
struct m0_ut_suite spiel_conf_ut
Definition: spiel_conf_ut.c:1975
m0_conf_cache_init
M0_INTERNAL void m0_conf_cache_init(struct m0_conf_cache *cache, struct m0_mutex *lock)
Definition: cache.c:66
m0_reqh_context::rc_reqh
struct m0_reqh rc_reqh
Definition: setup.h:312
m0_spiel_element_del
int m0_spiel_element_del(struct m0_spiel_tx *tx, const struct m0_fid *fid)
Definition: conf_mgmt.c:2124
local_conf
static char local_conf[]
Definition: file.c:115
m0_spiel_rack_add
int m0_spiel_rack_add(struct m0_spiel_tx *tx, const struct m0_fid *fid, const struct m0_fid *parent)
Definition: conf_mgmt.c:1426
SPIEL_UT_OBJ_RACK_V
Definition: spiel_conf_ut.c:95
m0_spiel_tx
Definition: spiel.h:260
m0_spiel_tx::spt_lock
struct m0_mutex spt_lock
Definition: spiel.h:266
spiel_conf_expired
static void spiel_conf_expired(void)
Definition: spiel_conf_ut.c:1939
m0_mutex_init
M0_INTERNAL void m0_mutex_init(struct m0_mutex *mutex)
Definition: mutex.c:35
m0_fid::f_container
uint64_t f_container
Definition: fid.h:39
spiel_conf_delete
static void spiel_conf_delete(void)
Definition: spiel_conf_ut.c:1447
m0_motr2confc
M0_INTERNAL struct m0_confc * m0_motr2confc(struct m0_motr *motr)
Definition: setup.c:191
m0_rconfc_lock
M0_INTERNAL void m0_rconfc_lock(struct m0_rconfc *rconfc)
Definition: rconfc.c:2841
m0_spiel_enclosure_add
int m0_spiel_enclosure_add(struct m0_spiel_tx *tx, const struct m0_fid *fid, const struct m0_fid *parent, const struct m0_fid *node)
Definition: conf_mgmt.c:1470
m0_bitmap_set
M0_INTERNAL void m0_bitmap_set(struct m0_bitmap *map, size_t idx, bool val)
Definition: bitmap.c:139
m0_spiel_pver_actual_add
int m0_spiel_pver_actual_add(struct m0_spiel_tx *tx, const struct m0_fid *fid, const struct m0_fid *parent, const struct m0_pdclust_attr *attrs, uint32_t *tolerance, uint32_t tolerance_len)
Definition: conf_mgmt.c:1601
m0_conf_obj
Definition: obj.h:206
m0_rm_ha_subscribe_sync
M0_INTERNAL int m0_rm_ha_subscribe_sync(struct m0_confc *confc, const char *rem_ep, struct m0_rm_ha_tracker *tracker)
Definition: rm_ha.c:360
SPIEL_UT_OBJ_SDEV6
Definition: spiel_conf_ut.c:72
SPIEL_UT_OBJ_SERVICE5
Definition: spiel_conf_ut.c:58
SPIEL_UT_OBJ_SERVICE11
Definition: spiel_conf_ut.c:64
m0_spiel_controller_v_add
int m0_spiel_controller_v_add(struct m0_spiel_tx *tx, const struct m0_fid *fid, const struct m0_fid *parent, const struct m0_fid *real)
Definition: conf_mgmt.c:1864
M0_CONF_CAST
#define M0_CONF_CAST(ptr, type)
Definition: obj.h:780
m0_spiel_controller_add
int m0_spiel_controller_add(struct m0_spiel_tx *tx, const struct m0_fid *fid, const struct m0_fid *parent)
Definition: conf_mgmt.c:1518
m0_spiel_device_add
int m0_spiel_device_add(struct m0_spiel_tx *tx, const struct m0_fid *fid, const struct m0_fid *parent, const struct m0_fid *drive, uint32_t dev_idx, enum m0_cfg_storage_device_interface_type iface, enum m0_cfg_storage_device_media_type media, uint32_t bsize, uint64_t size, uint64_t last_state, uint64_t flags, const char *filename)
Definition: conf_mgmt.c:1156
SPIEL_UT_OBJ_DRIVE
Definition: spiel_conf_ut.c:84
SPIEL_UT_OBJ_CONTROLLER_V
Definition: spiel_conf_ut.c:97
m0_spiel__ut_init
M0_INTERNAL void m0_spiel__ut_init(struct m0_spiel *spiel, const char *confd_path, bool cmd_iface)
Definition: spiel_ut_common.c:153
SPIEL_UT_OBJ_DRIVE10
Definition: spiel_conf_ut.c:93
error_injection.dest
dest
Definition: error_injection.py:49
m0_conf_ut_ast_thread_init
M0_INTERNAL int m0_conf_ut_ast_thread_init(void)
Definition: common.c:86
m0_spiel_ut_reqh
Definition: spiel_ut_common.h:48
m0_fi_enable_off_n_on_m
static void m0_fi_enable_off_n_on_m(const char *func, const char *tag, uint32_t n, uint32_t m)
Definition: finject.h:346
SPIEL_UT_OBJ_PROCESS2
Definition: spiel_conf_ut.c:53
SCO_NO_CHANGE
Definition: spiel_conf_ut.c:226
m0_spiel_tx_open
void m0_spiel_tx_open(struct m0_spiel *spiel, struct m0_spiel_tx *tx)
Definition: conf_mgmt.c:105
SPIEL_UT_OBJ_PVER_F
Definition: spiel_conf_ut.c:49
m0_conf_enclosure
Definition: obj.h:679
spiel_conf_create_conf_with_opt
static void spiel_conf_create_conf_with_opt(struct m0_spiel *spiel, struct m0_spiel_tx *tx, uint64_t opts)
Definition: spiel_conf_ut.c:235
m0_ut_suite::ts_name
const char * ts_name
Definition: ut.h:99
SPIEL_UT_OBJ_DRIVE5
Definition: spiel_conf_ut.c:88
spiel_conf_file
static void spiel_conf_file(void)
Definition: spiel_conf_ut.c:1647
spiel_copy_file
static int spiel_copy_file(const char *source, const char *dest)
Definition: spiel_conf_ut.c:157
m0_rconfc_unlock
M0_INTERNAL void m0_rconfc_unlock(struct m0_rconfc *rconfc)
Definition: rconfc.c:2855
m0_rconfc::rc_expired_cb
m0_rconfc_cb_t rc_expired_cb
Definition: rconfc.h:278
spiel_obj_fid
static struct m0_fid spiel_obj_fid[]
Definition: spiel_conf_ut.c:101
m0_conf_obj_create
M0_INTERNAL struct m0_conf_obj * m0_conf_obj_create(const struct m0_fid *id, struct m0_conf_cache *cache)
Definition: obj_ops.c:80
m0_spiel_tx_to_str
int m0_spiel_tx_to_str(struct m0_spiel_tx *tx, uint64_t ver_forced, char **str)
Definition: conf_mgmt.c:2174
m0_spiel_rack_v_add
int m0_spiel_rack_v_add(struct m0_spiel_tx *tx, const struct m0_fid *fid, const struct m0_fid *parent, const struct m0_fid *real)
Definition: conf_mgmt.c:1768
m0_spiel_drive_v_add
int m0_spiel_drive_v_add(struct m0_spiel_tx *tx, const struct m0_fid *fid, const struct m0_fid *parent, const struct m0_fid *real)
Definition: conf_mgmt.c:1912
ep
char * ep
Definition: sw.h:132
m0_spiel_process_add
int m0_spiel_process_add(struct m0_spiel_tx *tx, const struct m0_fid *fid, const struct m0_fid *parent, struct m0_bitmap *cores, uint64_t memlimit_as, uint64_t memlimit_rss, uint64_t memlimit_stack, uint64_t memlimit_memlock, const char *endpoint)
Definition: conf_mgmt.c:1033
m0_spiel_tx::spt_cache
struct m0_conf_cache spt_cache
Definition: spiel.h:264
SCO_DROP_SERVICE
Definition: spiel_conf_ut.c:228
SPIEL_UT_OBJ_DRIVE6
Definition: spiel_conf_ut.c:89
m0_motr::cc_reqh_ctx
struct m0_reqh_context cc_reqh_ctx
Definition: setup.h:361
spiel_ut_common.h
m0_fid
Definition: fid.h:38
load_fop.h
m0_spiel_service_info
Definition: spiel.h:438
m0_fid::f_key
uint64_t f_key
Definition: fid.h:40
SPIEL_UT_OBJ_RACK2
Definition: spiel_conf_ut.c:79
m0_bitmap
Definition: bitmap.h:42
M0_CFG_DEVICE_INTERFACE_NR
Definition: schema.h:128
spiel_conf_flip_fail
static void spiel_conf_flip_fail(void)
Definition: spiel_conf_ut.c:1809
M0_CFG_DEVICE_MEDIA_NR
Definition: schema.h:149
M0_CS_READY
Definition: obj.h:196
m0_conf_cache_from_string
M0_INTERNAL int m0_conf_cache_from_string(struct m0_conf_cache *cache, const char *str)
Definition: cache.c:278
SPIEL_UT_OBJ_SERVICE
Definition: spiel_conf_ut.c:54
spiel
struct m0_spiel spiel
Definition: spiel_conf_ut.c:42
spiel_conf_pver_delete_check
static void spiel_conf_pver_delete_check(struct m0_spiel_tx *tx)
Definition: spiel_conf_ut.c:789
m0_spiel_node_add
int m0_spiel_node_add(struct m0_spiel_tx *tx, const struct m0_fid *fid, uint32_t memsize, uint32_t nr_cpu, uint64_t last_state, uint64_t flags)
Definition: conf_mgmt.c:974
SPIEL_UT_OBJ_SERVICE3
Definition: spiel_conf_ut.c:56
params
Definition: common.h:34
spiel_conf_cancel
static void spiel_conf_cancel(void)
Definition: spiel_conf_ut.c:1689
m0_mutex_fini
M0_INTERNAL void m0_mutex_fini(struct m0_mutex *mutex)
Definition: mutex.c:42
SPIEL_UT_OBJ_SDEV2
Definition: spiel_conf_ut.c:68
SPIEL_UT_OBJ_PROFILE
Definition: spiel_conf_ut.c:46
m0_fi_enable_once
static void m0_fi_enable_once(const char *func, const char *tag)
Definition: finject.h:301
rconfc
static struct m0_rconfc * rconfc(struct m0_client *m0c)
Definition: client_init.c:310
SPIEL_UT_OBJ_SERVICE4
Definition: spiel_conf_ut.c:57
m0_reqh::rh_rconfc
struct m0_rconfc rh_rconfc
Definition: reqh.h:166
m0_conf_rack
Definition: obj.h:666
m0_rm_ha_tracker_init
M0_INTERNAL void m0_rm_ha_tracker_init(struct m0_rm_ha_tracker *tracker, m0_chan_cb_t cb)
Definition: rm_ha.c:399
m0_confc_ready_cb
M0_INTERNAL void m0_confc_ready_cb(struct m0_rconfc *rconfc)
Definition: helpers.c:488
SPIEL_UT_OBJ_SERVICE8
Definition: spiel_conf_ut.c:61
SERVER_ENDPOINT_ADDR
#define SERVER_ENDPOINT_ADDR
Definition: common.h:30
m0_spiel_service_info::svi_type
enum m0_conf_service_type svi_type
Definition: spiel.h:440
error_injection.filename
filename
Definition: error_injection.py:96
M0_CONF_PROCESS_TYPE
const struct m0_conf_obj_type M0_CONF_PROCESS_TYPE
Definition: process.c:161
M0_UT_PATH
#define M0_UT_PATH(name)
Definition: misc.h:41
m0_spiel_site_v_add
int m0_spiel_site_v_add(struct m0_spiel_tx *tx, const struct m0_fid *fid, const struct m0_fid *parent, const struct m0_fid *real)
Definition: conf_mgmt.c:1716
m0_confc_expired_cb
M0_INTERNAL void m0_confc_expired_cb(struct m0_rconfc *rconfc)
Definition: helpers.c:465
m0_confc
Definition: confc.h:371
m0_bitmap::b_nr
size_t b_nr
Definition: bitmap.h:44
M0_FID0
#define M0_FID0
Definition: fid.h:93
SPIEL_UT_OBJ_SERVICE12
Definition: spiel_conf_ut.c:65
m0_conf_cache_fini
M0_INTERNAL void m0_conf_cache_fini(struct m0_conf_cache *cache)
Definition: cache.c:183
spiel_conf_big_db
static void spiel_conf_big_db(void)
Definition: spiel_conf_ut.c:1763
m0_spiel
Definition: spiel.h:192
source
Definition: net.c:93
m0_tl_for
#define m0_tl_for(name, head, obj)
Definition: tlist.h:695
spiel_conf_dump
static void spiel_conf_dump(void)
Definition: spiel_conf_ut.c:1883
m0_free
void m0_free(void *data)
Definition: memory.c:146
SPIEL_UT_OBJ_SITE_V
Definition: spiel_conf_ut.c:94
m0_mutex
Definition: mutex.h:47
SPIEL_UT_OBJ_SERVICE7
Definition: spiel_conf_ut.c:60
M0_CFG_DEVICE_INTERFACE_SCSI
Definition: schema.h:123
FID_MOVE
#define FID_MOVE(fid, step)
Definition: spiel_conf_ut.c:618
SCO_ADD_SERVICE
Definition: spiel_conf_ut.c:231
rc
int32_t rc
Definition: trigger_fop.h:47
SCO_ADD_SDEV
Definition: spiel_conf_ut.c:232
ARRAY_SIZE
#define ARRAY_SIZE(a)
Definition: misc.h:45
SPIEL_UT_OBJ_SDEV8
Definition: spiel_conf_ut.c:74
M0_UT_ASSERT
#define M0_UT_ASSERT(a)
Definition: ut.h:46
m0_rpc_server_ctx::rsx_motr_ctx
struct m0_motr rsx_motr_ctx
Definition: rpclib.h:84
SPIEL_UT_OBJ_SERVICE6
Definition: spiel_conf_ut.c:59
m0_rconfc::rc_ready_cb
m0_rconfc_cb_t rc_ready_cb
Definition: rconfc.h:294
SPIEL_UT_OBJ_DRIVE2
Definition: spiel_conf_ut.c:85
spiel_conf_create_fail
static void spiel_conf_create_fail(void)
Definition: spiel_conf_ut.c:1032
SPIEL_UT_OBJ_SERVICE9
Definition: spiel_conf_ut.c:62