1 /*****************************************************************************\
2 * proc_req.c - functions for processing incoming RPCs.
3 *****************************************************************************
4 * Copyright (C) 2008-2010 Lawrence Livermore National Security.
5 * Produced at Lawrence Livermore National Laboratory (cf, DISCLAIMER).
6 * Written by Morris Jette <jette1@llnl.gov>, Danny Auble <da@llnl.gov>
7 * CODE-OCEC-09-009. All rights reserved.
8 *
9 * This file is part of Slurm, a resource management program.
10 * For details, see <https://slurm.schedmd.com/>.
11 * Please also read the included file: DISCLAIMER.
12 *
13 * Slurm is free software; you can redistribute it and/or modify it under
14 * the terms of the GNU General Public License as published by the Free
15 * Software Foundation; either version 2 of the License, or (at your option)
16 * any later version.
17 *
18 * In addition, as a special exception, the copyright holders give permission
19 * to link the code of portions of this program with the OpenSSL library under
20 * certain conditions as described in each individual source file, and
21 * distribute linked combinations including the two. You must obey the GNU
22 * General Public License in all respects for all of the code used other than
23 * OpenSSL. If you modify file(s) with this exception, you may extend this
24 * exception to your version of the file(s), but you are not obligated to do
25 * so. If you do not wish to do so, delete this exception statement from your
26 * version. If you delete this exception statement from all source files in
27 * the program, then also delete it here.
28 *
29 * Slurm is distributed in the hope that it will be useful, but WITHOUT ANY
30 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
31 * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
32 * details.
33 *
34 * You should have received a copy of the GNU General Public License along
35 * with Slurm; if not, write to the Free Software Foundation, Inc.,
36 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
37 \*****************************************************************************/
38
39 #include "config.h"
40
41 #include <signal.h>
42
43 #if HAVE_SYS_PRCTL_H
44 #include <sys/prctl.h>
45 #endif
46
47 #include "src/common/slurm_auth.h"
48 #include "src/common/gres.h"
49 #include "src/common/macros.h"
50 #include "src/common/pack.h"
51 #include "src/common/slurmdbd_defs.h"
52 #include "src/common/slurmdbd_pack.h"
53 #include "src/common/slurm_accounting_storage.h"
54 #include "src/common/slurm_jobacct_gather.h"
55 #include "src/common/slurm_protocol_api.h"
56 #include "src/common/slurm_protocol_defs.h"
57 #include "src/common/timers.h"
58 #include "src/common/uid.h"
59 #include "src/common/xstring.h"
60 #include "src/slurmdbd/read_config.h"
61 #include "src/slurmdbd/rpc_mgr.h"
62 #include "src/slurmdbd/proc_req.h"
63 #include "src/slurmdbd/slurmdbd.h"
64 #include "src/slurmctld/slurmctld.h"
65
66 /* Local functions */
67 static bool _validate_slurm_user(uint32_t uid);
68 static bool _validate_super_user(uint32_t uid, slurmdbd_conn_t *slurmdbd_conn);
69 static bool _validate_operator(uint32_t uid, slurmdbd_conn_t *slurmdbd_conn);
70 static int _unpack_persist_init(slurmdbd_conn_t *slurmdbd_conn,
71 persist_msg_t *msg, Buf *out_buffer,
72 uint32_t *uid);
73 static int _add_accounts(slurmdbd_conn_t *slurmdbd_conn,
74 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
75 static int _add_account_coords(slurmdbd_conn_t *slurmdbd_conn,
76 persist_msg_t *msg, Buf *out_buffer,
77 uint32_t *uid);
78 static int _add_tres(slurmdbd_conn_t *slurmdbd_conn,
79 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
80 static int _add_assocs(slurmdbd_conn_t *slurmdbd_conn,
81 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
82 static int _add_clusters(slurmdbd_conn_t *slurmdbd_conn,
83 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
84 static int _add_federations(slurmdbd_conn_t *slurmdbd_conn,
85 persist_msg_t *msg,
86 Buf *out_buffer, uint32_t *uid);
87 static int _add_qos(slurmdbd_conn_t *slurmdbd_conn,
88 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
89 static int _add_res(slurmdbd_conn_t *slurmdbd_conn,
90 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
91 static int _add_users(slurmdbd_conn_t *slurmdbd_conn,
92 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
93 static int _add_wckeys(slurmdbd_conn_t *slurmdbd_conn,
94 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
95 static int _add_reservation(slurmdbd_conn_t *slurmdbd_conn,
96 persist_msg_t *msg, Buf *out_buffer,
97 uint32_t *uid);
98 static int _archive_dump(slurmdbd_conn_t *slurmdbd_conn,
99 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
100 static int _archive_load(slurmdbd_conn_t *slurmdbd_conn,
101 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
102 static int _clear_stats(slurmdbd_conn_t *slurmdbd_conn,
103 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
104 static int _cluster_tres(slurmdbd_conn_t *slurmdbd_conn,
105 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
106 static int _fix_runaway_jobs(slurmdbd_conn_t *slurmdbd_conn,
107 persist_msg_t *msg,
108 Buf *out_buffer, uint32_t *uid);
109 static int _get_accounts(slurmdbd_conn_t *slurmdbd_conn,
110 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
111 static int _get_tres(slurmdbd_conn_t *slurmdbd_conn,
112 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
113 static int _get_assocs(slurmdbd_conn_t *slurmdbd_conn,
114 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
115 static int _get_clusters(slurmdbd_conn_t *slurmdbd_conn,
116 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
117 static int _get_federations(slurmdbd_conn_t *slurmdbd_conn,
118 persist_msg_t *msg,
119 Buf *out_buffer, uint32_t *uid);
120 static int _get_config(slurmdbd_conn_t *slurmdbd_conn,
121 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
122 static int _get_events(slurmdbd_conn_t *slurmdbd_conn,
123 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
124 static int _get_jobs_cond(slurmdbd_conn_t *slurmdbd_conn,
125 persist_msg_t *msg, Buf *out_buffer,
126 uint32_t *uid);
127 static int _get_probs(slurmdbd_conn_t *slurmdbd_conn,
128 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
129 static int _get_qos(slurmdbd_conn_t *slurmdbd_conn,
130 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
131 static int _get_res(slurmdbd_conn_t *slurmdbd_conn,
132 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
133 static int _get_stats(slurmdbd_conn_t *slurmdbd_conn,
134 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
135 static int _get_txn(slurmdbd_conn_t *slurmdbd_conn,
136 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
137 static int _get_usage(slurmdbd_conn_t *slurmdbd_conn,
138 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
139 static int _get_users(slurmdbd_conn_t *slurmdbd_conn,
140 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
141 static int _get_wckeys(slurmdbd_conn_t *slurmdbd_conn,
142 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
143 static int _get_reservations(slurmdbd_conn_t *slurmdbd_conn,
144 persist_msg_t *msg, Buf *out_buffer,
145 uint32_t *uid);
146 static int _find_rpc_obj_in_list(void *x, void *key);
147 static int _flush_jobs(slurmdbd_conn_t *slurmdbd_conn,
148 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
149 static int _fini_conn(slurmdbd_conn_t *slurmdbd_conn, persist_msg_t *msg,
150 Buf *out_buffer);
151 static int _job_complete(slurmdbd_conn_t *slurmdbd_conn,
152 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
153 static int _job_start(slurmdbd_conn_t *slurmdbd_conn,
154 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
155 static int _job_suspend(slurmdbd_conn_t *slurmdbd_conn,
156 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
157 static int _modify_accounts(slurmdbd_conn_t *slurmdbd_conn,
158 persist_msg_t *msg, Buf *out_buffer,
159 uint32_t *uid);
160 static int _modify_assocs(slurmdbd_conn_t *slurmdbd_conn,
161 persist_msg_t *msg, Buf *out_buffer,
162 uint32_t *uid);
163 static int _modify_clusters(slurmdbd_conn_t *slurmdbd_conn,
164 persist_msg_t *msg, Buf *out_buffer,
165 uint32_t *uid);
166 static int _modify_federations(slurmdbd_conn_t *slurmdbd_conn,
167 persist_msg_t *msg,
168 Buf *out_buffer, uint32_t *uid);
169 static int _modify_job(slurmdbd_conn_t *slurmdbd_conn,
170 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
171 static int _modify_qos(slurmdbd_conn_t *slurmdbd_conn,
172 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
173 static int _modify_res(slurmdbd_conn_t *slurmdbd_conn,
174 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
175 static int _modify_users(slurmdbd_conn_t *slurmdbd_conn,
176 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
177 static int _modify_wckeys(slurmdbd_conn_t *slurmdbd_conn,
178 persist_msg_t *msg, Buf *out_buffer,
179 uint32_t *uid);
180 static int _modify_reservation(slurmdbd_conn_t *slurmdbd_conn,
181 persist_msg_t *msg, Buf *out_buffer,
182 uint32_t *uid);
183 static int _node_state(slurmdbd_conn_t *slurmdbd_conn,
184 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
185 static void _process_job_start(slurmdbd_conn_t *slurmdbd_conn,
186 dbd_job_start_msg_t *job_start_msg,
187 dbd_id_rc_msg_t *id_rc_msg);
188 static int _reconfig(slurmdbd_conn_t *slurmdbd_conn,
189 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
190 static int _register_ctld(slurmdbd_conn_t *slurmdbd_conn,
191 persist_msg_t *msg, Buf *out_buffer,
192 uint32_t *uid);
193 static int _remove_accounts(slurmdbd_conn_t *slurmdbd_conn,
194 persist_msg_t *msg, Buf *out_buffer,
195 uint32_t *uid);
196 static int _remove_account_coords(slurmdbd_conn_t *slurmdbd_conn,
197 persist_msg_t *msg, Buf *out_buffer,
198 uint32_t *uid);
199 static int _remove_assocs(slurmdbd_conn_t *slurmdbd_conn,
200 persist_msg_t *msg, Buf *out_buffer,
201 uint32_t *uid);
202 static int _remove_clusters(slurmdbd_conn_t *slurmdbd_conn,
203 persist_msg_t *msg, Buf *out_buffer,
204 uint32_t *uid);
205 static int _remove_federations(slurmdbd_conn_t *slurmdbd_conn,
206 persist_msg_t *msg,
207 Buf *out_buffer, uint32_t *uid);
208 static int _remove_qos(slurmdbd_conn_t *slurmdbd_conn,
209 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
210 static int _remove_res(slurmdbd_conn_t *slurmdbd_conn,
211 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
212 static int _remove_users(slurmdbd_conn_t *slurmdbd_conn,
213 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
214 static int _remove_wckeys(slurmdbd_conn_t *slurmdbd_conn,
215 persist_msg_t *msg, Buf *out_buffer,
216 uint32_t *uid);
217 static int _remove_reservation(slurmdbd_conn_t *slurmdbd_conn,
218 persist_msg_t *msg, Buf *out_buffer,
219 uint32_t *uid);
220 static int _roll_usage(slurmdbd_conn_t *slurmdbd_conn,
221 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
222 static int _send_mult_job_start(slurmdbd_conn_t *slurmdbd_conn,
223 persist_msg_t *msg, Buf *out_buffer,
224 uint32_t *uid);
225 static int _send_mult_msg(slurmdbd_conn_t *slurmdbd_conn,
226 persist_msg_t *msg, Buf *out_buffer,
227 uint32_t *uid);
228 static int _shutdown(slurmdbd_conn_t *slurmdbd_conn,
229 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
230 static int _step_complete(slurmdbd_conn_t *slurmdbd_conn,
231 persist_msg_t *msg, Buf *out_buffer,
232 uint32_t *uid);
233 static int _step_start(slurmdbd_conn_t *slurmdbd_conn,
234 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
235
236 #ifndef NDEBUG
237 /*
238 * Used alongside the testsuite to signal that the RPC should be processed
239 * as an untrusted user, rather than the "real" account. (Which in a lot of
240 * testing is likely SlurmUser, and thus allowed to bypass many security
241 * checks.
242 *
243 * Implemented with a thread-local variable to apply only to the current
244 * RPC handling thread. Set by SLURM_DROP_PRIV bit in the slurm_msg_t flags.
245 */
246 __thread bool drop_priv = false;
247 #endif
248
249 /* Process an incoming RPC
250 * slurmdbd_conn IN/OUT - in will that the conn.fd set before
251 * calling and db_conn and conn.version will be filled in with the init.
252 * msg IN - incoming message
253 * msg_size IN - size of msg in bytes
254 * first IN - set if first message received on the socket
255 * buffer OUT - outgoing response, must be freed by caller
256 * uid IN/OUT - user ID who initiated the RPC
257 * RET SLURM_SUCCESS or error code */
258 extern int
proc_req(void * conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)259 proc_req(void *conn, persist_msg_t *msg,
260 Buf *out_buffer, uint32_t *uid)
261 {
262 slurmdbd_conn_t *slurmdbd_conn = conn;
263 int rc = SLURM_SUCCESS;
264 char *comment = NULL;
265 slurmdb_rpc_obj_t *rpc_obj;
266
267 DEF_TIMERS;
268 START_TIMER;
269
270 switch (msg->msg_type) {
271 case REQUEST_PERSIST_INIT:
272 rc = _unpack_persist_init(
273 slurmdbd_conn, msg, out_buffer, uid);
274 break;
275 case DBD_ADD_ACCOUNTS:
276 rc = _add_accounts(slurmdbd_conn,
277 msg, out_buffer, uid);
278 break;
279 case DBD_ADD_ACCOUNT_COORDS:
280 rc = _add_account_coords(slurmdbd_conn,
281 msg, out_buffer, uid);
282 break;
283 case DBD_ADD_TRES:
284 rc = _add_tres(slurmdbd_conn,
285 msg, out_buffer, uid);
286 break;
287 case DBD_ADD_ASSOCS:
288 rc = _add_assocs(slurmdbd_conn,
289 msg, out_buffer, uid);
290 break;
291 case DBD_ADD_CLUSTERS:
292 rc = _add_clusters(slurmdbd_conn,
293 msg, out_buffer, uid);
294 break;
295 case DBD_ADD_FEDERATIONS:
296 rc = _add_federations(slurmdbd_conn, msg,
297 out_buffer, uid);
298 break;
299 case DBD_ADD_QOS:
300 rc = _add_qos(slurmdbd_conn,
301 msg, out_buffer, uid);
302 break;
303 case DBD_ADD_RES:
304 rc = _add_res(slurmdbd_conn,
305 msg, out_buffer, uid);
306 break;
307 case DBD_ADD_USERS:
308 rc = _add_users(slurmdbd_conn,
309 msg, out_buffer, uid);
310 break;
311 case DBD_ADD_WCKEYS:
312 rc = _add_wckeys(slurmdbd_conn,
313 msg, out_buffer, uid);
314 break;
315 case DBD_ADD_RESV:
316 rc = _add_reservation(slurmdbd_conn,
317 msg, out_buffer, uid);
318 break;
319 case DBD_ARCHIVE_DUMP:
320 rc = _archive_dump(slurmdbd_conn,
321 msg, out_buffer, uid);
322 break;
323 case DBD_ARCHIVE_LOAD:
324 rc = _archive_load(slurmdbd_conn,
325 msg, out_buffer, uid);
326 break;
327 case DBD_CLUSTER_TRES:
328 rc = _cluster_tres(slurmdbd_conn,
329 msg, out_buffer, uid);
330 break;
331 case DBD_GET_ACCOUNTS:
332 rc = _get_accounts(slurmdbd_conn,
333 msg, out_buffer, uid);
334 break;
335 case DBD_GET_TRES:
336 rc = _get_tres(slurmdbd_conn,
337 msg, out_buffer, uid);
338 break;
339 case DBD_GET_ASSOCS:
340 rc = _get_assocs(slurmdbd_conn,
341 msg, out_buffer, uid);
342 break;
343 case DBD_GET_ASSOC_USAGE:
344 case DBD_GET_WCKEY_USAGE:
345 case DBD_GET_CLUSTER_USAGE:
346 rc = _get_usage(slurmdbd_conn,
347 msg, out_buffer, uid);
348 break;
349 case DBD_GET_CLUSTERS:
350 rc = _get_clusters(slurmdbd_conn,
351 msg, out_buffer, uid);
352 break;
353 case DBD_GET_FEDERATIONS:
354 rc = _get_federations(slurmdbd_conn, msg,
355 out_buffer, uid);
356 break;
357 case DBD_GET_CONFIG:
358 rc = _get_config(slurmdbd_conn,
359 msg, out_buffer, uid);
360 break;
361 case DBD_GET_EVENTS:
362 rc = _get_events(slurmdbd_conn,
363 msg, out_buffer, uid);
364 break;
365 case DBD_GET_JOBS_COND:
366 rc = _get_jobs_cond(slurmdbd_conn,
367 msg, out_buffer, uid);
368 break;
369 case DBD_GET_PROBS:
370 rc = _get_probs(slurmdbd_conn,
371 msg, out_buffer, uid);
372 break;
373 case DBD_GET_QOS:
374 rc = _get_qos(slurmdbd_conn,
375 msg, out_buffer, uid);
376 break;
377 case DBD_GET_RES:
378 rc = _get_res(slurmdbd_conn,
379 msg, out_buffer, uid);
380 break;
381 case DBD_GET_TXN:
382 rc = _get_txn(slurmdbd_conn,
383 msg, out_buffer, uid);
384 break;
385 case DBD_GET_WCKEYS:
386 rc = _get_wckeys(slurmdbd_conn,
387 msg, out_buffer, uid);
388 break;
389 case DBD_GET_RESVS:
390 rc = _get_reservations(slurmdbd_conn,
391 msg, out_buffer, uid);
392 break;
393 case DBD_GET_USERS:
394 rc = _get_users(slurmdbd_conn,
395 msg, out_buffer, uid);
396 break;
397 case DBD_FLUSH_JOBS:
398 rc = _flush_jobs(slurmdbd_conn,
399 msg, out_buffer, uid);
400 break;
401 case DBD_FINI:
402 rc = _fini_conn(slurmdbd_conn, msg, out_buffer);
403 break;
404 case DBD_JOB_COMPLETE:
405 rc = _job_complete(slurmdbd_conn,
406 msg, out_buffer, uid);
407 break;
408 case DBD_JOB_START:
409 rc = _job_start(slurmdbd_conn,
410 msg, out_buffer, uid);
411 break;
412 case DBD_JOB_SUSPEND:
413 rc = _job_suspend(slurmdbd_conn,
414 msg, out_buffer, uid);
415 break;
416 case DBD_MODIFY_ACCOUNTS:
417 rc = _modify_accounts(slurmdbd_conn,
418 msg, out_buffer, uid);
419 break;
420 case DBD_MODIFY_ASSOCS:
421 rc = _modify_assocs(slurmdbd_conn,
422 msg, out_buffer, uid);
423 break;
424 case DBD_MODIFY_CLUSTERS:
425 rc = _modify_clusters(slurmdbd_conn,
426 msg, out_buffer, uid);
427 break;
428 case DBD_MODIFY_FEDERATIONS:
429 rc = _modify_federations(slurmdbd_conn, msg,
430 out_buffer, uid);
431 break;
432 case DBD_MODIFY_JOB:
433 rc = _modify_job(slurmdbd_conn,
434 msg, out_buffer, uid);
435 break;
436 case DBD_MODIFY_QOS:
437 rc = _modify_qos(slurmdbd_conn,
438 msg, out_buffer, uid);
439 break;
440 case DBD_MODIFY_RES:
441 rc = _modify_res(slurmdbd_conn,
442 msg, out_buffer, uid);
443 break;
444 case DBD_MODIFY_USERS:
445 rc = _modify_users(slurmdbd_conn,
446 msg, out_buffer, uid);
447 break;
448 case DBD_MODIFY_WCKEYS:
449 rc = _modify_wckeys(slurmdbd_conn,
450 msg, out_buffer, uid);
451 break;
452 case DBD_MODIFY_RESV:
453 rc = _modify_reservation(slurmdbd_conn,
454 msg, out_buffer, uid);
455 break;
456 case DBD_NODE_STATE:
457 rc = _node_state(slurmdbd_conn,
458 msg, out_buffer, uid);
459 break;
460 case DBD_RECONFIG:
461 /* handle reconfig */
462 rc = _reconfig(slurmdbd_conn,
463 msg, out_buffer, uid);
464 break;
465 case DBD_REGISTER_CTLD:
466 rc = _register_ctld(slurmdbd_conn, msg,
467 out_buffer, uid);
468 break;
469 case DBD_REMOVE_ACCOUNTS:
470 rc = _remove_accounts(slurmdbd_conn,
471 msg, out_buffer, uid);
472 break;
473 case DBD_REMOVE_ACCOUNT_COORDS:
474 rc = _remove_account_coords(slurmdbd_conn,
475 msg, out_buffer, uid);
476 break;
477 case DBD_REMOVE_ASSOCS:
478 rc = _remove_assocs(slurmdbd_conn,
479 msg, out_buffer, uid);
480 break;
481 case DBD_REMOVE_CLUSTERS:
482 rc = _remove_clusters(slurmdbd_conn,
483 msg, out_buffer, uid);
484 break;
485 case DBD_REMOVE_FEDERATIONS:
486 rc = _remove_federations(slurmdbd_conn, msg,
487 out_buffer, uid);
488 break;
489 case DBD_REMOVE_QOS:
490 rc = _remove_qos(slurmdbd_conn,
491 msg, out_buffer, uid);
492 break;
493 case DBD_REMOVE_RES:
494 rc = _remove_res(slurmdbd_conn,
495 msg, out_buffer, uid);
496 break;
497 case DBD_REMOVE_USERS:
498 rc = _remove_users(slurmdbd_conn,
499 msg, out_buffer, uid);
500 break;
501 case DBD_REMOVE_WCKEYS:
502 rc = _remove_wckeys(slurmdbd_conn,
503 msg, out_buffer, uid);
504 break;
505 case DBD_REMOVE_RESV:
506 rc = _remove_reservation(slurmdbd_conn,
507 msg, out_buffer, uid);
508 break;
509 case DBD_ROLL_USAGE:
510 rc = _roll_usage(slurmdbd_conn,
511 msg, out_buffer, uid);
512 break;
513 case DBD_SEND_MULT_JOB_START:
514 rc = _send_mult_job_start(slurmdbd_conn,
515 msg, out_buffer, uid);
516 break;
517 case DBD_SEND_MULT_MSG:
518 rc = _send_mult_msg(slurmdbd_conn,
519 msg, out_buffer, uid);
520 break;
521 case DBD_STEP_COMPLETE:
522 rc = _step_complete(slurmdbd_conn,
523 msg, out_buffer, uid);
524 break;
525 case DBD_STEP_START:
526 rc = _step_start(slurmdbd_conn,
527 msg, out_buffer, uid);
528 break;
529 case DBD_FIX_RUNAWAY_JOB:
530 rc = _fix_runaway_jobs(slurmdbd_conn,
531 msg, out_buffer, uid);
532 break;
533 case DBD_GET_STATS:
534 rc = _get_stats(slurmdbd_conn, msg, out_buffer,
535 uid);
536 break;
537 case DBD_CLEAR_STATS:
538 rc = _clear_stats(slurmdbd_conn, msg, out_buffer,
539 uid);
540 break;
541 case DBD_SHUTDOWN:
542 rc = _shutdown(slurmdbd_conn, msg, out_buffer,
543 uid);
544 break;
545 default:
546 comment = "Invalid RPC";
547 error("CONN:%u %s msg_type=%d",
548 slurmdbd_conn->conn->fd, comment, msg->msg_type);
549 rc = EINVAL;
550 *out_buffer = slurm_persist_make_rc_msg(
551 slurmdbd_conn->conn, rc, comment, 0);
552 break;
553 }
554
555 if (rc == ESLURM_ACCESS_DENIED)
556 error("CONN:%u Security violation, %s",
557 slurmdbd_conn->conn->fd,
558 slurmdbd_msg_type_2_str(msg->msg_type, 1));
559 else if (slurmdbd_conn->conn->rem_port
560 && !slurmdbd_conf->commit_delay) {
561 /* If we are dealing with the slurmctld do the
562 commit (SUCCESS or NOT) afterwards since we
563 do transactions for performance reasons.
564 (don't ever use autocommit with innodb)
565 */
566 acct_storage_g_commit(slurmdbd_conn->db_conn, 1);
567 }
568
569 END_TIMER;
570
571 slurm_mutex_lock(&rpc_mutex);
572
573 if (!(rpc_obj = list_find_first(rpc_stats.rpc_list,
574 _find_rpc_obj_in_list,
575 &msg->msg_type))) {
576 rpc_obj = xmalloc(sizeof(slurmdb_rpc_obj_t));
577 rpc_obj->id = msg->msg_type;
578 list_append(rpc_stats.rpc_list, rpc_obj);
579 }
580 rpc_obj->cnt++;
581 rpc_obj->time += DELTA_TIMER;
582
583 if (!(rpc_obj = list_find_first(rpc_stats.user_list,
584 _find_rpc_obj_in_list,
585 uid))) {
586 rpc_obj = xmalloc(sizeof(slurmdb_rpc_obj_t));
587 rpc_obj->id = *uid;
588 list_append(rpc_stats.user_list, rpc_obj);
589 }
590 rpc_obj->cnt++;
591 rpc_obj->time += DELTA_TIMER;
592
593 slurm_mutex_unlock(&rpc_mutex);
594
595 return rc;
596 }
597
598 /*
599 * _validate_slurm_user - validate that the uid is authorized to see
600 * privileged data (either user root or SlurmUser)
601 */
_validate_slurm_user(uint32_t uid)602 static bool _validate_slurm_user(uint32_t uid)
603 {
604 #ifndef NDEBUG
605 if (drop_priv)
606 return false;
607 #endif
608 if ((uid == 0) || (uid == slurmdbd_conf->slurm_user_id))
609 return true;
610
611 return false;
612 }
613
614 /*
615 * _validate_super_user - validate that the uid is authorized at the
616 * root, SlurmUser, or SLURMDB_ADMIN_SUPER_USER level
617 */
_validate_super_user(uint32_t uid,slurmdbd_conn_t * dbd_conn)618 static bool _validate_super_user(uint32_t uid, slurmdbd_conn_t *dbd_conn)
619 {
620 #ifndef NDEBUG
621 if (drop_priv)
622 return false;
623 #endif
624 if ((uid == 0) || (uid == slurmdbd_conf->slurm_user_id) ||
625 assoc_mgr_get_admin_level(dbd_conn, uid) >= SLURMDB_ADMIN_SUPER_USER)
626 return true;
627
628 return false;
629 }
630
631 /*
632 * _validate_operator - validate that the uid is authorized at the
633 * root, SlurmUser, or SLURMDB_ADMIN_OPERATOR level
634 */
_validate_operator(uint32_t uid,slurmdbd_conn_t * dbd_conn)635 static bool _validate_operator(uint32_t uid, slurmdbd_conn_t *dbd_conn)
636 {
637 #ifndef NDEBUG
638 if (drop_priv)
639 return false;
640 #endif
641 if ((uid == 0) || (uid == slurmdbd_conf->slurm_user_id) ||
642 assoc_mgr_get_admin_level(dbd_conn, uid) >= SLURMDB_ADMIN_OPERATOR)
643 return true;
644
645 return false;
646 }
647
_add_registered_cluster(slurmdbd_conn_t * db_conn)648 static void _add_registered_cluster(slurmdbd_conn_t *db_conn)
649 {
650 ListIterator itr;
651 slurmdbd_conn_t *slurmdbd_conn;
652
653 if (!db_conn->conn->rem_port) {
654 error("%s: trying to register a cluster (%s) with no remote port",
655 __func__, db_conn->conn->cluster_name);
656 return;
657 }
658
659 slurm_mutex_lock(®istered_lock);
660 itr = list_iterator_create(registered_clusters);
661 while ((slurmdbd_conn = list_next(itr))) {
662 if (db_conn == slurmdbd_conn)
663 break;
664
665 if (!xstrcmp(db_conn->conn->cluster_name,
666 slurmdbd_conn->conn->cluster_name) &&
667 (db_conn->conn->fd != slurmdbd_conn->conn->fd)) {
668 error("A new registration for cluster %s CONN:%d just came in, but I am already talking to that cluster (CONN:%d), closing other connection.",
669 db_conn->conn->cluster_name, db_conn->conn->fd,
670 slurmdbd_conn->conn->fd);
671 slurmdbd_conn->conn->rem_port = 0;
672 list_delete_item(itr);
673 }
674 }
675 list_iterator_destroy(itr);
676 if (!slurmdbd_conn)
677 list_append(registered_clusters, db_conn);
678 slurm_mutex_unlock(®istered_lock);
679 }
680
681
682 /* replace \" with \` return is the same as what is given */
_replace_double_quotes(char * option)683 static char * _replace_double_quotes(char *option)
684 {
685 int i=0;
686
687 if (!option)
688 return NULL;
689
690 while (option[i]) {
691 if (option[i] == '\"')
692 option[i] = '`';
693 i++;
694 }
695 return option;
696 }
697
_handle_init_msg(slurmdbd_conn_t * slurmdbd_conn,persist_init_req_msg_t * init_msg,uint32_t * uid)698 static int _handle_init_msg(slurmdbd_conn_t *slurmdbd_conn,
699 persist_init_req_msg_t *init_msg,
700 uint32_t *uid)
701 {
702 int rc = SLURM_SUCCESS;
703
704 *uid = init_msg->uid;
705
706 #if HAVE_SYS_PRCTL_H
707 {
708 char *name = xstrdup_printf("p-%s", init_msg->cluster_name);
709 if (prctl(PR_SET_NAME, name, NULL, NULL, NULL) < 0)
710 error("%s: cannot set my name to %s %m", __func__, name);
711 xfree(name);
712 }
713 #endif
714
715 debug("REQUEST_PERSIST_INIT: CLUSTER:%s VERSION:%u UID:%u IP:%s CONN:%u",
716 init_msg->cluster_name, init_msg->version, init_msg->uid,
717 slurmdbd_conn->conn->rem_host, slurmdbd_conn->conn->fd);
718
719 slurmdbd_conn->conn->cluster_name = xstrdup(init_msg->cluster_name);
720
721 /* When dealing with rollbacks it turns out it is much faster
722 to do the commit once or once in a while instead of
723 autocommit. The SlurmDBD will periodically do a commit to
724 avoid such a slow down.
725 */
726 slurmdbd_conn->db_conn = acct_storage_g_get_connection(
727 NULL, slurmdbd_conn->conn->fd, NULL, true,
728 slurmdbd_conn->conn->cluster_name);
729 slurmdbd_conn->conn->version = init_msg->version;
730 if (errno)
731 rc = errno;
732
733 return rc;
734 }
735
_unpack_persist_init(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)736 static int _unpack_persist_init(slurmdbd_conn_t *slurmdbd_conn,
737 persist_msg_t *msg, Buf *out_buffer,
738 uint32_t *uid)
739 {
740 int rc;
741 slurm_msg_t *smsg = msg->data;
742 persist_init_req_msg_t *req_msg = smsg->data;
743 char *comment = NULL;
744
745 #ifndef NDEBUG
746 if ((smsg->flags & SLURM_DROP_PRIV))
747 drop_priv = true;
748 #endif
749
750 req_msg->uid = g_slurm_auth_get_uid(slurmdbd_conn->conn->auth_cred);
751
752 /* If the client happens to be a newer version than we are make it so
753 * they talk language I understand.
754 */
755 if (req_msg->version > SLURM_PROTOCOL_VERSION)
756 req_msg->version = SLURM_PROTOCOL_VERSION;
757
758 rc = _handle_init_msg(slurmdbd_conn, req_msg, uid);
759
760 if (rc != SLURM_SUCCESS)
761 comment = slurm_strerror(rc);
762
763 *out_buffer = slurm_persist_make_rc_msg_flags(
764 slurmdbd_conn->conn, rc, comment,
765 slurmdbd_conf->persist_conn_rc_flags,
766 req_msg->version);
767
768 return rc;
769 }
770
_add_accounts(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)771 static int _add_accounts(slurmdbd_conn_t *slurmdbd_conn,
772 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
773 {
774 int rc = SLURM_SUCCESS;
775 dbd_list_msg_t *get_msg = msg->data;
776 char *comment = NULL;
777
778 debug2("DBD_ADD_ACCOUNTS: called");
779
780 rc = acct_storage_g_add_accounts(slurmdbd_conn->db_conn, *uid,
781 get_msg->my_list);
782 if (rc == ESLURM_ACCESS_DENIED)
783 comment = "Your user doesn't have privilege to perform this action";
784 *out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
785 rc, comment, DBD_ADD_ACCOUNTS);
786 return rc;
787 }
788
_fix_runaway_jobs(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)789 static int _fix_runaway_jobs(slurmdbd_conn_t *slurmdbd_conn, persist_msg_t *msg,
790 Buf *out_buffer, uint32_t *uid)
791 {
792 int rc = SLURM_SUCCESS;
793 dbd_list_msg_t *get_msg = msg->data;
794 char *comment = NULL;
795
796 if (!_validate_operator(*uid, slurmdbd_conn))
797 rc = ESLURM_ACCESS_DENIED;
798 else
799 rc = acct_storage_g_fix_runaway_jobs(
800 slurmdbd_conn->db_conn, *uid, get_msg->my_list);
801
802 if (rc == ESLURM_ACCESS_DENIED) {
803 comment = "You must have an AdminLevel>=Operator to fix runaway jobs";
804 error("CONN:%u %s", slurmdbd_conn->conn->fd, comment);
805 }
806
807 *out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
808 rc, comment,
809 DBD_FIX_RUNAWAY_JOB);
810
811 return rc;
812 }
813
_add_account_coords(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)814 static int _add_account_coords(slurmdbd_conn_t *slurmdbd_conn,
815 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
816 {
817 int rc = SLURM_SUCCESS;
818 dbd_acct_coord_msg_t *get_msg = msg->data;
819 char *comment = NULL;
820
821 debug2("DBD_ADD_ACCOUNT_COORDS: called");
822
823 rc = acct_storage_g_add_coord(slurmdbd_conn->db_conn, *uid,
824 get_msg->acct_list, get_msg->cond);
825
826 if (rc == ESLURM_ACCESS_DENIED) {
827 comment = "Your user doesn't have privilege to perform this action";
828 error("CONN:%u %s", slurmdbd_conn->conn->fd, comment);
829 }
830
831 *out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
832 rc, comment,
833 DBD_ADD_ACCOUNT_COORDS);
834 return rc;
835 }
836
_add_tres(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)837 static int _add_tres(slurmdbd_conn_t *slurmdbd_conn,
838 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
839 {
840 int rc = SLURM_SUCCESS;
841 dbd_list_msg_t *get_msg = msg->data;
842 char *comment = NULL;
843
844 debug2("DBD_ADD_TRES: called");
845
846 rc = acct_storage_g_add_tres(slurmdbd_conn->db_conn, *uid,
847 get_msg->my_list);
848
849 *out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
850 rc, comment, DBD_ADD_TRES);
851
852 /* This happens before the slurmctld registers and only when
853 the slurmctld starts up. So always commit, success or not.
854 (don't ever use autocommit with innodb)
855 */
856 acct_storage_g_commit(slurmdbd_conn->db_conn, 1);
857
858 return rc;
859 }
860
_add_assocs(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)861 static int _add_assocs(slurmdbd_conn_t *slurmdbd_conn,
862 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
863 {
864 int rc = SLURM_SUCCESS;
865 dbd_list_msg_t *get_msg = msg->data;
866 char *comment = NULL;
867
868 debug2("DBD_ADD_ASSOCS: called");
869
870 if (!_validate_operator(*uid, slurmdbd_conn)) {
871 ListIterator itr = NULL;
872 ListIterator itr2 = NULL;
873 slurmdb_user_rec_t user;
874 slurmdb_coord_rec_t *coord = NULL;
875 slurmdb_assoc_rec_t *object = NULL;
876
877 memset(&user, 0, sizeof(slurmdb_user_rec_t));
878 user.uid = *uid;
879 if (assoc_mgr_fill_in_user(
880 slurmdbd_conn->db_conn, &user, 1, NULL, false)
881 != SLURM_SUCCESS) {
882 comment = "Your user has not been added to the accounting system yet.";
883 error("CONN:%u %s", slurmdbd_conn->conn->fd, comment);
884 rc = SLURM_ERROR;
885 goto end_it;
886 }
887 if (!user.coord_accts || !list_count(user.coord_accts)) {
888 comment = "Your user doesn't have privilege to perform this action";
889 error("CONN:%u %s", slurmdbd_conn->conn->fd, comment);
890 rc = ESLURM_ACCESS_DENIED;
891 goto end_it;
892 }
893 itr = list_iterator_create(get_msg->my_list);
894 itr2 = list_iterator_create(user.coord_accts);
895 while ((object = list_next(itr))) {
896 char *account = "root";
897 if (object->user)
898 account = object->acct;
899 else if (object->parent_acct)
900 account = object->parent_acct;
901 list_iterator_reset(itr2);
902 while ((coord = list_next(itr2))) {
903 if (!xstrcasecmp(coord->name, account))
904 break;
905 }
906 if (!coord)
907 break;
908 }
909 list_iterator_destroy(itr2);
910 list_iterator_destroy(itr);
911 if (!coord) {
912 comment = "Your user doesn't have privilege to perform this action";
913 error("CONN:%u %s", slurmdbd_conn->conn->fd, comment);
914 rc = ESLURM_ACCESS_DENIED;
915 goto end_it;
916 }
917 }
918
919 rc = acct_storage_g_add_assocs(slurmdbd_conn->db_conn, *uid,
920 get_msg->my_list);
921 end_it:
922 *out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
923 rc, comment, DBD_ADD_ASSOCS);
924 return rc;
925 }
926
_add_clusters(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)927 static int _add_clusters(slurmdbd_conn_t *slurmdbd_conn,
928 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
929 {
930 int rc = SLURM_SUCCESS;
931 dbd_list_msg_t *get_msg = msg->data;
932 char *comment = NULL;
933
934 debug2("DBD_ADD_CLUSTERS: called");
935
936 rc = acct_storage_g_add_clusters(slurmdbd_conn->db_conn, *uid,
937 get_msg->my_list);
938 if (rc == ESLURM_ACCESS_DENIED)
939 comment = "Your user doesn't have privilege to perform this action";
940 else if (rc != SLURM_SUCCESS)
941 comment = "Failed to add cluster.";
942
943 *out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
944 rc, comment, DBD_ADD_CLUSTERS);
945 return rc;
946 }
947
_add_federations(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)948 static int _add_federations(slurmdbd_conn_t *slurmdbd_conn, persist_msg_t *msg,
949 Buf *out_buffer, uint32_t *uid)
950 {
951 int rc = SLURM_SUCCESS;
952 dbd_list_msg_t *get_msg = msg->data;
953 char *comment = NULL;
954
955 debug2("DBD_ADD_FEDERATIONS: called");
956
957 rc = acct_storage_g_add_federations(slurmdbd_conn->db_conn, *uid,
958 get_msg->my_list);
959 if (rc == ESLURM_ACCESS_DENIED)
960 comment = "Your user doesn't have privilege to perform this "
961 "action";
962 else if (rc != SLURM_SUCCESS)
963 comment = "Failed to add cluster.";
964
965 *out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
966 rc, comment,
967 DBD_ADD_FEDERATIONS);
968 return rc;
969 }
970
_add_qos(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)971 static int _add_qos(slurmdbd_conn_t *slurmdbd_conn,
972 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
973 {
974 int rc = SLURM_SUCCESS;
975 dbd_list_msg_t *get_msg = msg->data;
976 char *comment = NULL;
977
978 debug2("DBD_ADD_QOS: called");
979
980 rc = acct_storage_g_add_qos(slurmdbd_conn->db_conn, *uid,
981 get_msg->my_list);
982 if (rc == ESLURM_ACCESS_DENIED)
983 comment = "Your user doesn't have privilege to perform this action";
984 else if (rc != SLURM_SUCCESS)
985 comment = "Failed to add qos.";
986
987 *out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
988 rc, comment, DBD_ADD_QOS);
989 return rc;
990 }
991
_add_res(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)992 static int _add_res(slurmdbd_conn_t *slurmdbd_conn,
993 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
994 {
995 int rc = SLURM_SUCCESS;
996 dbd_list_msg_t *get_msg = msg->data;
997 char *comment = NULL;
998
999 debug2("DBD_ADD_RES: called");
1000
1001 rc = acct_storage_g_add_res(slurmdbd_conn->db_conn, *uid,
1002 get_msg->my_list);
1003 if (rc == ESLURM_ACCESS_DENIED)
1004 comment = "Your user doesn't have privilege to perform this action";
1005 else if (rc != SLURM_SUCCESS)
1006 comment = "Failed to add system resource.";
1007
1008 *out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
1009 rc, comment, DBD_ADD_RES);
1010 return rc;
1011 }
1012
_add_users(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)1013 static int _add_users(slurmdbd_conn_t *slurmdbd_conn,
1014 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
1015 {
1016 int rc = SLURM_SUCCESS;
1017 dbd_list_msg_t *get_msg = msg->data;
1018 char *comment = NULL;
1019 debug2("DBD_ADD_USERS: called");
1020
1021 rc = acct_storage_g_add_users(slurmdbd_conn->db_conn, *uid,
1022 get_msg->my_list);
1023
1024 if (rc == ESLURM_ACCESS_DENIED)
1025 comment = "Your user doesn't have privilege to perform this action";
1026
1027 *out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
1028 rc, comment, DBD_ADD_USERS);
1029 return rc;
1030 }
1031
_add_wckeys(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)1032 static int _add_wckeys(slurmdbd_conn_t *slurmdbd_conn,
1033 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
1034 {
1035 int rc = SLURM_SUCCESS;
1036 dbd_list_msg_t *get_msg = msg->data;
1037 char *comment = NULL;
1038
1039 debug2("DBD_ADD_WCKEYS: called");
1040
1041 rc = acct_storage_g_add_wckeys(slurmdbd_conn->db_conn, *uid,
1042 get_msg->my_list);
1043
1044 *out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
1045 rc, comment, DBD_ADD_WCKEYS);
1046 return rc;
1047 }
1048
_add_reservation(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)1049 static int _add_reservation(slurmdbd_conn_t *slurmdbd_conn,
1050 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
1051 {
1052 int rc = SLURM_SUCCESS;
1053 dbd_rec_msg_t *rec_msg = msg->data;
1054 char *comment = NULL;
1055
1056 if (!_validate_slurm_user(*uid)) {
1057 comment = "DBD_ADD_RESV message from invalid uid";
1058 error("DBD_ADD_RESV message from invalid uid %u", *uid);
1059 rc = ESLURM_ACCESS_DENIED;
1060 goto end_it;
1061 }
1062
1063 debug2("DBD_ADD_RESV: called");
1064
1065 rc = acct_storage_g_add_reservation(slurmdbd_conn->db_conn,
1066 rec_msg->rec);
1067
1068 end_it:
1069 *out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
1070 rc, comment, DBD_ADD_RESV);
1071 return rc;
1072 }
1073
_archive_dump(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)1074 static int _archive_dump(slurmdbd_conn_t *slurmdbd_conn,
1075 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
1076 {
1077 int rc = SLURM_SUCCESS;
1078 dbd_cond_msg_t *get_msg = msg->data;
1079 char *comment = "SUCCESS";
1080 slurmdb_archive_cond_t *arch_cond = NULL;
1081
1082 debug2("DBD_ARCHIVE_DUMP: called");
1083 if (!_validate_super_user(*uid, slurmdbd_conn)) {
1084 comment = "Your user doesn't have privilege to perform this action";
1085 error("CONN:%u %s", slurmdbd_conn->conn->fd, comment);
1086 rc = ESLURM_ACCESS_DENIED;
1087 goto end_it;
1088 }
1089
1090 arch_cond = (slurmdb_archive_cond_t *)get_msg->cond;
1091 /* set up some defaults */
1092 if (!arch_cond->archive_dir)
1093 arch_cond->archive_dir = xstrdup(slurmdbd_conf->archive_dir);
1094 if (!arch_cond->archive_script)
1095 arch_cond->archive_script =
1096 xstrdup(slurmdbd_conf->archive_script);
1097
1098 if (arch_cond->purge_event == NO_VAL)
1099 arch_cond->purge_event = slurmdbd_conf->purge_event;
1100 if (arch_cond->purge_job == NO_VAL)
1101 arch_cond->purge_job = slurmdbd_conf->purge_job;
1102 if (arch_cond->purge_resv == NO_VAL)
1103 arch_cond->purge_resv = slurmdbd_conf->purge_resv;
1104 if (arch_cond->purge_step == NO_VAL)
1105 arch_cond->purge_step = slurmdbd_conf->purge_step;
1106 if (arch_cond->purge_suspend == NO_VAL)
1107 arch_cond->purge_suspend = slurmdbd_conf->purge_suspend;
1108 if (arch_cond->purge_txn == NO_VAL)
1109 arch_cond->purge_txn = slurmdbd_conf->purge_txn;
1110 if (arch_cond->purge_usage == NO_VAL)
1111 arch_cond->purge_usage = slurmdbd_conf->purge_usage;
1112
1113 rc = jobacct_storage_g_archive(slurmdbd_conn->db_conn, arch_cond);
1114 if (rc != SLURM_SUCCESS) {
1115 if (errno == EACCES)
1116 comment = "Problem accessing file.";
1117 else
1118 comment = "Error with request.";
1119 }
1120 end_it:
1121 *out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
1122 rc, comment, DBD_ARCHIVE_DUMP);
1123 return rc;
1124 }
1125
_archive_load(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)1126 static int _archive_load(slurmdbd_conn_t *slurmdbd_conn,
1127 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
1128 {
1129 int rc = SLURM_SUCCESS;
1130 slurmdb_archive_rec_t *arch_rec = msg->data;
1131 char *comment = "SUCCESS";
1132
1133 debug2("DBD_ARCHIVE_LOAD: called");
1134 if (!_validate_super_user(*uid, slurmdbd_conn)) {
1135 comment = "Your user doesn't have privilege to perform this action";
1136 error("CONN:%u %s", slurmdbd_conn->conn->fd, comment);
1137 rc = ESLURM_ACCESS_DENIED;
1138 goto end_it;
1139 }
1140
1141 rc = jobacct_storage_g_archive_load(slurmdbd_conn->db_conn, arch_rec);
1142
1143 if (rc == ENOENT)
1144 comment = "No archive file given to recover.";
1145 else if (rc != SLURM_SUCCESS)
1146 comment = "Error with request.";
1147
1148 end_it:
1149 *out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
1150 rc, comment, DBD_ARCHIVE_LOAD);
1151 return rc;
1152 }
1153
_cluster_tres(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)1154 static int _cluster_tres(slurmdbd_conn_t *slurmdbd_conn,
1155 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
1156 {
1157 dbd_cluster_tres_msg_t *cluster_tres_msg = msg->data;
1158 int rc = SLURM_SUCCESS;
1159 char *comment = NULL;
1160
1161 if (!_validate_slurm_user(*uid)) {
1162 comment = "DBD_CLUSTER_TRES message from invalid uid";
1163 error("DBD_CLUSTER_TRES message from invalid uid %u", *uid);
1164 rc = ESLURM_ACCESS_DENIED;
1165 goto end_it;
1166 }
1167
1168 debug2("DBD_CLUSTER_TRES: called for %s(%s)",
1169 slurmdbd_conn->conn->cluster_name,
1170 cluster_tres_msg->tres_str);
1171
1172 rc = clusteracct_storage_g_cluster_tres(
1173 slurmdbd_conn->db_conn,
1174 cluster_tres_msg->cluster_nodes,
1175 cluster_tres_msg->tres_str,
1176 cluster_tres_msg->event_time,
1177 slurmdbd_conn->conn->version);
1178 if (rc == ESLURM_ACCESS_DENIED) {
1179 comment = "This cluster hasn't been added to accounting yet";
1180 rc = SLURM_ERROR;
1181 }
1182 end_it:
1183 if (rc == SLURM_SUCCESS) {
1184 xfree(slurmdbd_conn->tres_str);
1185 slurmdbd_conn->tres_str = cluster_tres_msg->tres_str;
1186 cluster_tres_msg->tres_str = NULL;
1187 }
1188 if (!slurmdbd_conn->conn->rem_port) {
1189 debug3("DBD_CLUSTER_TRES: cluster not registered");
1190 slurmdbd_conn->conn->rem_port =
1191 clusteracct_storage_g_register_disconn_ctld(
1192 slurmdbd_conn->db_conn,
1193 slurmdbd_conn->conn->rem_host);
1194
1195 _add_registered_cluster(slurmdbd_conn);
1196 }
1197
1198 *out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
1199 rc, comment, DBD_CLUSTER_TRES);
1200 return rc;
1201 }
1202
_get_accounts(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)1203 static int _get_accounts(slurmdbd_conn_t *slurmdbd_conn,
1204 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
1205 {
1206 dbd_cond_msg_t *get_msg = msg->data;
1207 dbd_list_msg_t list_msg = { NULL };
1208 int rc = SLURM_SUCCESS;
1209
1210 debug2("DBD_GET_ACCOUNTS: called");
1211
1212 list_msg.my_list = acct_storage_g_get_accounts(slurmdbd_conn->db_conn,
1213 *uid, get_msg->cond);
1214
1215 if (!errno) {
1216 if (!list_msg.my_list)
1217 list_msg.my_list = list_create(NULL);
1218 *out_buffer = init_buf(1024);
1219 pack16((uint16_t) DBD_GOT_ACCOUNTS, *out_buffer);
1220 slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->conn->version,
1221 DBD_GOT_ACCOUNTS,
1222 *out_buffer);
1223 } else {
1224 *out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
1225 errno,
1226 slurm_strerror(errno),
1227 DBD_GET_ACCOUNTS);
1228 rc = SLURM_ERROR;
1229 }
1230
1231 FREE_NULL_LIST(list_msg.my_list);
1232
1233 return rc;
1234 }
1235
_get_tres(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)1236 static int _get_tres(slurmdbd_conn_t *slurmdbd_conn,
1237 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
1238 {
1239 dbd_cond_msg_t *get_msg = msg->data;
1240 dbd_list_msg_t list_msg = { NULL };
1241 int rc = SLURM_SUCCESS;
1242
1243 debug2("DBD_GET_TRES: called");
1244
1245 list_msg.my_list = acct_storage_g_get_tres(
1246 slurmdbd_conn->db_conn, *uid, get_msg->cond);
1247
1248 if (!errno) {
1249 if (!list_msg.my_list)
1250 list_msg.my_list = list_create(NULL);
1251 *out_buffer = init_buf(1024);
1252 pack16((uint16_t) DBD_GOT_TRES, *out_buffer);
1253 slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->conn->version,
1254 DBD_GOT_TRES, *out_buffer);
1255 } else {
1256 *out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
1257 errno,
1258 slurm_strerror(errno),
1259 DBD_GET_TRES);
1260 rc = SLURM_ERROR;
1261 }
1262
1263 FREE_NULL_LIST(list_msg.my_list);
1264
1265 return rc;
1266 }
1267
_get_assocs(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)1268 static int _get_assocs(slurmdbd_conn_t *slurmdbd_conn,
1269 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
1270 {
1271 dbd_cond_msg_t *get_msg = msg->data;
1272 dbd_list_msg_t list_msg = { NULL };
1273 int rc = SLURM_SUCCESS;
1274
1275 debug2("DBD_GET_ASSOCS: called");
1276
1277 list_msg.my_list = acct_storage_g_get_assocs(
1278 slurmdbd_conn->db_conn, *uid, get_msg->cond);
1279
1280 if (!errno) {
1281 if (!list_msg.my_list)
1282 list_msg.my_list = list_create(NULL);
1283 *out_buffer = init_buf(1024);
1284 pack16((uint16_t) DBD_GOT_ASSOCS, *out_buffer);
1285 slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->conn->version,
1286 DBD_GOT_ASSOCS, *out_buffer);
1287 } else {
1288 *out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
1289 errno,
1290 slurm_strerror(errno),
1291 DBD_GET_ASSOCS);
1292 rc = SLURM_ERROR;
1293 }
1294
1295 FREE_NULL_LIST(list_msg.my_list);
1296
1297 return rc;
1298 }
1299
_get_clusters(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)1300 static int _get_clusters(slurmdbd_conn_t *slurmdbd_conn,
1301 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
1302 {
1303 dbd_cond_msg_t *get_msg = msg->data;
1304 dbd_list_msg_t list_msg = { NULL };
1305 int rc = SLURM_SUCCESS;
1306
1307 debug2("DBD_GET_CLUSTERS: called");
1308
1309 list_msg.my_list = acct_storage_g_get_clusters(
1310 slurmdbd_conn->db_conn, *uid, get_msg->cond);
1311
1312 if (!errno) {
1313 if (!list_msg.my_list)
1314 list_msg.my_list = list_create(NULL);
1315 *out_buffer = init_buf(1024);
1316 pack16((uint16_t) DBD_GOT_CLUSTERS, *out_buffer);
1317 slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->conn->version,
1318 DBD_GOT_CLUSTERS,
1319 *out_buffer);
1320 } else {
1321 *out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
1322 errno,
1323 slurm_strerror(errno),
1324 DBD_GET_CLUSTERS);
1325 rc = SLURM_ERROR;
1326 }
1327
1328 FREE_NULL_LIST(list_msg.my_list);
1329
1330 return rc;
1331 }
1332
_get_federations(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)1333 static int _get_federations(slurmdbd_conn_t *slurmdbd_conn, persist_msg_t *msg,
1334 Buf *out_buffer, uint32_t *uid)
1335 {
1336 dbd_cond_msg_t *get_msg = msg->data;
1337 dbd_list_msg_t list_msg = { NULL };
1338 int rc = SLURM_SUCCESS;
1339
1340 debug2("DBD_GET_FEDERATIONS: called");
1341
1342 list_msg.my_list = acct_storage_g_get_federations(
1343 slurmdbd_conn->db_conn, *uid, get_msg->cond);
1344
1345 if (!errno) {
1346 if (!list_msg.my_list)
1347 list_msg.my_list = list_create(NULL);
1348 *out_buffer = init_buf(1024);
1349 pack16((uint16_t) DBD_GOT_FEDERATIONS, *out_buffer);
1350 slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->conn->version,
1351 DBD_GOT_FEDERATIONS,
1352 *out_buffer);
1353 } else {
1354 *out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
1355 errno,
1356 slurm_strerror(errno),
1357 DBD_GET_FEDERATIONS);
1358 rc = SLURM_ERROR;
1359 }
1360
1361 FREE_NULL_LIST(list_msg.my_list);
1362
1363 return rc;
1364 }
1365
_get_config(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)1366 static int _get_config(slurmdbd_conn_t *slurmdbd_conn,
1367 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
1368 {
1369 char *config_name = msg->data;
1370 dbd_list_msg_t list_msg = { NULL };
1371
1372 debug2("DBD_GET_CONFIG: called");
1373
1374 if (config_name == NULL ||
1375 xstrcmp(config_name, "slurmdbd.conf") == 0)
1376 list_msg.my_list = dump_config();
1377 else if ((list_msg.my_list = acct_storage_g_get_config(
1378 slurmdbd_conn->db_conn, config_name)) == NULL) {
1379 *out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
1380 errno,
1381 slurm_strerror(errno),
1382 DBD_GET_CONFIG);
1383 xfree(config_name);
1384 return SLURM_ERROR;
1385 }
1386
1387 *out_buffer = init_buf(1024);
1388 pack16((uint16_t) DBD_GOT_CONFIG, *out_buffer);
1389 slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->conn->version,
1390 DBD_GOT_CONFIG, *out_buffer);
1391 FREE_NULL_LIST(list_msg.my_list);
1392 xfree(config_name);
1393
1394 return SLURM_SUCCESS;
1395 }
1396
_get_events(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)1397 static int _get_events(slurmdbd_conn_t *slurmdbd_conn,
1398 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
1399 {
1400 dbd_cond_msg_t *get_msg = msg->data;
1401 dbd_list_msg_t list_msg = { NULL };
1402 int rc = SLURM_SUCCESS;
1403
1404 debug2("DBD_GET_EVENTS: called");
1405
1406 list_msg.my_list = acct_storage_g_get_events(
1407 slurmdbd_conn->db_conn, *uid, get_msg->cond);
1408
1409 if (!errno) {
1410 if (!list_msg.my_list)
1411 list_msg.my_list = list_create(NULL);
1412 *out_buffer = init_buf(1024);
1413 pack16((uint16_t) DBD_GOT_EVENTS, *out_buffer);
1414 slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->conn->version,
1415 DBD_GOT_EVENTS,
1416 *out_buffer);
1417 } else {
1418 *out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
1419 errno,
1420 slurm_strerror(errno),
1421 DBD_GET_EVENTS);
1422 rc = SLURM_ERROR;
1423 }
1424
1425 FREE_NULL_LIST(list_msg.my_list);
1426
1427 return rc;
1428 }
1429
_get_jobs_cond(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)1430 static int _get_jobs_cond(slurmdbd_conn_t *slurmdbd_conn,
1431 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
1432 {
1433 dbd_cond_msg_t *cond_msg = msg->data;
1434 dbd_list_msg_t list_msg = { NULL };
1435 slurmdb_job_cond_t *job_cond = cond_msg->cond;
1436 int rc = SLURM_SUCCESS;
1437
1438 debug2("DBD_GET_JOBS_COND: called");
1439
1440 /* fail early if requesting runaways and not super user */
1441 if ((job_cond->flags & JOBCOND_FLAG_RUNAWAY) &&
1442 !_validate_operator(*uid, slurmdbd_conn)) {
1443 debug("Rejecting query of runaways from uid %u", *uid);
1444 *out_buffer = slurm_persist_make_rc_msg(
1445 slurmdbd_conn->conn,
1446 ESLURM_ACCESS_DENIED,
1447 "You must have an AdminLevel>=Operator to fix runaway jobs",
1448 DBD_GET_JOBS_COND);
1449 return SLURM_ERROR;
1450 }
1451 /* fail early if too wide a query */
1452 if (!job_cond->step_list && !_validate_operator(*uid, slurmdbd_conn)
1453 && (slurmdbd_conf->max_time_range != INFINITE)) {
1454 time_t start, end;
1455
1456 start = job_cond->usage_start;
1457
1458 if (job_cond->usage_end)
1459 end = job_cond->usage_end;
1460 else
1461 end = time(NULL);
1462
1463 if ((end - start) > slurmdbd_conf->max_time_range) {
1464 info("Rejecting query > MaxQueryTimeRange from uid %u",
1465 *uid);
1466 *out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
1467 ESLURM_DB_QUERY_TOO_WIDE,
1468 slurm_strerror(ESLURM_DB_QUERY_TOO_WIDE),
1469 DBD_GET_JOBS_COND);
1470 return SLURM_ERROR;
1471 }
1472 }
1473
1474 list_msg.my_list = jobacct_storage_g_get_jobs_cond(
1475 slurmdbd_conn->db_conn, *uid, job_cond);
1476
1477 if (!errno) {
1478 if (!list_msg.my_list)
1479 list_msg.my_list = list_create(NULL);
1480 *out_buffer = init_buf(1024);
1481 pack16((uint16_t) DBD_GOT_JOBS, *out_buffer);
1482 slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->conn->version,
1483 DBD_GOT_JOBS, *out_buffer);
1484 } else {
1485 *out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
1486 errno,
1487 slurm_strerror(errno),
1488 DBD_GET_JOBS_COND);
1489 rc = SLURM_ERROR;
1490 }
1491
1492 FREE_NULL_LIST(list_msg.my_list);
1493
1494 return rc;
1495 }
1496
_get_probs(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)1497 static int _get_probs(slurmdbd_conn_t *slurmdbd_conn,
1498 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
1499 {
1500 dbd_cond_msg_t *get_msg = msg->data;
1501 dbd_list_msg_t list_msg = { NULL };
1502 int rc = SLURM_SUCCESS;
1503
1504 debug2("DBD_GET_PROBS: called");
1505
1506 list_msg.my_list = acct_storage_g_get_problems(
1507 slurmdbd_conn->db_conn, *uid, get_msg->cond);
1508
1509 if (!errno) {
1510 if (!list_msg.my_list)
1511 list_msg.my_list = list_create(NULL);
1512 *out_buffer = init_buf(1024);
1513 pack16((uint16_t) DBD_GOT_PROBS, *out_buffer);
1514 slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->conn->version,
1515 DBD_GOT_PROBS, *out_buffer);
1516 } else {
1517 *out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
1518 errno,
1519 slurm_strerror(errno),
1520 DBD_GET_PROBS);
1521 rc = SLURM_ERROR;
1522 }
1523
1524 FREE_NULL_LIST(list_msg.my_list);
1525
1526 return rc;
1527 }
1528
_get_qos(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)1529 static int _get_qos(slurmdbd_conn_t *slurmdbd_conn,
1530 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
1531 {
1532 dbd_cond_msg_t *cond_msg = msg->data;
1533 dbd_list_msg_t list_msg = { NULL };
1534 int rc = SLURM_SUCCESS;
1535
1536 debug2("DBD_GET_QOS: called");
1537
1538 list_msg.my_list = acct_storage_g_get_qos(slurmdbd_conn->db_conn, *uid,
1539 cond_msg->cond);
1540
1541 if (errno == ESLURM_ACCESS_DENIED && !list_msg.my_list)
1542 list_msg.my_list = list_create(NULL);
1543
1544 if (!errno) {
1545 if (!list_msg.my_list)
1546 list_msg.my_list = list_create(NULL);
1547 *out_buffer = init_buf(1024);
1548 pack16((uint16_t) DBD_GOT_QOS, *out_buffer);
1549 slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->conn->version,
1550 DBD_GOT_QOS, *out_buffer);
1551 } else {
1552 *out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
1553 errno,
1554 slurm_strerror(errno),
1555 DBD_GET_QOS);
1556 rc = SLURM_ERROR;
1557 }
1558
1559 FREE_NULL_LIST(list_msg.my_list);
1560
1561 return rc;
1562 }
1563
_get_res(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)1564 static int _get_res(slurmdbd_conn_t *slurmdbd_conn,
1565 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
1566 {
1567 dbd_cond_msg_t *get_msg = msg->data;
1568 dbd_list_msg_t list_msg = { NULL };
1569 int rc = SLURM_SUCCESS;
1570
1571 debug2("DBD_GET_RES: called");
1572
1573 list_msg.my_list = acct_storage_g_get_res(
1574 slurmdbd_conn->db_conn, *uid, get_msg->cond);
1575
1576 if (!errno) {
1577 if (!list_msg.my_list)
1578 list_msg.my_list = list_create(NULL);
1579 *out_buffer = init_buf(1024);
1580 pack16((uint16_t) DBD_GOT_RES, *out_buffer);
1581 slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->conn->version,
1582 DBD_GOT_RES,
1583 *out_buffer);
1584 } else {
1585 *out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
1586 errno,
1587 slurm_strerror(errno),
1588 DBD_GET_RES);
1589 rc = SLURM_ERROR;
1590 }
1591
1592 FREE_NULL_LIST(list_msg.my_list);
1593 return rc;
1594 }
1595
_get_txn(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)1596 static int _get_txn(slurmdbd_conn_t *slurmdbd_conn,
1597 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
1598 {
1599 dbd_cond_msg_t *cond_msg = msg->data;
1600 dbd_list_msg_t list_msg = { NULL };
1601 int rc = SLURM_SUCCESS;
1602
1603 debug2("DBD_GET_TXN: called");
1604
1605 list_msg.my_list = acct_storage_g_get_txn(slurmdbd_conn->db_conn, *uid,
1606 cond_msg->cond);
1607
1608 if (!errno) {
1609 if (!list_msg.my_list)
1610 list_msg.my_list = list_create(NULL);
1611 *out_buffer = init_buf(1024);
1612 pack16((uint16_t) DBD_GOT_TXN, *out_buffer);
1613 slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->conn->version,
1614 DBD_GOT_TXN, *out_buffer);
1615 } else {
1616 *out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
1617 errno,
1618 slurm_strerror(errno),
1619 DBD_GET_TXN);
1620 rc = SLURM_ERROR;
1621 }
1622
1623 FREE_NULL_LIST(list_msg.my_list);
1624
1625 return rc;
1626 }
1627
_get_usage(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)1628 static int _get_usage(slurmdbd_conn_t *slurmdbd_conn,
1629 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
1630 {
1631 dbd_usage_msg_t *get_msg = msg->data;
1632 dbd_usage_msg_t got_msg;
1633 uint16_t ret_type = 0;
1634 int rc = SLURM_SUCCESS;
1635 char *comment = NULL;
1636
1637 info("DBD_GET_USAGE: called type is %s",
1638 slurmdbd_msg_type_2_str(msg->msg_type, 1));
1639
1640 switch(msg->msg_type) {
1641 case DBD_GET_ASSOC_USAGE:
1642 ret_type = DBD_GOT_ASSOC_USAGE;
1643 break;
1644 case DBD_GET_WCKEY_USAGE:
1645 ret_type = DBD_GOT_WCKEY_USAGE;
1646 break;
1647 case DBD_GET_CLUSTER_USAGE:
1648 ret_type = DBD_GOT_CLUSTER_USAGE;
1649 break;
1650 default:
1651 comment = "Unknown type of usage to get";
1652 error("%s %u", comment, msg->msg_type);
1653 *out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
1654 SLURM_ERROR, comment,
1655 msg->msg_type);
1656 return SLURM_ERROR;
1657 }
1658
1659 rc = acct_storage_g_get_usage(slurmdbd_conn->db_conn,
1660 *uid, get_msg->rec, msg->msg_type,
1661 get_msg->start, get_msg->end);
1662
1663 if (rc != SLURM_SUCCESS) {
1664 comment = "Problem getting usage info";
1665 error("CONN:%u %s", slurmdbd_conn->conn->fd, comment);
1666 *out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
1667 rc, comment,
1668 msg->msg_type);
1669 return rc;
1670
1671 }
1672 memset(&got_msg, 0, sizeof(dbd_usage_msg_t));
1673 got_msg.rec = get_msg->rec;
1674 get_msg->rec = NULL;
1675 *out_buffer = init_buf(1024);
1676 pack16((uint16_t) ret_type, *out_buffer);
1677 slurmdbd_pack_usage_msg(&got_msg, slurmdbd_conn->conn->version,
1678 ret_type, *out_buffer);
1679
1680 return SLURM_SUCCESS;
1681 }
1682
_get_users(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)1683 static int _get_users(slurmdbd_conn_t *slurmdbd_conn,
1684 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
1685 {
1686 dbd_cond_msg_t *get_msg = msg->data;
1687 dbd_list_msg_t list_msg = { NULL };
1688 int rc = SLURM_SUCCESS;
1689 slurmdb_user_cond_t * user_cond = NULL;
1690
1691 debug2("DBD_GET_USERS: called");
1692
1693 user_cond = get_msg->cond;
1694 if ((!user_cond->with_assocs && !user_cond->with_wckeys)
1695 && ((slurmdbd_conn->conn->version < 8)
1696 || (user_cond->assoc_cond->only_defs))) {
1697 List cluster_list = user_cond->assoc_cond->cluster_list;
1698 /* load up with just this cluster to query against
1699 * since befor 2.2 we had only 1 default account so
1700 * send the default for this cluster. */
1701 if (!cluster_list) {
1702 cluster_list = list_create(NULL);
1703 list_append(cluster_list,
1704 slurmdbd_conn->conn->cluster_name);
1705 user_cond->assoc_cond->cluster_list = cluster_list;
1706 }
1707 }
1708
1709 list_msg.my_list = acct_storage_g_get_users(slurmdbd_conn->db_conn,
1710 *uid, user_cond);
1711
1712 if (!errno) {
1713 if (!list_msg.my_list)
1714 list_msg.my_list = list_create(NULL);
1715 *out_buffer = init_buf(1024);
1716 pack16((uint16_t) DBD_GOT_USERS, *out_buffer);
1717 slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->conn->version,
1718 DBD_GOT_USERS, *out_buffer);
1719 } else {
1720 *out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
1721 errno,
1722 slurm_strerror(errno),
1723 DBD_GET_USERS);
1724 rc = SLURM_ERROR;
1725 }
1726
1727 FREE_NULL_LIST(list_msg.my_list);
1728
1729 return rc;
1730 }
1731
_get_wckeys(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)1732 static int _get_wckeys(slurmdbd_conn_t *slurmdbd_conn,
1733 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
1734 {
1735 dbd_cond_msg_t *get_msg = msg->data;
1736 dbd_list_msg_t list_msg = { NULL };
1737 char *comment = NULL;
1738 int rc = SLURM_SUCCESS;
1739
1740 debug2("DBD_GET_WCKEYS: called");
1741
1742 /* We have to check this here, and not in the plugin. There
1743 * are places in the plugin that a non-admin can call this and
1744 * it be ok. */
1745 if (!_validate_operator(*uid, slurmdbd_conn)) {
1746 comment = "Your user doesn't have privilege to perform this action";
1747 error("CONN:%u %s", slurmdbd_conn->conn->fd, comment);
1748 *out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
1749 ESLURM_ACCESS_DENIED,
1750 comment,
1751 DBD_GET_WCKEYS);
1752 return ESLURM_ACCESS_DENIED;
1753 }
1754
1755 list_msg.my_list = acct_storage_g_get_wckeys(slurmdbd_conn->db_conn,
1756 *uid, get_msg->cond);
1757
1758 if (!errno) {
1759 if (!list_msg.my_list)
1760 list_msg.my_list = list_create(NULL);
1761 *out_buffer = init_buf(1024);
1762 pack16((uint16_t) DBD_GOT_WCKEYS, *out_buffer);
1763 slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->conn->version,
1764 DBD_GOT_WCKEYS, *out_buffer);
1765 } else {
1766 *out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
1767 errno,
1768 slurm_strerror(errno),
1769 DBD_GET_WCKEYS);
1770 rc = SLURM_ERROR;
1771 }
1772
1773 FREE_NULL_LIST(list_msg.my_list);
1774
1775 return rc;
1776 }
1777
_get_reservations(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)1778 static int _get_reservations(slurmdbd_conn_t *slurmdbd_conn,
1779 persist_msg_t *msg, Buf *out_buffer,
1780 uint32_t *uid)
1781 {
1782 dbd_cond_msg_t *get_msg = msg->data;
1783 dbd_list_msg_t list_msg = { NULL };
1784 int rc = SLURM_SUCCESS;
1785
1786 debug2("DBD_GET_RESVS: called");
1787
1788 list_msg.my_list = acct_storage_g_get_reservations(
1789 slurmdbd_conn->db_conn, *uid, get_msg->cond);
1790
1791 if (!errno) {
1792 if (!list_msg.my_list)
1793 list_msg.my_list = list_create(NULL);
1794 *out_buffer = init_buf(1024);
1795 pack16((uint16_t) DBD_GOT_RESVS, *out_buffer);
1796 slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->conn->version,
1797 DBD_GOT_RESVS, *out_buffer);
1798 } else {
1799 *out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
1800 errno,
1801 slurm_strerror(errno),
1802 DBD_GET_RESVS);
1803 rc = SLURM_ERROR;
1804 }
1805
1806 FREE_NULL_LIST(list_msg.my_list);
1807
1808 return rc;
1809 }
1810
_find_rpc_obj_in_list(void * x,void * key)1811 static int _find_rpc_obj_in_list(void *x, void *key)
1812 {
1813 slurmdb_rpc_obj_t *obj = (slurmdb_rpc_obj_t *)x;
1814
1815 if (obj->id == *(int *)key)
1816 return 1;
1817 return 0;
1818 }
1819
_flush_jobs(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)1820 static int _flush_jobs(slurmdbd_conn_t *slurmdbd_conn,
1821 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
1822 {
1823 dbd_cluster_tres_msg_t *cluster_tres_msg = msg->data;
1824 int rc = SLURM_SUCCESS;
1825 char *comment = NULL;
1826
1827 if (!_validate_slurm_user(*uid)) {
1828 comment = "DBD_FLUSH_JOBS message from invalid uid";
1829 error("DBD_FLUSH_JOBS message from invalid uid %u", *uid);
1830 rc = ESLURM_ACCESS_DENIED;
1831 goto end_it;
1832 }
1833
1834 debug2("DBD_FLUSH_JOBS: called for %s",
1835 slurmdbd_conn->conn->cluster_name);
1836
1837 rc = acct_storage_g_flush_jobs_on_cluster(
1838 slurmdbd_conn->db_conn,
1839 cluster_tres_msg->event_time);
1840 end_it:
1841 *out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
1842 rc, comment, DBD_FLUSH_JOBS);
1843 return rc;
1844 }
1845
_fini_conn(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer)1846 static int _fini_conn(slurmdbd_conn_t *slurmdbd_conn, persist_msg_t *msg,
1847 Buf *out_buffer)
1848 {
1849 dbd_fini_msg_t *fini_msg = msg->data;
1850 char *comment = NULL;
1851 int rc = SLURM_SUCCESS;
1852 bool locked = false;
1853
1854
1855 debug2("DBD_FINI: CLOSE:%u COMMIT:%u",
1856 fini_msg->close_conn, fini_msg->commit);
1857
1858 if (slurmdbd_conn->conn->rem_port && slurmdbd_conf->commit_delay) {
1859 slurm_mutex_lock(®istered_lock);
1860 locked = true;
1861 }
1862
1863 if (fini_msg->close_conn == 1)
1864 rc = acct_storage_g_close_connection(&slurmdbd_conn->db_conn);
1865 else
1866 rc = acct_storage_g_commit(slurmdbd_conn->db_conn,
1867 fini_msg->commit);
1868 if (locked)
1869 slurm_mutex_unlock(®istered_lock);
1870
1871 *out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
1872 rc, comment, DBD_FINI);
1873 return rc;
1874
1875 }
1876
_job_complete(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)1877 static int _job_complete(slurmdbd_conn_t *slurmdbd_conn,
1878 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
1879 {
1880 dbd_job_comp_msg_t *job_comp_msg = msg->data;
1881 job_record_t job;
1882 struct job_details details;
1883 int rc = SLURM_SUCCESS;
1884 char *comment = NULL;
1885
1886 if (!_validate_slurm_user(*uid)) {
1887 comment = "DBD_JOB_COMPLETE message from invalid uid";
1888 error("CONN:%u %s %u",
1889 slurmdbd_conn->conn->fd, comment, *uid);
1890 rc = ESLURM_ACCESS_DENIED;
1891 goto end_it;
1892 }
1893
1894 memset(&job, 0, sizeof(job_record_t));
1895 memset(&details, 0, sizeof(struct job_details));
1896
1897 job.admin_comment = job_comp_msg->admin_comment;
1898 job.assoc_id = job_comp_msg->assoc_id;
1899 job.comment = job_comp_msg->comment;
1900 if (job_comp_msg->db_index != NO_VAL64)
1901 job.db_index = job_comp_msg->db_index;
1902 job.derived_ec = job_comp_msg->derived_ec;
1903 job.end_time = job_comp_msg->end_time;
1904 job.exit_code = job_comp_msg->exit_code;
1905 job.job_id = job_comp_msg->job_id;
1906 job.job_state = job_comp_msg->job_state;
1907 job.requid = job_comp_msg->req_uid;
1908 job.nodes = job_comp_msg->nodes;
1909 job.start_time = job_comp_msg->start_time;
1910 details.submit_time = job_comp_msg->submit_time;
1911 job.start_protocol_ver = slurmdbd_conn->conn->version;
1912 job.system_comment = job_comp_msg->system_comment;
1913 job.tres_alloc_str = job_comp_msg->tres_alloc_str;
1914
1915 job.details = &details;
1916
1917 if (job.job_state & JOB_RESIZING) {
1918 job.resize_time = job_comp_msg->end_time;
1919 debug2("DBD_JOB_COMPLETE: RESIZE ID:%u", job_comp_msg->job_id);
1920 } else
1921 debug2("DBD_JOB_COMPLETE: ID:%u", job_comp_msg->job_id);
1922
1923 rc = jobacct_storage_g_job_complete(slurmdbd_conn->db_conn, &job);
1924
1925 if (rc && errno == 740) /* meaning data is already there */
1926 rc = SLURM_SUCCESS;
1927
1928 /* just in case this gets set we need to clear it */
1929 xfree(job.wckey);
1930
1931 if (!slurmdbd_conn->conn->rem_port) {
1932 debug3("DBD_JOB_COMPLETE: cluster not registered");
1933 slurmdbd_conn->conn->rem_port =
1934 clusteracct_storage_g_register_disconn_ctld(
1935 slurmdbd_conn->db_conn,
1936 slurmdbd_conn->conn->rem_host);
1937
1938 _add_registered_cluster(slurmdbd_conn);
1939 }
1940
1941 end_it:
1942 *out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
1943 rc, comment, DBD_JOB_COMPLETE);
1944 return SLURM_SUCCESS;
1945 }
1946
_job_start(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)1947 static int _job_start(slurmdbd_conn_t *slurmdbd_conn,
1948 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
1949 {
1950 dbd_job_start_msg_t *job_start_msg = msg->data;
1951 dbd_id_rc_msg_t id_rc_msg;
1952 char *comment = NULL;
1953
1954 if (!_validate_slurm_user(*uid)) {
1955 comment = "DBD_JOB_START message from invalid uid";
1956 error("CONN:%u %s %u",
1957 slurmdbd_conn->conn->fd, comment, *uid);
1958 *out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
1959 ESLURM_ACCESS_DENIED,
1960 comment,
1961 DBD_JOB_START);
1962 return SLURM_ERROR;
1963 }
1964
1965 _process_job_start(slurmdbd_conn, job_start_msg, &id_rc_msg);
1966
1967 *out_buffer = init_buf(1024);
1968 pack16((uint16_t) DBD_ID_RC, *out_buffer);
1969 slurmdbd_pack_id_rc_msg(&id_rc_msg,
1970 slurmdbd_conn->conn->version, *out_buffer);
1971 return SLURM_SUCCESS;
1972 }
1973
_job_suspend(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)1974 static int _job_suspend(slurmdbd_conn_t *slurmdbd_conn,
1975 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
1976 {
1977 dbd_job_suspend_msg_t *job_suspend_msg = msg->data;
1978 job_record_t job;
1979 struct job_details details;
1980 int rc = SLURM_SUCCESS;
1981 char *comment = NULL;
1982
1983 if (!_validate_slurm_user(*uid)) {
1984 comment = "DBD_JOB_SUSPEND message from invalid uid";
1985 error("CONN:%u %s %u",
1986 slurmdbd_conn->conn->fd, comment, *uid);
1987 rc = ESLURM_ACCESS_DENIED;
1988 goto end_it;
1989 }
1990
1991 debug2("DBD_JOB_SUSPEND: ID:%u STATE:%s",
1992 job_suspend_msg->job_id,
1993 job_state_string(job_suspend_msg->job_state));
1994
1995 memset(&job, 0, sizeof(job_record_t));
1996 memset(&details, 0, sizeof(struct job_details));
1997
1998 job.assoc_id = job_suspend_msg->assoc_id;
1999 if (job_suspend_msg->db_index != NO_VAL64)
2000 job.db_index = job_suspend_msg->db_index;
2001 job.job_id = job_suspend_msg->job_id;
2002 job.job_state = job_suspend_msg->job_state;
2003 details.submit_time = job_suspend_msg->submit_time;
2004 job.start_protocol_ver = slurmdbd_conn->conn->version;
2005 job.suspend_time = job_suspend_msg->suspend_time;
2006
2007 job.details = &details;
2008 rc = jobacct_storage_g_job_suspend(slurmdbd_conn->db_conn, &job);
2009
2010 if (rc && errno == 740) /* meaning data is already there */
2011 rc = SLURM_SUCCESS;
2012
2013 /* just in case this gets set we need to clear it */
2014 xfree(job.wckey);
2015 end_it:
2016 *out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
2017 rc, comment,
2018 DBD_JOB_SUSPEND);
2019 return SLURM_SUCCESS;
2020 }
2021
_modify_accounts(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)2022 static int _modify_accounts(slurmdbd_conn_t *slurmdbd_conn,
2023 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
2024 {
2025 dbd_list_msg_t list_msg = { NULL };
2026 int rc = SLURM_SUCCESS;
2027 dbd_modify_msg_t *get_msg = msg->data;
2028 char *comment = NULL;
2029
2030 debug2("DBD_MODIFY_ACCOUNTS: called");
2031
2032 if (!(list_msg.my_list = acct_storage_g_modify_accounts(
2033 slurmdbd_conn->db_conn, *uid, get_msg->cond,
2034 get_msg->rec))) {
2035 if (errno == ESLURM_ACCESS_DENIED) {
2036 comment = "Your user doesn't have privilege to perform this action";
2037 rc = ESLURM_ACCESS_DENIED;
2038 } else if (errno == SLURM_ERROR) {
2039 comment = "Something was wrong with your query";
2040 rc = SLURM_ERROR;
2041 } else if (errno == SLURM_NO_CHANGE_IN_DATA) {
2042 comment = "Request didn't affect anything";
2043 rc = SLURM_SUCCESS;
2044 } else if (errno == ESLURM_DB_CONNECTION) {
2045 comment = slurm_strerror(errno);
2046 rc = errno;
2047 } else {
2048 rc = errno;
2049 if (!(comment = slurm_strerror(errno)))
2050 comment = "Unknown issue";
2051 }
2052 error("CONN:%u %s", slurmdbd_conn->conn->fd, comment);
2053 *out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
2054 rc, comment,
2055 DBD_MODIFY_ACCOUNTS);
2056 return rc;
2057 }
2058
2059 *out_buffer = init_buf(1024);
2060 pack16((uint16_t) DBD_GOT_LIST, *out_buffer);
2061 slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->conn->version,
2062 DBD_GOT_LIST, *out_buffer);
2063 FREE_NULL_LIST(list_msg.my_list);
2064
2065 return rc;
2066 }
2067
_modify_assocs(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)2068 static int _modify_assocs(slurmdbd_conn_t *slurmdbd_conn,
2069 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
2070 {
2071 dbd_list_msg_t list_msg = { NULL };
2072 int rc = SLURM_SUCCESS;
2073 dbd_modify_msg_t *get_msg = msg->data;
2074 char *comment = NULL;
2075
2076 debug2("DBD_MODIFY_ASSOCS: called");
2077
2078 /* All authentication needs to be done inside the plugin since we are
2079 * unable to know what accounts this request is talking about
2080 * until we process it through the database.
2081 */
2082
2083 if (!(list_msg.my_list = acct_storage_g_modify_assocs(
2084 slurmdbd_conn->db_conn, *uid, get_msg->cond,
2085 get_msg->rec))) {
2086 if (errno == ESLURM_ACCESS_DENIED) {
2087 comment = "Your user doesn't have privilege to perform this action";
2088 rc = ESLURM_ACCESS_DENIED;
2089 } else if (errno == SLURM_ERROR) {
2090 comment = "Something was wrong with your query";
2091 rc = SLURM_ERROR;
2092 } else if (errno == SLURM_NO_CHANGE_IN_DATA) {
2093 comment = "Request didn't affect anything";
2094 rc = SLURM_SUCCESS;
2095 } else if (errno == ESLURM_DB_CONNECTION) {
2096 comment = slurm_strerror(errno);
2097 rc = errno;
2098 } else {
2099 rc = errno;
2100 if (!(comment = slurm_strerror(errno)))
2101 comment = "Unknown issue";
2102 }
2103 error("CONN:%u %s", slurmdbd_conn->conn->fd, comment);
2104 *out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
2105 rc, comment,
2106 DBD_MODIFY_ASSOCS);
2107 return rc;
2108 }
2109
2110 *out_buffer = init_buf(1024);
2111 pack16((uint16_t) DBD_GOT_LIST, *out_buffer);
2112 slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->conn->version,
2113 DBD_GOT_LIST, *out_buffer);
2114 FREE_NULL_LIST(list_msg.my_list);
2115
2116 return rc;
2117 }
2118
_modify_clusters(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)2119 static int _modify_clusters(slurmdbd_conn_t *slurmdbd_conn,
2120 persist_msg_t *msg, Buf *out_buffer,
2121 uint32_t *uid)
2122 {
2123 dbd_list_msg_t list_msg = { NULL };
2124 int rc = SLURM_SUCCESS;
2125 dbd_modify_msg_t *get_msg = msg->data;
2126 char *comment = NULL;
2127
2128 debug2("DBD_MODIFY_CLUSTERS: called");
2129
2130 if (!(list_msg.my_list = acct_storage_g_modify_clusters(
2131 slurmdbd_conn->db_conn, *uid, get_msg->cond,
2132 get_msg->rec))) {
2133 if (errno == ESLURM_ACCESS_DENIED) {
2134 comment = "Your user doesn't have privilege to perform this action";
2135 rc = ESLURM_ACCESS_DENIED;
2136 } else if (errno == SLURM_ERROR) {
2137 comment = "Something was wrong with your query";
2138 rc = SLURM_ERROR;
2139 } else if (errno == SLURM_NO_CHANGE_IN_DATA) {
2140 comment = "Request didn't affect anything";
2141 rc = SLURM_SUCCESS;
2142 } else if (errno == ESLURM_DB_CONNECTION) {
2143 comment = slurm_strerror(errno);
2144 rc = errno;
2145 } else {
2146 rc = errno;
2147 if (!(comment = slurm_strerror(errno)))
2148 comment = "Unknown issue";
2149 }
2150 error("CONN:%u %s", slurmdbd_conn->conn->fd, comment);
2151 *out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
2152 rc, comment,
2153 DBD_MODIFY_CLUSTERS);
2154 return rc;
2155 }
2156
2157 *out_buffer = init_buf(1024);
2158 pack16((uint16_t) DBD_GOT_LIST, *out_buffer);
2159 slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->conn->version,
2160 DBD_GOT_LIST, *out_buffer);
2161 FREE_NULL_LIST(list_msg.my_list);
2162
2163 return rc;
2164 }
2165
_modify_federations(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)2166 static int _modify_federations(slurmdbd_conn_t *slurmdbd_conn,
2167 persist_msg_t *msg,
2168 Buf *out_buffer, uint32_t *uid)
2169 {
2170 dbd_list_msg_t list_msg = { NULL };
2171 int rc = SLURM_SUCCESS;
2172 dbd_modify_msg_t *get_msg = msg->data;
2173 char *comment = NULL;
2174
2175 debug2("DBD_MODIFY_FEDERATIONS: called");
2176
2177 if (!(list_msg.my_list = acct_storage_g_modify_federations(
2178 slurmdbd_conn->db_conn, *uid, get_msg->cond,
2179 get_msg->rec))) {
2180 if (errno == ESLURM_ACCESS_DENIED) {
2181 comment = "Your user doesn't have privilege to perform "
2182 "this action";
2183 rc = ESLURM_ACCESS_DENIED;
2184 } else if (errno == SLURM_ERROR) {
2185 comment = "Something was wrong with your query";
2186 rc = SLURM_ERROR;
2187 } else if (errno == SLURM_NO_CHANGE_IN_DATA) {
2188 comment = "Request didn't affect anything";
2189 rc = SLURM_SUCCESS;
2190 } else if (errno == ESLURM_DB_CONNECTION) {
2191 comment = slurm_strerror(errno);
2192 rc = errno;
2193 } else {
2194 rc = errno;
2195 if (!(comment = slurm_strerror(errno)))
2196 comment = "Unknown issue";
2197 }
2198 error("CONN:%u %s", slurmdbd_conn->conn->fd, comment);
2199 *out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
2200 rc, comment,
2201 DBD_MODIFY_FEDERATIONS);
2202 return rc;
2203 }
2204
2205 *out_buffer = init_buf(1024);
2206 pack16((uint16_t) DBD_GOT_LIST, *out_buffer);
2207 slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->conn->version,
2208 DBD_GOT_LIST, *out_buffer);
2209 FREE_NULL_LIST(list_msg.my_list);
2210
2211 return rc;
2212 }
2213
_modify_job(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)2214 static int _modify_job(slurmdbd_conn_t *slurmdbd_conn,
2215 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
2216 {
2217 dbd_list_msg_t list_msg = { NULL };
2218 int rc = SLURM_SUCCESS;
2219 dbd_modify_msg_t *get_msg = msg->data;
2220 char *comment = NULL;
2221
2222 debug2("DBD_MODIFY_JOB: called");
2223
2224 if (!(list_msg.my_list = acct_storage_g_modify_job(
2225 slurmdbd_conn->db_conn, *uid, get_msg->cond,
2226 get_msg->rec))) {
2227 if (errno == ESLURM_ACCESS_DENIED) {
2228 comment = "Your user doesn't have privilege to perform this action";
2229 rc = ESLURM_ACCESS_DENIED;
2230 } else if (errno == SLURM_ERROR) {
2231 comment = "Something was wrong with your query";
2232 rc = SLURM_ERROR;
2233 } else if (errno == SLURM_NO_CHANGE_IN_DATA) {
2234 comment = "Request didn't affect anything";
2235 rc = SLURM_SUCCESS;
2236 } else if (errno == ESLURM_DB_CONNECTION) {
2237 comment = slurm_strerror(errno);
2238 rc = errno;
2239 } else {
2240 rc = errno;
2241 if (!(comment = slurm_strerror(errno)))
2242 comment = "Unknown issue";
2243 }
2244 error("CONN:%u %s", slurmdbd_conn->conn->fd, comment);
2245 *out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
2246 rc, comment,
2247 DBD_MODIFY_JOB);
2248 return rc;
2249 }
2250
2251 if (get_msg->cond &&
2252 (((slurmdb_job_cond_t *)get_msg->cond)->flags &
2253 JOBCOND_FLAG_NO_WAIT)) {
2254 *out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
2255 rc, comment,
2256 DBD_MODIFY_JOB);
2257 } else {
2258 *out_buffer = init_buf(1024);
2259 pack16((uint16_t) DBD_GOT_LIST, *out_buffer);
2260 slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->conn->version,
2261 DBD_GOT_LIST, *out_buffer);
2262 }
2263
2264 FREE_NULL_LIST(list_msg.my_list);
2265
2266 return rc;
2267 }
2268
_modify_qos(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)2269 static int _modify_qos(slurmdbd_conn_t *slurmdbd_conn,
2270 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
2271 {
2272 dbd_list_msg_t list_msg = { NULL };
2273 int rc = SLURM_SUCCESS;
2274 dbd_modify_msg_t *get_msg = msg->data;
2275 char *comment = NULL;
2276
2277 debug2("DBD_MODIFY_QOS: called");
2278
2279 if (!(list_msg.my_list = acct_storage_g_modify_qos(
2280 slurmdbd_conn->db_conn, *uid, get_msg->cond,
2281 get_msg->rec))) {
2282 if (errno == ESLURM_ACCESS_DENIED) {
2283 comment = "Your user doesn't have privilege to perform this action";
2284 rc = ESLURM_ACCESS_DENIED;
2285 } else if (errno == SLURM_ERROR) {
2286 comment = "Something was wrong with your query";
2287 rc = SLURM_ERROR;
2288 } else if (errno == SLURM_NO_CHANGE_IN_DATA) {
2289 comment = "Request didn't affect anything";
2290 rc = SLURM_SUCCESS;
2291 } else if (errno == ESLURM_QOS_PREEMPTION_LOOP) {
2292 comment = "QOS Preemption loop detected";
2293 rc = ESLURM_QOS_PREEMPTION_LOOP;
2294 } else if (errno == ESLURM_DB_CONNECTION) {
2295 comment = slurm_strerror(errno);
2296 rc = errno;
2297 } else {
2298 rc = errno;
2299 if (!(comment = slurm_strerror(errno)))
2300 comment = "Unknown issue";
2301 }
2302 error("CONN:%u %s", slurmdbd_conn->conn->fd, comment);
2303 *out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
2304 rc, comment,
2305 DBD_MODIFY_QOS);
2306 return rc;
2307 }
2308
2309 *out_buffer = init_buf(1024);
2310 pack16((uint16_t) DBD_GOT_LIST, *out_buffer);
2311 slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->conn->version,
2312 DBD_GOT_LIST, *out_buffer);
2313 FREE_NULL_LIST(list_msg.my_list);
2314
2315 return rc;
2316 }
2317
_modify_res(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)2318 static int _modify_res(slurmdbd_conn_t *slurmdbd_conn,
2319 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
2320 {
2321 dbd_list_msg_t list_msg = { NULL };
2322 int rc = SLURM_SUCCESS;
2323 dbd_modify_msg_t *get_msg = msg->data;
2324 char *comment = NULL;
2325
2326 debug2("DBD_MODIFY_RES: called");
2327
2328 if (!(list_msg.my_list = acct_storage_g_modify_res(
2329 slurmdbd_conn->db_conn, *uid, get_msg->cond,
2330 get_msg->rec))) {
2331 if (errno == ESLURM_ACCESS_DENIED) {
2332 comment = "Your user doesn't have privilege to perform "
2333 "this action";
2334 rc = ESLURM_ACCESS_DENIED;
2335 } else if (errno == SLURM_ERROR) {
2336 comment = "Something was wrong with your query";
2337 rc = SLURM_ERROR;
2338 } else if (errno == SLURM_NO_CHANGE_IN_DATA) {
2339 comment = "Request didn't affect anything";
2340 rc = SLURM_SUCCESS;
2341 } else if (errno == ESLURM_DB_CONNECTION) {
2342 comment = slurm_strerror(errno);
2343 rc = errno;
2344 } else {
2345 rc = errno;
2346 if (!(comment = slurm_strerror(errno)))
2347 comment = "Unknown issue";
2348 }
2349 error("CONN:%u %s", slurmdbd_conn->conn->fd, comment);
2350 *out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
2351 rc, comment,
2352 DBD_MODIFY_RES);
2353 return rc;
2354 }
2355
2356 *out_buffer = init_buf(1024);
2357 pack16((uint16_t) DBD_GOT_LIST, *out_buffer);
2358 slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->conn->version,
2359 DBD_GOT_LIST, *out_buffer);
2360 FREE_NULL_LIST(list_msg.my_list);
2361 return rc;
2362 }
2363
_modify_users(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)2364 static int _modify_users(slurmdbd_conn_t *slurmdbd_conn,
2365 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
2366 {
2367 dbd_list_msg_t list_msg = { NULL };
2368 int rc = SLURM_SUCCESS;
2369 dbd_modify_msg_t *get_msg = msg->data;
2370 char *comment = NULL;
2371 int same_user = 0;
2372 slurmdb_user_cond_t *user_cond = NULL;
2373 slurmdb_user_rec_t *user_rec = NULL;
2374
2375 debug2("DBD_MODIFY_USERS: called");
2376
2377 user_cond = (slurmdb_user_cond_t *)get_msg->cond;
2378 user_rec = (slurmdb_user_rec_t *)get_msg->rec;
2379
2380 if (!_validate_operator(*uid, slurmdbd_conn)) {
2381 if (user_cond && user_cond->assoc_cond
2382 && user_cond->assoc_cond->user_list
2383 && (list_count(user_cond->assoc_cond->user_list) == 1)) {
2384 uid_t pw_uid;
2385 char *name;
2386 name = list_peek (user_cond->assoc_cond->user_list);
2387 if ((uid_from_string (name, &pw_uid) >= 0)
2388 && pw_uid == *uid) {
2389 same_user = 1;
2390 goto is_same_user;
2391 }
2392 }
2393 comment = "Your user doesn't have privilege to perform this action";
2394 error("CONN:%u %s", slurmdbd_conn->conn->fd, comment);
2395 *out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
2396 ESLURM_ACCESS_DENIED,
2397 comment,
2398 DBD_MODIFY_USERS);
2399
2400 return ESLURM_ACCESS_DENIED;
2401 }
2402
2403 is_same_user:
2404
2405 /* same_user can only alter the default account, default wckey
2406 * nothing else */
2407 if (same_user) {
2408 /* If we add anything else here for the user we will
2409 * need to document it
2410 */
2411 if ((user_rec->admin_level != SLURMDB_ADMIN_NOTSET)) {
2412 comment = "You can only change your own default account, default wckey nothing else";
2413 error("CONN:%u %s", slurmdbd_conn->conn->fd, comment);
2414 *out_buffer = slurm_persist_make_rc_msg(
2415 slurmdbd_conn->conn,
2416 ESLURM_ACCESS_DENIED,
2417 comment,
2418 DBD_MODIFY_USERS);
2419
2420 return ESLURM_ACCESS_DENIED;
2421 }
2422 }
2423
2424 if ((user_rec->admin_level != SLURMDB_ADMIN_NOTSET) &&
2425 !_validate_super_user(*uid, slurmdbd_conn)) {
2426 comment = "You must be a super user to modify a users admin level";
2427 error("CONN:%u %s", slurmdbd_conn->conn->fd, comment);
2428 *out_buffer = slurm_persist_make_rc_msg(
2429 slurmdbd_conn->conn,
2430 ESLURM_ACCESS_DENIED,
2431 comment,
2432 DBD_MODIFY_USERS);
2433 return ESLURM_ACCESS_DENIED;
2434 }
2435
2436 if (!(list_msg.my_list = acct_storage_g_modify_users(
2437 slurmdbd_conn->db_conn, *uid, user_cond, user_rec))) {
2438 if (errno == ESLURM_ACCESS_DENIED) {
2439 comment = "Your user doesn't have privilege to perform this action";
2440 rc = ESLURM_ACCESS_DENIED;
2441 } else if (errno == SLURM_ERROR) {
2442 comment = "Something was wrong with your query";
2443 rc = SLURM_ERROR;
2444 } else if (errno == SLURM_NO_CHANGE_IN_DATA) {
2445 comment = "Request didn't affect anything";
2446 rc = SLURM_SUCCESS;
2447 } else if (errno == ESLURM_DB_CONNECTION) {
2448 comment = slurm_strerror(errno);
2449 rc = errno;
2450 } else {
2451 rc = errno;
2452 if (!(comment = slurm_strerror(errno)))
2453 comment = "Unknown issue";
2454 }
2455 error("CONN:%u %s", slurmdbd_conn->conn->fd, comment);
2456 *out_buffer = slurm_persist_make_rc_msg(
2457 slurmdbd_conn->conn, rc, comment, DBD_MODIFY_USERS);
2458 return rc;
2459 }
2460
2461 *out_buffer = init_buf(1024);
2462 pack16((uint16_t) DBD_GOT_LIST, *out_buffer);
2463 slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->conn->version,
2464 DBD_GOT_LIST, *out_buffer);
2465 FREE_NULL_LIST(list_msg.my_list);
2466
2467 return rc;
2468 }
2469
_modify_wckeys(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)2470 static int _modify_wckeys(slurmdbd_conn_t *slurmdbd_conn,
2471 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
2472 {
2473 dbd_list_msg_t list_msg = { NULL };
2474 int rc = SLURM_SUCCESS;
2475 dbd_modify_msg_t *get_msg = msg->data;
2476 char *comment = NULL;
2477
2478 debug2("DBD_MODIFY_WCKEYS: called");
2479
2480 if (!(list_msg.my_list = acct_storage_g_modify_wckeys(
2481 slurmdbd_conn->db_conn, *uid, get_msg->cond,
2482 get_msg->rec))) {
2483 if (errno == ESLURM_ACCESS_DENIED) {
2484 comment = "Your user doesn't have privilege to perform this action";
2485 rc = ESLURM_ACCESS_DENIED;
2486 } else if (errno == SLURM_ERROR) {
2487 comment = "Something was wrong with your query";
2488 rc = SLURM_ERROR;
2489 } else if (errno == SLURM_NO_CHANGE_IN_DATA) {
2490 comment = "Request didn't affect anything";
2491 rc = SLURM_SUCCESS;
2492 } else if (errno == ESLURM_DB_CONNECTION) {
2493 comment = slurm_strerror(errno);
2494 rc = errno;
2495 } else {
2496 rc = errno;
2497 if (!(comment = slurm_strerror(errno)))
2498 comment = "Unknown issue";
2499 }
2500 error("CONN:%u %s", slurmdbd_conn->conn->fd, comment);
2501 *out_buffer = slurm_persist_make_rc_msg(
2502 slurmdbd_conn->conn, rc, comment, DBD_MODIFY_WCKEYS);
2503 return rc;
2504 }
2505
2506 *out_buffer = init_buf(1024);
2507 pack16((uint16_t) DBD_GOT_LIST, *out_buffer);
2508 slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->conn->version,
2509 DBD_GOT_LIST, *out_buffer);
2510 FREE_NULL_LIST(list_msg.my_list);
2511
2512 return rc;
2513 }
2514
_modify_reservation(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)2515 static int _modify_reservation(slurmdbd_conn_t *slurmdbd_conn,
2516 persist_msg_t *msg, Buf *out_buffer,
2517 uint32_t *uid)
2518 {
2519 int rc = SLURM_SUCCESS;
2520 dbd_rec_msg_t *rec_msg = msg->data;
2521 char *comment = NULL;
2522
2523 if (!_validate_slurm_user(*uid)) {
2524 comment = "DBD_MODIFY_RESV message from invalid uid";
2525 error("CONN:%u %s %u",
2526 slurmdbd_conn->conn->fd, comment, *uid);
2527 rc = ESLURM_ACCESS_DENIED;
2528 goto end_it;
2529 }
2530
2531 debug2("DBD_MODIFY_RESV: called");
2532
2533 rc = acct_storage_g_modify_reservation(slurmdbd_conn->db_conn,
2534 rec_msg->rec);
2535
2536 end_it:
2537 *out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
2538 rc, comment, DBD_MODIFY_RESV);
2539 return rc;
2540 }
2541
_node_state(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)2542 static int _node_state(slurmdbd_conn_t *slurmdbd_conn,
2543 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
2544 {
2545 dbd_node_state_msg_t *node_state_msg = msg->data;
2546 node_record_t node_ptr;
2547 int rc = SLURM_SUCCESS;
2548 char *comment = NULL;
2549
2550 if (!_validate_slurm_user(*uid)) {
2551 comment = "DBD_NODE_STATE message from invalid uid";
2552 error("CONN:%u %s %u",
2553 slurmdbd_conn->conn->fd, comment, *uid);
2554 rc = ESLURM_ACCESS_DENIED;
2555 goto end_it;
2556 }
2557
2558 memset(&node_ptr, 0, sizeof(node_record_t));
2559 node_ptr.name = node_state_msg->hostlist;
2560 node_ptr.tres_str = node_state_msg->tres_str;
2561 node_ptr.node_state = node_state_msg->state;
2562 node_ptr.reason = node_state_msg->reason;
2563 node_ptr.reason_time = node_state_msg->event_time;
2564 node_ptr.reason_uid = node_state_msg->reason_uid;
2565
2566 if (!node_ptr.tres_str)
2567 node_state_msg->new_state = DBD_NODE_STATE_UP;
2568
2569 if (node_state_msg->new_state == DBD_NODE_STATE_UP) {
2570 debug2("DBD_NODE_STATE_UP: NODE:%s REASON:%s TIME:%ld",
2571 node_state_msg->hostlist,
2572 node_state_msg->reason,
2573 (long)node_state_msg->event_time);
2574
2575 /* clusteracct_storage_g_node_up can change the reason
2576 * field so copy it to avoid memory issues.
2577 */
2578 node_ptr.reason = xstrdup(node_state_msg->reason);
2579 rc = clusteracct_storage_g_node_up(
2580 slurmdbd_conn->db_conn,
2581 &node_ptr,
2582 node_state_msg->event_time);
2583 xfree(node_ptr.reason);
2584 } else {
2585 debug2("DBD_NODE_STATE_DOWN: NODE:%s STATE:%s REASON:%s UID:%u TIME:%ld",
2586 node_state_msg->hostlist,
2587 node_state_string(node_state_msg->state),
2588 node_state_msg->reason,
2589 node_ptr.reason_uid,
2590 (long)node_state_msg->event_time);
2591 rc = clusteracct_storage_g_node_down(
2592 slurmdbd_conn->db_conn,
2593 &node_ptr,
2594 node_state_msg->event_time,
2595 node_state_msg->reason, node_ptr.reason_uid);
2596 }
2597
2598 end_it:
2599 *out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
2600 rc, comment, DBD_NODE_STATE);
2601 return SLURM_SUCCESS;
2602 }
2603
_process_job_start(slurmdbd_conn_t * slurmdbd_conn,dbd_job_start_msg_t * job_start_msg,dbd_id_rc_msg_t * id_rc_msg)2604 static void _process_job_start(slurmdbd_conn_t *slurmdbd_conn,
2605 dbd_job_start_msg_t *job_start_msg,
2606 dbd_id_rc_msg_t *id_rc_msg)
2607 {
2608 job_record_t job, *job_ptr;
2609 struct job_details details;
2610 job_array_struct_t array_recs;
2611
2612 memset(&job, 0, sizeof(job_record_t));
2613 memset(&details, 0, sizeof(struct job_details));
2614 memset(&array_recs, 0, sizeof(job_array_struct_t));
2615 memset(id_rc_msg, 0, sizeof(dbd_id_rc_msg_t));
2616
2617 job.total_nodes = job_start_msg->alloc_nodes;
2618 job.account = _replace_double_quotes(job_start_msg->account);
2619 job.array_job_id = job_start_msg->array_job_id;
2620 job.array_task_id = job_start_msg->array_task_id;
2621 array_recs.task_id_str = job_start_msg->array_task_str;
2622 array_recs.max_run_tasks = job_start_msg->array_max_tasks;
2623 array_recs.task_cnt = job_start_msg->array_task_pending;
2624 job.assoc_id = job_start_msg->assoc_id;
2625 if (job_start_msg->db_index != NO_VAL64)
2626 job.db_index = job_start_msg->db_index;
2627 details.begin_time = job_start_msg->eligible_time;
2628 job.user_id = job_start_msg->uid;
2629 job.group_id = job_start_msg->gid;
2630 job.het_job_id = job_start_msg->het_job_id;
2631 job.het_job_offset = job_start_msg->het_job_offset;
2632 job.job_id = job_start_msg->job_id;
2633 job.job_state = job_start_msg->job_state;
2634 job.mcs_label = _replace_double_quotes(job_start_msg->mcs_label);
2635 job.name = _replace_double_quotes(job_start_msg->name);
2636 job.nodes = job_start_msg->nodes;
2637 job.network = job_start_msg->node_inx;
2638 job.partition = job_start_msg->partition;
2639 details.min_cpus = job_start_msg->req_cpus;
2640 details.pn_min_memory = job_start_msg->req_mem;
2641 job.qos_id = job_start_msg->qos_id;
2642 job.resv_id = job_start_msg->resv_id;
2643 job.priority = job_start_msg->priority;
2644 job.start_protocol_ver = slurmdbd_conn->conn->version;
2645 job.start_time = job_start_msg->start_time;
2646 job.time_limit = job_start_msg->timelimit;
2647 job.tres_alloc_str = job_start_msg->tres_alloc_str;
2648 job.tres_req_str = job_start_msg->tres_req_str;
2649 job.gres_alloc = job_start_msg->gres_alloc;
2650 job.gres_req = job_start_msg->gres_req;
2651 job.gres_used = job_start_msg->gres_used;
2652 job.wckey = _replace_double_quotes(job_start_msg->wckey);
2653 details.work_dir = _replace_double_quotes(job_start_msg->work_dir);
2654 details.submit_time = job_start_msg->submit_time;
2655 job.db_flags = job_start_msg->db_flags;
2656 details.features = _replace_double_quotes(job_start_msg->constraints);
2657 job.state_reason_prev_db = job_start_msg->state_reason_prev;
2658
2659 job.array_recs = &array_recs;
2660 job.details = &details;
2661 job_ptr = &job;
2662
2663 if (job.job_state & JOB_RESIZING) {
2664 job.resize_time = job_start_msg->eligible_time;
2665 debug2("DBD_JOB_START: RESIZE CALL ID:%u NAME:%s INX:%"PRIu64,
2666 job_start_msg->job_id, job_start_msg->name,
2667 job.db_index);
2668 } else if (job.start_time && !IS_JOB_PENDING(job_ptr)) {
2669 debug2("DBD_JOB_START: START CALL ID:%u NAME:%s INX:%"PRIu64,
2670 job_start_msg->job_id, job_start_msg->name,
2671 job.db_index);
2672 } else {
2673 debug2("DBD_JOB_START: ELIGIBLE CALL ID:%u NAME:%s",
2674 job_start_msg->job_id, job_start_msg->name);
2675 }
2676 id_rc_msg->return_code = jobacct_storage_g_job_start(
2677 slurmdbd_conn->db_conn, &job);
2678 id_rc_msg->job_id = job.job_id;
2679 id_rc_msg->db_index = job.db_index;
2680
2681 /* just in case job.wckey was set because we didn't send one */
2682 if (!job_start_msg->wckey)
2683 xfree(job.wckey);
2684
2685 if (!slurmdbd_conn->conn->rem_port) {
2686 debug3("DBD_JOB_START: cluster not registered");
2687 slurmdbd_conn->conn->rem_port =
2688 clusteracct_storage_g_register_disconn_ctld(
2689 slurmdbd_conn->db_conn,
2690 slurmdbd_conn->conn->rem_host);
2691
2692 _add_registered_cluster(slurmdbd_conn);
2693 }
2694 }
2695
_reconfig(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)2696 static int _reconfig(slurmdbd_conn_t *slurmdbd_conn,
2697 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
2698 {
2699 int rc = SLURM_SUCCESS;
2700 char *comment = NULL;
2701
2702 if (!_validate_super_user(*uid, slurmdbd_conn)) {
2703 comment = "Your user doesn't have privilege to perform this action";
2704 error("CONN:%u %s", slurmdbd_conn->conn->fd, comment);
2705 *out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
2706 ESLURM_ACCESS_DENIED,
2707 comment,
2708 DBD_MODIFY_WCKEYS);
2709
2710 return ESLURM_ACCESS_DENIED;
2711 }
2712
2713 info("Reconfigure request received");
2714 reconfig();
2715
2716 *out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
2717 rc, comment, DBD_RECONFIG);
2718 return rc;
2719
2720 }
2721
_register_ctld(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)2722 static int _register_ctld(slurmdbd_conn_t *slurmdbd_conn,
2723 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
2724 {
2725 dbd_register_ctld_msg_t *register_ctld_msg = msg->data;
2726 int rc = SLURM_SUCCESS;
2727 char *comment = NULL;
2728 slurmdb_cluster_cond_t cluster_q;
2729 slurmdb_cluster_rec_t cluster;
2730 dbd_list_msg_t list_msg = { NULL };
2731 List cluster_list;
2732
2733 if (!_validate_slurm_user(*uid)) {
2734 comment = "DBD_REGISTER_CTLD message from invalid uid";
2735 error("CONN:%u %s %u",
2736 slurmdbd_conn->conn->fd, comment, *uid);
2737 rc = ESLURM_ACCESS_DENIED;
2738 goto end_it;
2739 }
2740
2741 debug2("DBD_REGISTER_CTLD: called for %s(%u)",
2742 slurmdbd_conn->conn->cluster_name, register_ctld_msg->port);
2743
2744 /* Just to make sure we don't allow a NULL cluster name to attempt
2745 to connect. This should never happen, but here just for
2746 sanity check.
2747 */
2748 if (!slurmdbd_conn->conn->cluster_name) {
2749 comment = "Must have a cluster name to register it";
2750 error("CONN:%u %s", slurmdbd_conn->conn->fd, comment);
2751 rc = ESLURM_BAD_NAME;
2752 goto end_it;
2753 }
2754
2755 debug2("slurmctld at ip:%s, port:%d",
2756 slurmdbd_conn->conn->rem_host, register_ctld_msg->port);
2757
2758 slurmdb_init_cluster_cond(&cluster_q, 0);
2759 slurmdb_init_cluster_rec(&cluster, 0);
2760
2761 cluster_q.cluster_list = list_create(NULL);
2762 list_append(cluster_q.cluster_list, slurmdbd_conn->conn->cluster_name);
2763 cluster.control_host = slurmdbd_conn->conn->rem_host;
2764 cluster.control_port = register_ctld_msg->port;
2765 cluster.dimensions = register_ctld_msg->dimensions;
2766 cluster.flags = register_ctld_msg->flags;
2767 cluster.plugin_id_select = register_ctld_msg->plugin_id_select;
2768 cluster.rpc_version = slurmdbd_conn->conn->version;
2769
2770 cluster_list = acct_storage_g_get_clusters(slurmdbd_conn->db_conn, *uid,
2771 &cluster_q);
2772 if (!cluster_list || errno) {
2773 comment = slurm_strerror(errno);
2774 rc = errno;
2775 } else if (!list_count(cluster_list)) {
2776 slurmdb_assoc_rec_t root_assoc;
2777 List add_list = list_create(NULL);
2778 list_append(add_list, &cluster);
2779
2780 slurmdb_init_assoc_rec(&root_assoc, 0);
2781 cluster.root_assoc = &root_assoc;
2782 cluster.name = slurmdbd_conn->conn->cluster_name;
2783 rc = acct_storage_g_add_clusters(slurmdbd_conn->db_conn, *uid,
2784 add_list);
2785 if (rc == ESLURM_ACCESS_DENIED)
2786 comment = "Your user doesn't have privilege to perform this action";
2787 else if (rc != SLURM_SUCCESS)
2788 comment = "Failed to add/register cluster.";
2789 slurmdb_free_assoc_rec_members(&root_assoc);
2790 FREE_NULL_LIST(add_list);
2791 } else if ((cluster.flags != NO_VAL) &&
2792 (cluster.flags & CLUSTER_FLAG_EXT) &&
2793 !(((slurmdb_cluster_rec_t *)list_peek(cluster_list))->flags &
2794 CLUSTER_FLAG_EXT)) {
2795 comment = "Can't register to non-external cluster";
2796 rc = ESLURM_ACCESS_DENIED;
2797 }
2798 FREE_NULL_LIST(cluster_list);
2799 if (rc)
2800 goto end_it;
2801
2802 list_msg.my_list = acct_storage_g_modify_clusters(
2803 slurmdbd_conn->db_conn, *uid, &cluster_q, &cluster);
2804 if (errno == EFAULT) {
2805 comment = "Request to register was incomplete";
2806 rc = SLURM_ERROR;
2807 } else if (errno == ESLURM_ACCESS_DENIED) {
2808 comment = "Your user doesn't have privilege to perform this action";
2809 rc = ESLURM_ACCESS_DENIED;
2810 } else if (errno == ESLURM_DB_CONNECTION) {
2811 comment = slurm_strerror(errno);
2812 rc = errno;
2813 } else if (!list_msg.my_list || !list_count(list_msg.my_list)) {
2814 comment = "This cluster hasn't been added to accounting yet";
2815 rc = SLURM_ERROR;
2816 }
2817
2818 FREE_NULL_LIST(list_msg.my_list);
2819 FREE_NULL_LIST(cluster_q.cluster_list);
2820
2821 end_it:
2822
2823 if (rc == SLURM_SUCCESS) {
2824 slurmdbd_conn->conn->rem_port = register_ctld_msg->port;
2825
2826 _add_registered_cluster(slurmdbd_conn);
2827 }
2828
2829 *out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
2830 rc, comment, DBD_REGISTER_CTLD);
2831 return rc;
2832 }
2833
_remove_accounts(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)2834 static int _remove_accounts(slurmdbd_conn_t *slurmdbd_conn,
2835 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
2836 {
2837 int rc = SLURM_SUCCESS;
2838 dbd_cond_msg_t *get_msg = msg->data;
2839 dbd_list_msg_t list_msg = { NULL };
2840 char *comment = NULL;
2841
2842 debug2("DBD_REMOVE_ACCOUNTS: called");
2843
2844 if (!(list_msg.my_list = acct_storage_g_remove_accounts(
2845 slurmdbd_conn->db_conn, *uid, get_msg->cond))) {
2846 if (errno == ESLURM_ACCESS_DENIED) {
2847 comment = "Your user doesn't have privilege to perform this action";
2848 rc = ESLURM_ACCESS_DENIED;
2849 } else if (errno == SLURM_ERROR) {
2850 comment = "Something was wrong with your query";
2851 rc = SLURM_ERROR;
2852 } else if (errno == SLURM_NO_CHANGE_IN_DATA) {
2853 comment = "Request didn't affect anything";
2854 rc = SLURM_SUCCESS;
2855 } else if (errno == ESLURM_DB_CONNECTION) {
2856 comment = slurm_strerror(errno);
2857 rc = errno;
2858 } else {
2859 rc = errno;
2860 if (!(comment = slurm_strerror(errno)))
2861 comment = "Unknown issue";
2862 }
2863 error("CONN:%u %s", slurmdbd_conn->conn->fd, comment);
2864 *out_buffer = slurm_persist_make_rc_msg(
2865 slurmdbd_conn->conn, rc, comment, DBD_REMOVE_ACCOUNTS);
2866 return rc;
2867 }
2868 list_msg.return_code = errno;
2869
2870 *out_buffer = init_buf(1024);
2871 pack16((uint16_t) DBD_GOT_LIST, *out_buffer);
2872 slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->conn->version,
2873 DBD_GOT_LIST, *out_buffer);
2874 FREE_NULL_LIST(list_msg.my_list);
2875
2876 return rc;
2877 }
2878
_remove_account_coords(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)2879 static int _remove_account_coords(slurmdbd_conn_t *slurmdbd_conn,
2880 persist_msg_t *msg, Buf *out_buffer,
2881 uint32_t *uid)
2882 {
2883 int rc = SLURM_SUCCESS;
2884 dbd_acct_coord_msg_t *get_msg = msg->data;
2885 dbd_list_msg_t list_msg = { NULL };
2886 char *comment = NULL;
2887
2888 debug2("DBD_REMOVE_ACCOUNT_COORDS: called");
2889
2890 /* All authentication needs to be done inside the plugin since we are
2891 * unable to know what accounts this request is talking about
2892 * until we process it through the database.
2893 */
2894
2895 if (!(list_msg.my_list = acct_storage_g_remove_coord(
2896 slurmdbd_conn->db_conn, *uid, get_msg->acct_list,
2897 get_msg->cond))) {
2898 if (errno == ESLURM_ACCESS_DENIED) {
2899 comment = "Your user doesn't have privilege to perform this action";
2900 rc = ESLURM_ACCESS_DENIED;
2901 } else if (errno == SLURM_ERROR) {
2902 comment = "Something was wrong with your query";
2903 rc = SLURM_ERROR;
2904 } else if (errno == SLURM_NO_CHANGE_IN_DATA) {
2905 comment = "Request didn't affect anything";
2906 rc = SLURM_SUCCESS;
2907 } else if (errno == ESLURM_DB_CONNECTION) {
2908 comment = slurm_strerror(errno);
2909 rc = errno;
2910 } else {
2911 rc = errno;
2912 if (!(comment = slurm_strerror(errno)))
2913 comment = "Unknown issue";
2914 }
2915 error("CONN:%u %s", slurmdbd_conn->conn->fd, comment);
2916 *out_buffer = slurm_persist_make_rc_msg(
2917 slurmdbd_conn->conn, rc, comment,
2918 DBD_REMOVE_ACCOUNT_COORDS);
2919 return rc;
2920 }
2921 list_msg.return_code = SLURM_SUCCESS;
2922
2923 *out_buffer = init_buf(1024);
2924 pack16((uint16_t) DBD_GOT_LIST, *out_buffer);
2925 slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->conn->version,
2926 DBD_GOT_LIST, *out_buffer);
2927 FREE_NULL_LIST(list_msg.my_list);
2928
2929 return rc;
2930 }
2931
_remove_assocs(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)2932 static int _remove_assocs(slurmdbd_conn_t *slurmdbd_conn,
2933 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
2934 {
2935 int rc = SLURM_SUCCESS;
2936 dbd_cond_msg_t *get_msg = msg->data;
2937 dbd_list_msg_t list_msg = { NULL };
2938 char *comment = NULL;
2939
2940 debug2("DBD_REMOVE_ASSOCS: called");
2941
2942 /* All authentication needs to be done inside the plugin since we are
2943 * unable to know what accounts this request is talking about
2944 * until we process it through the database.
2945 */
2946
2947 if (!(list_msg.my_list = acct_storage_g_remove_assocs(
2948 slurmdbd_conn->db_conn, *uid, get_msg->cond))) {
2949 if (errno == ESLURM_ACCESS_DENIED) {
2950 comment = "Your user doesn't have privilege to perform this action";
2951 rc = ESLURM_ACCESS_DENIED;
2952 } else if (errno == SLURM_ERROR) {
2953 comment = "Something was wrong with your query";
2954 rc = SLURM_ERROR;
2955 } else if (errno == SLURM_NO_CHANGE_IN_DATA) {
2956 comment = "Request didn't affect anything";
2957 rc = SLURM_SUCCESS;
2958 } else if (errno == ESLURM_DB_CONNECTION) {
2959 comment = slurm_strerror(errno);
2960 rc = errno;
2961 } else {
2962 rc = errno;
2963 if (!(comment = slurm_strerror(errno)))
2964 comment = "Unknown issue";
2965 }
2966 error("CONN:%u %s", slurmdbd_conn->conn->fd, comment);
2967 *out_buffer = slurm_persist_make_rc_msg(
2968 slurmdbd_conn->conn, rc, comment, DBD_REMOVE_ASSOCS);
2969 return rc;
2970 }
2971 list_msg.return_code = errno;
2972
2973 *out_buffer = init_buf(1024);
2974 pack16((uint16_t) DBD_GOT_LIST, *out_buffer);
2975 slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->conn->version,
2976 DBD_GOT_LIST, *out_buffer);
2977 FREE_NULL_LIST(list_msg.my_list);
2978
2979 return rc;
2980
2981 }
2982
_remove_clusters(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)2983 static int _remove_clusters(slurmdbd_conn_t *slurmdbd_conn,
2984 persist_msg_t *msg, Buf *out_buffer,
2985 uint32_t *uid)
2986 {
2987 int rc = SLURM_SUCCESS;
2988 dbd_cond_msg_t *get_msg = msg->data;
2989 dbd_list_msg_t list_msg = { NULL };
2990 char *comment = NULL;
2991
2992 debug2("DBD_REMOVE_CLUSTERS: called");
2993
2994 if (!(list_msg.my_list = acct_storage_g_remove_clusters(
2995 slurmdbd_conn->db_conn, *uid, get_msg->cond))) {
2996 if (errno == ESLURM_ACCESS_DENIED) {
2997 comment = "Your user doesn't have privilege to perform this action";
2998 rc = ESLURM_ACCESS_DENIED;
2999 } else if (errno == SLURM_ERROR) {
3000 comment = "Something was wrong with your query";
3001 rc = SLURM_ERROR;
3002 } else if (errno == SLURM_NO_CHANGE_IN_DATA) {
3003 comment = "Request didn't affect anything";
3004 rc = SLURM_SUCCESS;
3005 } else if (errno == ESLURM_DB_CONNECTION) {
3006 comment = slurm_strerror(errno);
3007 rc = errno;
3008 } else {
3009 rc = errno;
3010 if (!(comment = slurm_strerror(errno)))
3011 comment = "Unknown issue";
3012 }
3013 error("CONN:%u %s", slurmdbd_conn->conn->fd, comment);
3014 *out_buffer = slurm_persist_make_rc_msg(
3015 slurmdbd_conn->conn, rc, comment, DBD_REMOVE_CLUSTERS);
3016 return rc;
3017 }
3018 list_msg.return_code = errno;
3019
3020 *out_buffer = init_buf(1024);
3021 pack16((uint16_t) DBD_GOT_LIST, *out_buffer);
3022 slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->conn->version,
3023 DBD_GOT_LIST, *out_buffer);
3024 FREE_NULL_LIST(list_msg.my_list);
3025
3026 return rc;
3027 }
3028
_remove_federations(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)3029 static int _remove_federations(slurmdbd_conn_t *slurmdbd_conn,
3030 persist_msg_t *msg,
3031 Buf *out_buffer, uint32_t *uid)
3032 {
3033 int rc = SLURM_SUCCESS;
3034 dbd_cond_msg_t *get_msg = msg->data;
3035 dbd_list_msg_t list_msg = { NULL };
3036 char *comment = NULL;
3037
3038 debug2("DBD_REMOVE_FEDERATIONS: called");
3039
3040 if (!(list_msg.my_list = acct_storage_g_remove_federations(
3041 slurmdbd_conn->db_conn, *uid, get_msg->cond))) {
3042 if (errno == ESLURM_ACCESS_DENIED) {
3043 comment = "Your user doesn't have privilege to perform "
3044 "this action";
3045 rc = ESLURM_ACCESS_DENIED;
3046 } else if (errno == SLURM_ERROR) {
3047 comment = "Something was wrong with your query";
3048 rc = SLURM_ERROR;
3049 } else if (errno == SLURM_NO_CHANGE_IN_DATA) {
3050 comment = "Request didn't affect anything";
3051 rc = SLURM_SUCCESS;
3052 } else if (errno == ESLURM_DB_CONNECTION) {
3053 comment = slurm_strerror(errno);
3054 rc = errno;
3055 } else {
3056 rc = errno;
3057 if (!(comment = slurm_strerror(errno)))
3058 comment = "Unknown issue";
3059 }
3060 error("CONN:%u %s", slurmdbd_conn->conn->fd, comment);
3061 *out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
3062 rc, comment,
3063 DBD_REMOVE_FEDERATIONS);
3064 return rc;
3065 }
3066 list_msg.return_code = errno;
3067
3068 *out_buffer = init_buf(1024);
3069 pack16((uint16_t) DBD_GOT_LIST, *out_buffer);
3070 slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->conn->version,
3071 DBD_GOT_LIST, *out_buffer);
3072 FREE_NULL_LIST(list_msg.my_list);
3073
3074 return rc;
3075 }
3076
_remove_qos(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)3077 static int _remove_qos(slurmdbd_conn_t *slurmdbd_conn,
3078 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
3079 {
3080 int rc = SLURM_SUCCESS;
3081 dbd_cond_msg_t *get_msg = msg->data;
3082 dbd_list_msg_t list_msg = { NULL };
3083 char *comment = NULL;
3084
3085 debug2("DBD_REMOVE_QOS: called");
3086
3087 if (!(list_msg.my_list = acct_storage_g_remove_qos(
3088 slurmdbd_conn->db_conn, *uid, get_msg->cond))) {
3089 if (errno == ESLURM_ACCESS_DENIED) {
3090 comment = "Your user doesn't have privilege to perform this action";
3091 rc = ESLURM_ACCESS_DENIED;
3092 } else if (errno == SLURM_ERROR) {
3093 comment = "Something was wrong with your query";
3094 rc = SLURM_ERROR;
3095 } else if (errno == SLURM_NO_CHANGE_IN_DATA) {
3096 comment = "Request didn't affect anything";
3097 rc = SLURM_SUCCESS;
3098 } else if (errno == ESLURM_DB_CONNECTION) {
3099 comment = slurm_strerror(errno);
3100 rc = errno;
3101 } else {
3102 rc = errno;
3103 if (!(comment = slurm_strerror(errno)))
3104 comment = "Unknown issue";
3105 }
3106 error("CONN:%u %s", slurmdbd_conn->conn->fd, comment);
3107 *out_buffer = slurm_persist_make_rc_msg(
3108 slurmdbd_conn->conn, rc, comment, DBD_REMOVE_QOS);
3109 return rc;
3110 }
3111 list_msg.return_code = SLURM_SUCCESS;
3112
3113 *out_buffer = init_buf(1024);
3114 pack16((uint16_t) DBD_GOT_LIST, *out_buffer);
3115 slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->conn->version,
3116 DBD_GOT_LIST, *out_buffer);
3117 FREE_NULL_LIST(list_msg.my_list);
3118
3119 return rc;
3120 }
3121
_remove_res(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)3122 static int _remove_res(slurmdbd_conn_t *slurmdbd_conn,
3123 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
3124 {
3125 int rc = SLURM_SUCCESS;
3126 dbd_cond_msg_t *get_msg = msg->data;
3127 dbd_list_msg_t list_msg = { NULL };
3128 char *comment = NULL;
3129
3130 debug2("DBD_REMOVE_RES: called");
3131
3132 if (!(list_msg.my_list = acct_storage_g_remove_res(
3133 slurmdbd_conn->db_conn, *uid, get_msg->cond))) {
3134 if (errno == ESLURM_ACCESS_DENIED) {
3135 comment = "Your user doesn't have privilege to perform "
3136 "this action";
3137 rc = ESLURM_ACCESS_DENIED;
3138 } else if (errno == SLURM_ERROR) {
3139 comment = "Something was wrong with your query";
3140 rc = SLURM_ERROR;
3141 } else if (errno == SLURM_NO_CHANGE_IN_DATA) {
3142 comment = "Request didn't affect anything";
3143 rc = SLURM_SUCCESS;
3144 } else if (errno == ESLURM_DB_CONNECTION) {
3145 comment = slurm_strerror(errno);
3146 rc = errno;
3147 } else {
3148 rc = errno;
3149 if (!(comment = slurm_strerror(errno)))
3150 comment = "Unknown issue";
3151 }
3152 error("CONN:%u %s", slurmdbd_conn->conn->fd, comment);
3153 *out_buffer = slurm_persist_make_rc_msg(
3154 slurmdbd_conn->conn, rc, comment, DBD_REMOVE_RES);
3155 return rc;
3156 }
3157 list_msg.return_code = errno;
3158 *out_buffer = init_buf(1024);
3159 pack16((uint16_t) DBD_GOT_LIST, *out_buffer);
3160 slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->conn->version,
3161 DBD_GOT_LIST, *out_buffer);
3162 FREE_NULL_LIST(list_msg.my_list);
3163
3164 return rc;
3165 }
3166
_remove_users(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)3167 static int _remove_users(slurmdbd_conn_t *slurmdbd_conn,
3168 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
3169 {
3170 int rc = SLURM_SUCCESS;
3171 dbd_cond_msg_t *get_msg = msg->data;
3172 dbd_list_msg_t list_msg = { NULL };
3173 char *comment = NULL;
3174
3175 debug2("DBD_REMOVE_USERS: called");
3176
3177 if (!(list_msg.my_list = acct_storage_g_remove_users(
3178 slurmdbd_conn->db_conn, *uid, get_msg->cond))) {
3179 if (errno == ESLURM_ACCESS_DENIED) {
3180 comment = "Your user doesn't have privilege to perform this action";
3181 rc = ESLURM_ACCESS_DENIED;
3182 } else if (errno == SLURM_ERROR) {
3183 comment = "Something was wrong with your query";
3184 rc = SLURM_ERROR;
3185 } else if (errno == SLURM_NO_CHANGE_IN_DATA) {
3186 comment = "Request didn't affect anything";
3187 rc = SLURM_SUCCESS;
3188 } else if (errno == ESLURM_DB_CONNECTION) {
3189 comment = slurm_strerror(errno);
3190 rc = errno;
3191 } else {
3192 rc = errno;
3193 if (!(comment = slurm_strerror(errno)))
3194 comment = "Unknown issue";
3195 }
3196 error("CONN:%u %s", slurmdbd_conn->conn->fd, comment);
3197 *out_buffer = slurm_persist_make_rc_msg(
3198 slurmdbd_conn->conn, rc, comment, DBD_REMOVE_USERS);
3199 return rc;
3200 }
3201 list_msg.return_code = errno;
3202
3203 *out_buffer = init_buf(1024);
3204 pack16((uint16_t) DBD_GOT_LIST, *out_buffer);
3205 slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->conn->version,
3206 DBD_GOT_LIST, *out_buffer);
3207 FREE_NULL_LIST(list_msg.my_list);
3208
3209 return rc;
3210 }
3211
_remove_wckeys(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)3212 static int _remove_wckeys(slurmdbd_conn_t *slurmdbd_conn,
3213 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
3214 {
3215 int rc = SLURM_SUCCESS;
3216 dbd_cond_msg_t *get_msg = msg->data;
3217 dbd_list_msg_t list_msg = { NULL };
3218 char *comment = NULL;
3219
3220 debug2("DBD_REMOVE_WCKEYS: called");
3221
3222 if (!(list_msg.my_list = acct_storage_g_remove_wckeys(
3223 slurmdbd_conn->db_conn, *uid, get_msg->cond))) {
3224 if (errno == ESLURM_ACCESS_DENIED) {
3225 comment = "Your user doesn't have privilege to perform this action";
3226 rc = ESLURM_ACCESS_DENIED;
3227 } else if (errno == SLURM_ERROR) {
3228 comment = "Something was wrong with your query";
3229 rc = SLURM_ERROR;
3230 } else if (errno == SLURM_NO_CHANGE_IN_DATA) {
3231 comment = "Request didn't affect anything";
3232 rc = SLURM_SUCCESS;
3233 } else if (errno == ESLURM_DB_CONNECTION) {
3234 comment = slurm_strerror(errno);
3235 rc = errno;
3236 } else {
3237 rc = errno;
3238 if (!(comment = slurm_strerror(errno)))
3239 comment = "Unknown issue";
3240 }
3241 error("CONN:%u %s", slurmdbd_conn->conn->fd, comment);
3242 *out_buffer = slurm_persist_make_rc_msg(
3243 slurmdbd_conn->conn, rc, comment, DBD_REMOVE_WCKEYS);
3244 return rc;
3245 }
3246 list_msg.return_code = SLURM_SUCCESS;
3247
3248 *out_buffer = init_buf(1024);
3249 pack16((uint16_t) DBD_GOT_LIST, *out_buffer);
3250 slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->conn->version,
3251 DBD_GOT_LIST, *out_buffer);
3252 FREE_NULL_LIST(list_msg.my_list);
3253
3254 return rc;
3255 }
3256
_remove_reservation(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)3257 static int _remove_reservation(slurmdbd_conn_t *slurmdbd_conn,
3258 persist_msg_t *msg, Buf *out_buffer,
3259 uint32_t *uid)
3260 {
3261 int rc = SLURM_SUCCESS;
3262 dbd_rec_msg_t *rec_msg = msg->data;
3263 char *comment = NULL;
3264
3265 if (!_validate_slurm_user(*uid)) {
3266 comment = "DBD_REMOVE_RESV message from invalid uid";
3267 error("DBD_REMOVE_RESV message from invalid uid %u", *uid);
3268 rc = ESLURM_ACCESS_DENIED;
3269 goto end_it;
3270 }
3271
3272 debug2("DBD_REMOVE_RESV: called");
3273
3274 rc = acct_storage_g_remove_reservation(slurmdbd_conn->db_conn,
3275 rec_msg->rec);
3276
3277 end_it:
3278 *out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
3279 rc, comment, DBD_REMOVE_RESV);
3280 return rc;
3281 }
3282
_roll_usage(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)3283 static int _roll_usage(slurmdbd_conn_t *slurmdbd_conn,
3284 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
3285 {
3286 dbd_roll_usage_msg_t *get_msg = msg->data;
3287 int rc = SLURM_SUCCESS;
3288 char *comment = NULL;
3289 List rollup_stats_list = NULL;
3290 DEF_TIMERS;
3291
3292 info("DBD_ROLL_USAGE: called");
3293
3294 if (!_validate_operator(*uid, slurmdbd_conn)) {
3295 comment = "Your user doesn't have privilege to perform this action";
3296 error("CONN:%u %s", slurmdbd_conn->conn->fd, comment);
3297 rc = ESLURM_ACCESS_DENIED;
3298 goto end_it;
3299 }
3300
3301 START_TIMER;
3302 rc = acct_storage_g_roll_usage(slurmdbd_conn->db_conn,
3303 get_msg->start, get_msg->end,
3304 get_msg->archive_data,
3305 &rollup_stats_list);
3306 END_TIMER;
3307 handle_rollup_stats(rollup_stats_list, DELTA_TIMER, 1);
3308 FREE_NULL_LIST(rollup_stats_list);
3309
3310 end_it:
3311 *out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
3312 rc, comment, DBD_ROLL_USAGE);
3313 return rc;
3314 }
3315
_send_mult_job_start(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)3316 static int _send_mult_job_start(slurmdbd_conn_t *slurmdbd_conn,
3317 persist_msg_t *msg, Buf *out_buffer,
3318 uint32_t *uid)
3319 {
3320 dbd_list_msg_t *get_msg = msg->data;
3321 dbd_list_msg_t list_msg = { NULL };
3322 char *comment = NULL;
3323 ListIterator itr = NULL;
3324 dbd_job_start_msg_t *job_start_msg;
3325 dbd_id_rc_msg_t *id_rc_msg;
3326 /* DEF_TIMERS; */
3327
3328 if (!_validate_slurm_user(*uid)) {
3329 comment = "DBD_SEND_MULT_JOB_START message from invalid uid";
3330 error("%s %u", comment, *uid);
3331 *out_buffer = slurm_persist_make_rc_msg(
3332 slurmdbd_conn->conn,
3333 ESLURM_ACCESS_DENIED, comment,
3334 DBD_SEND_MULT_JOB_START);
3335 return SLURM_ERROR;
3336 }
3337
3338 list_msg.my_list = list_create(slurmdbd_free_id_rc_msg);
3339 /* START_TIMER; */
3340 itr = list_iterator_create(get_msg->my_list);
3341 while ((job_start_msg = list_next(itr))) {
3342 id_rc_msg = xmalloc(sizeof(dbd_id_rc_msg_t));
3343 list_append(list_msg.my_list, id_rc_msg);
3344
3345 _process_job_start(slurmdbd_conn, job_start_msg, id_rc_msg);
3346 }
3347 list_iterator_destroy(itr);
3348 /* END_TIMER; */
3349 /* info("%d multi job took %s", */
3350 /* list_count(get_msg->my_list), TIME_STR); */
3351
3352 *out_buffer = init_buf(1024);
3353 pack16((uint16_t) DBD_GOT_MULT_JOB_START, *out_buffer);
3354 slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->conn->version,
3355 DBD_GOT_MULT_JOB_START, *out_buffer);
3356 FREE_NULL_LIST(list_msg.my_list);
3357
3358 return SLURM_SUCCESS;
3359 }
3360
_send_mult_msg(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)3361 static int _send_mult_msg(slurmdbd_conn_t *slurmdbd_conn,
3362 persist_msg_t *msg, Buf *out_buffer,
3363 uint32_t *uid)
3364 {
3365 dbd_list_msg_t *get_msg = msg->data;
3366 dbd_list_msg_t list_msg = { NULL };
3367 char *comment = NULL;
3368 ListIterator itr = NULL;
3369 Buf req_buf = NULL, ret_buf = NULL;
3370 int rc = SLURM_SUCCESS;
3371 /* DEF_TIMERS; */
3372
3373 if (!_validate_slurm_user(*uid)) {
3374 comment = "DBD_SEND_MULT_MSG message from invalid uid";
3375 error("%s %u", comment, *uid);
3376 *out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
3377 ESLURM_ACCESS_DENIED,
3378 comment,
3379 DBD_SEND_MULT_MSG);
3380 return SLURM_ERROR;
3381 }
3382
3383 list_msg.my_list = list_create(slurmdbd_free_buffer);
3384 /* START_TIMER; */
3385 itr = list_iterator_create(get_msg->my_list);
3386 while ((req_buf = list_next(itr))) {
3387 persist_msg_t sub_msg;
3388
3389 ret_buf = NULL;
3390
3391 rc = slurm_persist_conn_process_msg(
3392 slurmdbd_conn->conn, &sub_msg,
3393 get_buf_data(req_buf),
3394 size_buf(req_buf), &ret_buf, 0);
3395
3396 if (rc == SLURM_SUCCESS) {
3397 rc = proc_req(slurmdbd_conn, &sub_msg, &ret_buf, uid);
3398 slurmdbd_free_msg(&sub_msg);
3399 }
3400
3401 if (ret_buf)
3402 list_append(list_msg.my_list, ret_buf);
3403 if (rc != SLURM_SUCCESS)
3404 break;
3405 }
3406 list_iterator_destroy(itr);
3407 /* END_TIMER; */
3408 /* info("%d multi took %s", list_count(get_msg->my_list), TIME_STR); */
3409
3410 *out_buffer = init_buf(1024);
3411 pack16((uint16_t) DBD_GOT_MULT_MSG, *out_buffer);
3412 slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->conn->version,
3413 DBD_GOT_MULT_MSG, *out_buffer);
3414 FREE_NULL_LIST(list_msg.my_list);
3415
3416 return SLURM_SUCCESS;
3417 }
3418
_step_complete(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)3419 static int _step_complete(slurmdbd_conn_t *slurmdbd_conn,
3420 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
3421 {
3422 dbd_step_comp_msg_t *step_comp_msg = msg->data;
3423 step_record_t step;
3424 job_record_t job;
3425 struct job_details details;
3426 int rc = SLURM_SUCCESS;
3427 char *comment = NULL;
3428
3429 if (!_validate_slurm_user(*uid)) {
3430 comment = "DBD_STEP_COMPLETE message from invalid uid";
3431 error("%s %u", comment, *uid);
3432 rc = ESLURM_ACCESS_DENIED;
3433 goto end_it;
3434 }
3435
3436 debug2("DBD_STEP_COMPLETE: ID:%u.%u SUBMIT:%lu",
3437 step_comp_msg->job_id, step_comp_msg->step_id,
3438 (unsigned long) step_comp_msg->job_submit_time);
3439
3440 memset(&step, 0, sizeof(step_record_t));
3441 memset(&job, 0, sizeof(job_record_t));
3442 memset(&details, 0, sizeof(struct job_details));
3443
3444 job.assoc_id = step_comp_msg->assoc_id;
3445 if (step_comp_msg->db_index != NO_VAL64)
3446 job.db_index = step_comp_msg->db_index;
3447 job.end_time = step_comp_msg->end_time;
3448 step.exit_code = step_comp_msg->exit_code;
3449 step.jobacct = step_comp_msg->jobacct;
3450 job.job_id = step_comp_msg->job_id;
3451 step.requid = step_comp_msg->req_uid;
3452 job.start_protocol_ver = slurmdbd_conn->conn->version;
3453 job.start_time = step_comp_msg->start_time;
3454 job.tres_alloc_str = step_comp_msg->job_tres_alloc_str;
3455 step.state = step_comp_msg->state;
3456 step.step_id = step_comp_msg->step_id;
3457 details.submit_time = step_comp_msg->job_submit_time;
3458 details.num_tasks = step_comp_msg->total_tasks;
3459
3460 job.details = &details;
3461 step.job_ptr = &job;
3462
3463 rc = jobacct_storage_g_step_complete(slurmdbd_conn->db_conn, &step);
3464
3465 if (rc && errno == 740) /* meaning data is already there */
3466 rc = SLURM_SUCCESS;
3467 /* just in case this gets set we need to clear it */
3468 xfree(job.wckey);
3469
3470 if (!slurmdbd_conn->conn->rem_port) {
3471 debug3("DBD_STEP_COMPLETE: cluster not registered");
3472 slurmdbd_conn->conn->rem_port =
3473 clusteracct_storage_g_register_disconn_ctld(
3474 slurmdbd_conn->db_conn,
3475 slurmdbd_conn->conn->rem_host);
3476
3477 _add_registered_cluster(slurmdbd_conn);
3478 }
3479
3480 end_it:
3481 *out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
3482 rc, comment, DBD_STEP_COMPLETE);
3483 return rc;
3484 }
3485
_step_start(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)3486 static int _step_start(slurmdbd_conn_t *slurmdbd_conn,
3487 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
3488 {
3489 dbd_step_start_msg_t *step_start_msg = msg->data;
3490 step_record_t step;
3491 job_record_t job;
3492 struct job_details details;
3493 slurm_step_layout_t layout;
3494 int rc = SLURM_SUCCESS;
3495 char *comment = NULL;
3496
3497 if (!_validate_slurm_user(*uid)) {
3498 comment = "DBD_STEP_START message from invalid uid";
3499 error("%s %u", comment, *uid);
3500 rc = ESLURM_ACCESS_DENIED;
3501 goto end_it;
3502 }
3503
3504 debug2("DBD_STEP_START: ID:%u.%u NAME:%s SUBMIT:%lu",
3505 step_start_msg->job_id, step_start_msg->step_id,
3506 step_start_msg->name,
3507 (unsigned long) step_start_msg->job_submit_time);
3508
3509 memset(&step, 0, sizeof(step_record_t));
3510 memset(&job, 0, sizeof(job_record_t));
3511 memset(&details, 0, sizeof(struct job_details));
3512 memset(&layout, 0, sizeof(slurm_step_layout_t));
3513
3514 job.assoc_id = step_start_msg->assoc_id;
3515 if (step_start_msg->db_index != NO_VAL64)
3516 job.db_index = step_start_msg->db_index;
3517 job.job_id = step_start_msg->job_id;
3518 step.name = step_start_msg->name;
3519 job.nodes = step_start_msg->nodes;
3520 step.network = step_start_msg->node_inx;
3521 job.start_protocol_ver = slurmdbd_conn->conn->version;
3522 step.start_time = step_start_msg->start_time;
3523 details.submit_time = step_start_msg->job_submit_time;
3524 step.step_id = step_start_msg->step_id;
3525 details.num_tasks = step_start_msg->total_tasks;
3526 step.cpu_freq_min = step_start_msg->req_cpufreq_min;
3527 step.cpu_freq_max = step_start_msg->req_cpufreq_max;
3528 step.cpu_freq_gov = step_start_msg->req_cpufreq_gov;
3529 step.tres_alloc_str = step_start_msg->tres_alloc_str;
3530
3531 layout.node_cnt = step_start_msg->node_cnt;
3532 layout.task_dist = step_start_msg->task_dist;
3533
3534 job.details = &details;
3535 step.job_ptr = &job;
3536 step.step_layout = &layout;
3537
3538 rc = jobacct_storage_g_step_start(slurmdbd_conn->db_conn, &step);
3539
3540 if (rc && errno == 740) /* meaning data is already there */
3541 rc = SLURM_SUCCESS;
3542
3543 /* just in case this gets set we need to clear it */
3544 xfree(job.wckey);
3545
3546 if (!slurmdbd_conn->conn->rem_port) {
3547 debug3("DBD_STEP_START: cluster not registered");
3548 slurmdbd_conn->conn->rem_port =
3549 clusteracct_storage_g_register_disconn_ctld(
3550 slurmdbd_conn->db_conn,
3551 slurmdbd_conn->conn->rem_host);
3552
3553 _add_registered_cluster(slurmdbd_conn);
3554 }
3555
3556 end_it:
3557 *out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
3558 rc, comment, DBD_STEP_START);
3559 return rc;
3560 }
3561
_get_stats(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)3562 static int _get_stats(slurmdbd_conn_t *slurmdbd_conn,
3563 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
3564 {
3565 int rc = SLURM_SUCCESS;
3566 char *comment = NULL;
3567
3568 if (!_validate_super_user(*uid, slurmdbd_conn)) {
3569 comment = "Your user doesn't have privilege to perform this action";
3570 error("CONN:%u %s", slurmdbd_conn->conn->fd, comment);
3571 *out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
3572 ESLURM_ACCESS_DENIED,
3573 comment, DBD_GET_STATS);
3574
3575 return ESLURM_ACCESS_DENIED;
3576 }
3577
3578 debug2("Get stats request received from UID %u", *uid);
3579 *out_buffer = init_buf(32 * 1024);
3580 pack16((uint16_t) DBD_GOT_STATS, *out_buffer);
3581 slurm_mutex_lock(&rpc_mutex);
3582 slurmdb_pack_stats_msg(&rpc_stats, slurmdbd_conn->conn->version,
3583 *out_buffer);
3584 slurm_mutex_unlock(&rpc_mutex);
3585
3586 return rc;
3587 }
3588
_clear_stats(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)3589 static int _clear_stats(slurmdbd_conn_t *slurmdbd_conn,
3590 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
3591 {
3592 int rc = SLURM_SUCCESS;
3593 char *comment = NULL;
3594
3595 if (!_validate_super_user(*uid, slurmdbd_conn)) {
3596 comment = "Your user doesn't have privilege to perform this action";
3597 error("CONN:%u %s", slurmdbd_conn->conn->fd, comment);
3598 *out_buffer = slurm_persist_make_rc_msg(
3599 slurmdbd_conn->conn,
3600 ESLURM_ACCESS_DENIED,
3601 comment, DBD_CLEAR_STATS);
3602
3603 return ESLURM_ACCESS_DENIED;
3604 }
3605
3606 info("Clear stats request received from UID %u", *uid);
3607
3608 init_dbd_stats();
3609
3610 *out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
3611 rc, comment, DBD_CLEAR_STATS);
3612 return rc;
3613 }
3614
_shutdown(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)3615 static int _shutdown(slurmdbd_conn_t *slurmdbd_conn,
3616 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
3617 {
3618 int rc = SLURM_SUCCESS;
3619 char *comment = NULL;
3620
3621 if (!_validate_super_user(*uid, slurmdbd_conn)) {
3622 comment = "Your user doesn't have privilege to perform this action";
3623 error("CONN:%u %s", slurmdbd_conn->conn->fd, comment);
3624 *out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
3625 ESLURM_ACCESS_DENIED,
3626 comment, DBD_SHUTDOWN);
3627
3628 return ESLURM_ACCESS_DENIED;
3629 }
3630
3631 info("Shutdown request received from UID %u", *uid);
3632 pthread_kill(signal_handler_thread, SIGTERM);
3633
3634 *out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
3635 rc, comment, DBD_SHUTDOWN);
3636 return rc;
3637 }
3638