← Back to branch summary

~ubuntu-branches/ubuntu/vivid/slurm-llnl/vivid

« back to all changes in this revision

Viewing changes to src/plugins/accounting_storage/slurmdbd/accounting_storage_slurmdbd.c

  • Committer: Bazaar Package Importer
  • Author(s): Gennaro Oliva
  • Date: 2009-09-24 23:28:15 UTC
  • mfrom: (1.1.11 upstream) (3.2.4 sid)
  • Revision ID: james.westby@ubuntu.com-20090924232815-enh65jn32q1ebg07
Tags: 2.0.5-1
http://bugs.debian.org/541252
* New upstream release 
* Changed dependecy from lib-mysqlclient15 to lib-mysqlclient 
* Added Default-Start for runlevel 2 and 4 and $remote_fs requirement in
  init.d scripts (Closes: #541252)
* Postinst checks for wrong runlevels 2 and 4 links
* Upgraded to standard version 3.8.3
* Add lintian overrides for missing slurm-llnl-configurator.html in doc
  base registration
* modified postrm scripts to ignore pkill return value in order to avoid
  postrm failure when no slurm process is running
* Checking for slurmctld.pid before cancelling running and pending
  jobs during package removal 

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/plugins/accounting_storage/slurmdbd/accounting_storage_slurmdbd.c
7
7
 *  Written by Danny Auble <da@llnl.gov>
8
8
 *  
9
9
 *  This file is part of SLURM, a resource management program.
10
 
 *  For details, see <http://www.llnl.gov/linux/slurm/>.
 
10
 *  For details, see <https://computing.llnl.gov/linux/slurm/>.
 
11
 *  Please also read the included file: DISCLAIMER.
11
12
 *  
12
13
 *  SLURM is free software; you can redistribute it and/or modify it under
13
14
 *  the terms of the GNU General Public License as published by the Free
175
176
        dbd_list_msg_t get_msg;
176
177
        int rc, resp_code;
177
178
 
 
179
        memset(&get_msg, 0, sizeof(dbd_list_msg_t));
178
180
        get_msg.my_list = user_list;
179
181
 
180
182
        req.msg_type = DBD_ADD_USERS;
195
197
        dbd_acct_coord_msg_t get_msg;
196
198
        int rc, resp_code;
197
199
 
 
200
        memset(&get_msg, 0, sizeof(dbd_acct_coord_msg_t));
198
201
        get_msg.acct_list = acct_list;
199
202
        get_msg.cond = user_cond;
200
203
 
215
218
        dbd_list_msg_t get_msg;
216
219
        int rc, resp_code;
217
220
 
 
221
        memset(&get_msg, 0, sizeof(dbd_list_msg_t));
218
222
        get_msg.my_list = acct_list;
219
223
 
220
224
        req.msg_type = DBD_ADD_ACCOUNTS;
235
239
        dbd_list_msg_t get_msg;
236
240
        int rc, resp_code;
237
241
 
 
242
        memset(&get_msg, 0, sizeof(dbd_list_msg_t));
238
243
        get_msg.my_list = cluster_list;
239
244
 
240
245
        req.msg_type = DBD_ADD_CLUSTERS;
256
261
        dbd_list_msg_t get_msg;
257
262
        int rc, resp_code;
258
263
 
 
264
        memset(&get_msg, 0, sizeof(dbd_list_msg_t));
259
265
        get_msg.my_list = association_list;
260
266
 
261
267
        req.msg_type = DBD_ADD_ASSOCS;
276
282
        dbd_list_msg_t get_msg;
277
283
        int rc, resp_code;
278
284
 
 
285
        memset(&get_msg, 0, sizeof(dbd_list_msg_t));
279
286
        get_msg.my_list = qos_list;
280
287
 
281
288
        req.msg_type = DBD_ADD_QOS;
290
297
}
291
298
 
292
299
extern int acct_storage_p_add_wckeys(void *db_conn, uint32_t uid,
293
 
                                  List wckey_list)
 
300
                                     List wckey_list)
294
301
{
295
302
        slurmdbd_msg_t req;
296
303
        dbd_list_msg_t get_msg;
297
304
        int rc, resp_code;
298
305
 
 
306
        memset(&get_msg, 0, sizeof(dbd_list_msg_t));
299
307
        get_msg.my_list = wckey_list;
300
308
 
301
309
        req.msg_type = DBD_ADD_WCKEYS;
309
317
        return rc;
310
318
}
311
319
 
 
320
extern int acct_storage_p_add_reservation(void *db_conn, 
 
321
                                           acct_reservation_rec_t *resv)
 
322
{
 
323
        slurmdbd_msg_t req;
 
324
        dbd_rec_msg_t get_msg;
 
325
        int rc, resp_code;
 
326
 
 
327
        memset(&get_msg, 0, sizeof(dbd_rec_msg_t));
 
328
        get_msg.rec = resv;
 
329
 
 
330
        req.msg_type = DBD_ADD_RESV;
 
331
        req.data = &get_msg;
 
332
 
 
333
        rc = slurm_send_slurmdbd_recv_rc_msg(SLURMDBD_VERSION,
 
334
                                             &req, &resp_code);
 
335
        
 
336
        if(resp_code != SLURM_SUCCESS)
 
337
                rc = resp_code;
 
338
 
 
339
        return rc;
 
340
}
 
341
 
312
342
extern List acct_storage_p_modify_users(void *db_conn, uint32_t uid,
313
343
                                        acct_user_cond_t *user_cond,
314
344
                                        acct_user_rec_t *user)
319
349
        List ret_list = NULL;
320
350
        int rc;
321
351
 
 
352
        memset(&get_msg, 0, sizeof(dbd_modify_msg_t));
322
353
        get_msg.cond = user_cond;
323
354
        get_msg.rec = user;
324
355
 
359
390
        int rc;
360
391
        List ret_list = NULL;
361
392
 
 
393
        memset(&get_msg, 0, sizeof(dbd_modify_msg_t));
362
394
        get_msg.cond = acct_cond;
363
395
        get_msg.rec = acct;
364
396
 
400
432
        dbd_list_msg_t *got_msg;
401
433
        List ret_list = NULL;
402
434
 
 
435
        memset(&get_msg, 0, sizeof(dbd_modify_msg_t));
403
436
        get_msg.cond = cluster_cond;
404
437
        get_msg.rec = cluster;
405
438
 
444
477
        List ret_list = NULL;
445
478
 
446
479
 
 
480
        memset(&get_msg, 0, sizeof(dbd_modify_msg_t));
447
481
        get_msg.cond = assoc_cond;
448
482
        get_msg.rec = assoc;
449
483
 
484
518
        List ret_list = NULL;
485
519
        int rc;
486
520
 
 
521
        memset(&get_msg, 0, sizeof(dbd_modify_msg_t));
487
522
        get_msg.cond = qos_cond;
488
523
        get_msg.rec = qos;
489
524
 
524
559
        List ret_list = NULL;
525
560
        int rc;
526
561
 
 
562
        memset(&get_msg, 0, sizeof(dbd_modify_msg_t));
527
563
        get_msg.cond = wckey_cond;
528
564
        get_msg.rec = wckey;
529
565
 
554
590
        return ret_list;
555
591
}
556
592
 
 
593
extern int acct_storage_p_modify_reservation(void *db_conn, 
 
594
                                           acct_reservation_rec_t *resv)
 
595
{
 
596
        slurmdbd_msg_t req;
 
597
        dbd_rec_msg_t get_msg;
 
598
        int rc, resp_code;
 
599
 
 
600
        memset(&get_msg, 0, sizeof(dbd_rec_msg_t));
 
601
        get_msg.rec = resv;
 
602
 
 
603
        req.msg_type = DBD_MODIFY_RESV;
 
604
        req.data = &get_msg;
 
605
 
 
606
        rc = slurm_send_slurmdbd_recv_rc_msg(SLURMDBD_VERSION,
 
607
                                             &req, &resp_code);
 
608
        
 
609
        if(resp_code != SLURM_SUCCESS)
 
610
                rc = resp_code;
 
611
 
 
612
        return rc;
 
613
}
 
614
 
557
615
extern List acct_storage_p_remove_users(void *db_conn, uint32_t uid,
558
616
                                        acct_user_cond_t *user_cond)
559
617
{
564
622
        dbd_list_msg_t *got_msg;
565
623
        List ret_list = NULL;
566
624
 
567
 
 
 
625
        memset(&get_msg, 0, sizeof(dbd_cond_msg_t));
568
626
        get_msg.cond = user_cond;
569
627
 
570
628
        req.msg_type = DBD_REMOVE_USERS;
605
663
        dbd_list_msg_t *got_msg;
606
664
        List ret_list = NULL;
607
665
 
608
 
 
 
666
        memset(&get_msg, 0, sizeof(dbd_acct_coord_msg_t));
609
667
        get_msg.acct_list = acct_list;
610
668
        get_msg.cond = user_cond;
611
669
 
646
704
        dbd_list_msg_t *got_msg;
647
705
        List ret_list = NULL;
648
706
 
649
 
 
 
707
        memset(&get_msg, 0, sizeof(dbd_cond_msg_t));
650
708
        get_msg.cond = acct_cond;
651
709
 
652
710
        req.msg_type = DBD_REMOVE_ACCOUNTS;
686
744
        dbd_list_msg_t *got_msg;
687
745
        List ret_list = NULL;
688
746
 
689
 
 
 
747
        memset(&get_msg, 0, sizeof(dbd_cond_msg_t));
690
748
        get_msg.cond = cluster_cond;
691
749
 
692
750
        req.msg_type = DBD_REMOVE_CLUSTERS;
728
786
        List ret_list = NULL;
729
787
 
730
788
 
 
789
        memset(&get_msg, 0, sizeof(dbd_cond_msg_t));
731
790
        get_msg.cond = assoc_cond;
732
791
 
733
792
        req.msg_type = DBD_REMOVE_ASSOCS;
769
828
        List ret_list = NULL;
770
829
 
771
830
 
 
831
        memset(&get_msg, 0, sizeof(dbd_cond_msg_t));
772
832
        get_msg.cond = qos_cond;
773
833
 
774
834
        req.msg_type = DBD_REMOVE_QOS;
810
870
        List ret_list = NULL;
811
871
 
812
872
 
 
873
        memset(&get_msg, 0, sizeof(dbd_cond_msg_t));
813
874
        get_msg.cond = wckey_cond;
814
875
 
815
876
        req.msg_type = DBD_REMOVE_WCKEYS;
839
900
        return ret_list;
840
901
}
841
902
 
 
903
extern int acct_storage_p_remove_reservation(void *db_conn, 
 
904
                                           acct_reservation_rec_t *resv)
 
905
{
 
906
        slurmdbd_msg_t req;
 
907
        dbd_rec_msg_t get_msg;
 
908
        int rc, resp_code;
 
909
 
 
910
        memset(&get_msg, 0, sizeof(dbd_rec_msg_t));
 
911
        get_msg.rec = resv;
 
912
 
 
913
        req.msg_type = DBD_REMOVE_RESV;
 
914
        req.data = &get_msg;
 
915
 
 
916
        rc = slurm_send_slurmdbd_recv_rc_msg(SLURMDBD_VERSION,
 
917
                                             &req, &resp_code);
 
918
        
 
919
        if(resp_code != SLURM_SUCCESS)
 
920
                rc = resp_code;
 
921
 
 
922
        return rc;
 
923
}
 
924
 
842
925
extern List acct_storage_p_get_users(void *db_conn, uid_t uid,
843
926
                                     acct_user_cond_t *user_cond)
844
927
{
848
931
        int rc;
849
932
        List ret_list = NULL;
850
933
 
 
934
        memset(&get_msg, 0, sizeof(dbd_cond_msg_t));
851
935
        get_msg.cond = user_cond;
852
936
        
853
937
        req.msg_type = DBD_GET_USERS;
886
970
        int rc;
887
971
        List ret_list = NULL;
888
972
 
 
973
        memset(&get_msg, 0, sizeof(dbd_cond_msg_t));
889
974
        get_msg.cond = acct_cond;
890
975
        
891
976
        req.msg_type = DBD_GET_ACCOUNTS;
925
1010
        int rc;
926
1011
        List ret_list = NULL;
927
1012
 
 
1013
        memset(&get_msg, 0, sizeof(dbd_cond_msg_t));
928
1014
        get_msg.cond = cluster_cond;
929
1015
        
930
1016
        req.msg_type = DBD_GET_CLUSTERS;
955
1041
        return ret_list;
956
1042
}
957
1043
 
 
1044
extern List acct_storage_p_get_config(void)
 
1045
{
 
1046
        slurmdbd_msg_t req, resp;
 
1047
        dbd_list_msg_t *got_msg;
 
1048
        int rc;
 
1049
        List ret_list = NULL;
 
1050
        
 
1051
        req.msg_type = DBD_GET_CONFIG;
 
1052
        req.data = NULL;
 
1053
        rc = slurm_send_recv_slurmdbd_msg(SLURMDBD_VERSION, &req, &resp);
 
1054
 
 
1055
        if (rc != SLURM_SUCCESS)
 
1056
                error("slurmdbd: DBD_GET_CONFIG failure: %m");
 
1057
        else if (resp.msg_type == DBD_RC) {
 
1058
                dbd_rc_msg_t *msg = resp.data;
 
1059
                if(msg->return_code == SLURM_SUCCESS) {
 
1060
                        info("%s", msg->comment);
 
1061
                        ret_list = list_create(NULL);
 
1062
                } else
 
1063
                        error("%s", msg->comment);
 
1064
                slurmdbd_free_rc_msg(SLURMDBD_VERSION, msg);
 
1065
        } else if (resp.msg_type != DBD_GOT_CONFIG) {
 
1066
                error("slurmdbd: response type not DBD_GOT_CONFIG: %u", 
 
1067
                      resp.msg_type);
 
1068
        } else {
 
1069
                got_msg = (dbd_list_msg_t *) resp.data;
 
1070
                ret_list = got_msg->my_list;
 
1071
                got_msg->my_list = NULL;
 
1072
                slurmdbd_free_list_msg(SLURMDBD_VERSION, got_msg);
 
1073
        }
 
1074
 
 
1075
        return ret_list;
 
1076
}
 
1077
 
958
1078
extern List acct_storage_p_get_associations(void *db_conn, uid_t uid,
959
1079
                                            acct_association_cond_t *assoc_cond)
960
1080
{
964
1084
        int rc;
965
1085
        List ret_list = NULL;
966
1086
 
 
1087
        memset(&get_msg, 0, sizeof(dbd_cond_msg_t));
967
1088
        get_msg.cond = assoc_cond;
968
1089
        
969
1090
        req.msg_type = DBD_GET_ASSOCS;
1002
1123
        int rc;
1003
1124
        List ret_list = NULL;
1004
1125
 
 
1126
        memset(&get_msg, 0, sizeof(dbd_cond_msg_t));
1005
1127
        get_msg.cond = qos_cond;
1006
1128
 
1007
1129
        req.msg_type = DBD_GET_QOS;
1047
1169
        int rc;
1048
1170
        List ret_list = NULL;
1049
1171
 
 
1172
        memset(&get_msg, 0, sizeof(dbd_cond_msg_t));
1050
1173
        get_msg.cond = wckey_cond;
1051
1174
 
1052
1175
        req.msg_type = DBD_GET_WCKEYS;
1083
1206
        return ret_list;
1084
1207
}
1085
1208
 
 
1209
extern List acct_storage_p_get_reservations(void *mysql_conn, uid_t uid,
 
1210
                                            acct_reservation_cond_t *resv_cond)
 
1211
{
 
1212
        slurmdbd_msg_t req, resp;
 
1213
        dbd_cond_msg_t get_msg;
 
1214
        dbd_list_msg_t *got_msg;
 
1215
        int rc;
 
1216
        List ret_list = NULL;
 
1217
 
 
1218
        memset(&get_msg, 0, sizeof(dbd_cond_msg_t));
 
1219
        get_msg.cond = resv_cond;
 
1220
 
 
1221
        req.msg_type = DBD_GET_RESVS;
 
1222
        req.data = &get_msg;
 
1223
        rc = slurm_send_recv_slurmdbd_msg(SLURMDBD_VERSION, &req, &resp);
 
1224
 
 
1225
        if (rc != SLURM_SUCCESS)
 
1226
                error("slurmdbd: DBD_GET_RESVS failure: %m");
 
1227
        else if (resp.msg_type == DBD_RC) {
 
1228
                dbd_rc_msg_t *msg = resp.data;
 
1229
                if(msg->return_code == SLURM_SUCCESS) {
 
1230
                        info("%s", msg->comment);
 
1231
                        ret_list = list_create(NULL);
 
1232
                } else
 
1233
                        error("%s", msg->comment);
 
1234
                slurmdbd_free_rc_msg(SLURMDBD_VERSION, msg);
 
1235
        } else if (resp.msg_type != DBD_GOT_RESVS) {
 
1236
                error("slurmdbd: response type not DBD_GOT_RESVS: %u", 
 
1237
                      resp.msg_type);
 
1238
        } else {
 
1239
                got_msg = (dbd_list_msg_t *) resp.data;
 
1240
                /* do this just for this type since it could be called
 
1241
                 * multiple times, and if we send back and empty list
 
1242
                 * instead of no list we will only call this once.
 
1243
                 */
 
1244
                if(!got_msg->my_list)
 
1245
                        ret_list = list_create(NULL);
 
1246
                else 
 
1247
                        ret_list = got_msg->my_list;
 
1248
                got_msg->my_list = NULL;
 
1249
                slurmdbd_free_list_msg(SLURMDBD_VERSION, got_msg);
 
1250
        }
 
1251
 
 
1252
        return ret_list;
 
1253
}
 
1254
 
1086
1255
extern List acct_storage_p_get_txn(void *db_conn, uid_t uid,
1087
1256
                                   acct_txn_cond_t *txn_cond)
1088
1257
{
1092
1261
        int rc;
1093
1262
        List ret_list = NULL;
1094
1263
 
 
1264
        memset(&get_msg, 0, sizeof(dbd_cond_msg_t));
1095
1265
        get_msg.cond = txn_cond;
1096
1266
 
1097
1267
        req.msg_type = DBD_GET_TXN;
1133
1303
        List *my_list = NULL;
1134
1304
        int rc;
1135
1305
 
 
1306
        memset(&get_msg, 0, sizeof(dbd_usage_msg_t));
1136
1307
        get_msg.rec = in;
1137
1308
        get_msg.start = start;
1138
1309
        get_msg.end = end;
1195
1366
}
1196
1367
 
1197
1368
extern int acct_storage_p_roll_usage(void *db_conn, 
1198
 
                                     time_t sent_start)
 
1369
                                     time_t sent_start, time_t sent_end,
 
1370
                                     uint16_t archive_data)
1199
1371
{
1200
1372
        slurmdbd_msg_t req;
1201
1373
        dbd_roll_usage_msg_t get_msg;
1202
1374
        int rc, resp_code;
1203
1375
        
 
1376
        memset(&get_msg, 0, sizeof(dbd_roll_usage_msg_t));
 
1377
        get_msg.end = sent_end;
1204
1378
        get_msg.start = sent_start;
 
1379
        get_msg.archive_data = archive_data;
1205
1380
 
1206
1381
        req.msg_type = DBD_ROLL_USAGE;
1207
1382
 
1212
1387
 
1213
1388
        if(resp_code != SLURM_SUCCESS)
1214
1389
                rc = resp_code;
1215
 
        
 
1390
        else
 
1391
                info("SUCCESS");
1216
1392
        return rc;
1217
1393
}
1218
1394
 
1236
1412
        else
1237
1413
                my_reason = node_ptr->reason;
1238
1414
 
 
1415
        memset(&req, 0, sizeof(dbd_node_state_msg_t));
1239
1416
        req.cluster_name = cluster;
1240
1417
        req.cpu_count = cpus;
1241
1418
        req.hostlist   = node_ptr->name;
1242
1419
        req.new_state  = DBD_NODE_STATE_DOWN;
1243
1420
        req.event_time = event_time;
1244
1421
        req.reason     = my_reason;
 
1422
        req.state      = node_ptr->node_state;
1245
1423
        msg.msg_type   = DBD_NODE_STATE;
1246
1424
        msg.data       = &req;
1247
1425
 
1250
1428
 
1251
1429
        return SLURM_SUCCESS;
1252
1430
}
 
1431
 
1253
1432
extern int clusteracct_storage_p_node_up(void *db_conn,
1254
1433
                                         char *cluster,
1255
1434
                                         struct node_record *node_ptr,
1258
1437
        slurmdbd_msg_t msg;
1259
1438
        dbd_node_state_msg_t req;
1260
1439
 
 
1440
        memset(&req, 0, sizeof(dbd_node_state_msg_t));
1261
1441
        req.cluster_name = cluster;
1262
1442
        req.hostlist   = node_ptr->name;
1263
1443
        req.new_state  = DBD_NODE_STATE_UP;
1274
1454
 
1275
1455
extern int clusteracct_storage_p_cluster_procs(void *db_conn,
1276
1456
                                               char *cluster,
 
1457
                                               char *cluster_nodes,
1277
1458
                                               uint32_t procs,
1278
1459
                                               time_t event_time)
1279
1460
{
1282
1463
        int rc = SLURM_ERROR;
1283
1464
 
1284
1465
        debug2("Sending info for cluster %s", cluster);
 
1466
        memset(&req, 0, sizeof(dbd_cluster_procs_msg_t));
1285
1467
        req.cluster_name = cluster;
 
1468
        req.cluster_nodes = cluster_nodes;
1286
1469
        req.proc_count   = procs;
1287
1470
        req.event_time   = event_time;
1288
1471
        msg.msg_type     = DBD_CLUSTER_PROCS;
1301
1484
        dbd_register_ctld_msg_t req;
1302
1485
        info("Registering slurmctld for cluster %s at port %u with slurmdbd.",
1303
1486
             cluster, port);
 
1487
        memset(&req, 0, sizeof(dbd_register_ctld_msg_t));
 
1488
 
1304
1489
        req.cluster_name = cluster;
1305
1490
        req.port         = port;
1306
1491
        msg.msg_type     = DBD_REGISTER_CTLD;
1323
1508
        acct_cluster_rec_t *got_rec;
1324
1509
        int rc;
1325
1510
 
 
1511
        memset(&get_msg, 0, sizeof(dbd_usage_msg_t));
 
1512
 
1326
1513
        get_msg.rec = cluster_rec;
1327
1514
        get_msg.start = start;
1328
1515
        get_msg.end = end;
1366
1553
{
1367
1554
        slurmdbd_msg_t msg, msg_rc;
1368
1555
        dbd_job_start_msg_t req;
1369
 
        dbd_job_start_rc_msg_t *resp;
 
1556
        dbd_id_rc_msg_t *resp;
1370
1557
        char *block_id = NULL;
1371
1558
        int rc = SLURM_SUCCESS;
 
1559
        char temp_bit[BUF_SIZE];
1372
1560
 
1373
1561
        if (!job_ptr->details || !job_ptr->details->submit_time) {
1374
1562
                error("jobacct_storage_p_job_start: "
1375
1563
                      "Not inputing this job, it has no submit time.");
1376
1564
                return SLURM_ERROR;
1377
1565
        }
 
1566
        memset(&req, 0, sizeof(dbd_job_start_msg_t));
1378
1567
 
1379
1568
        req.alloc_cpus    = job_ptr->total_procs;
1380
1569
        req.cluster       = cluster_name;
1384
1573
        select_g_get_jobinfo(job_ptr->select_jobinfo, 
1385
1574
                             SELECT_DATA_BLOCK_ID, 
1386
1575
                             &block_id);
 
1576
        select_g_get_jobinfo(job_ptr->select_jobinfo, 
 
1577
                             SELECT_DATA_NODE_CNT, 
 
1578
                             &req.alloc_nodes);
 
1579
#else
 
1580
        req.alloc_nodes      = job_ptr->node_cnt;
1387
1581
#endif
1388
1582
        req.block_id      = block_id;
1389
1583
        req.db_index      = job_ptr->db_index;
1394
1588
        req.job_state     = job_ptr->job_state & (~JOB_COMPLETING);
1395
1589
        req.name          = job_ptr->name;
1396
1590
        req.nodes         = job_ptr->nodes;
 
1591
        if(job_ptr->node_bitmap) 
 
1592
                req.node_inx = bit_fmt(temp_bit, sizeof(temp_bit), 
 
1593
                                       job_ptr->node_bitmap);
 
1594
        
1397
1595
        req.partition     = job_ptr->partition;
1398
1596
        req.req_cpus      = job_ptr->num_procs;
 
1597
        req.resv_id       = job_ptr->resv_id;
1399
1598
        req.priority      = job_ptr->priority;
1400
1599
        req.start_time    = job_ptr->start_time;
 
1600
        req.timelimit     = job_ptr->time_limit;
 
1601
        req.wckey         = job_ptr->wckey;
1401
1602
        if (job_ptr->details)
1402
1603
                req.submit_time   = job_ptr->details->submit_time;
1403
1604
        req.uid           = job_ptr->user_id;
1426
1627
                        xfree(block_id);
1427
1628
                        return SLURM_ERROR;
1428
1629
                }
1429
 
        } else if (msg_rc.msg_type != DBD_JOB_START_RC) {
1430
 
                error("slurmdbd: response type not DBD_GOT_JOBS: %u", 
 
1630
        } else if (msg_rc.msg_type != DBD_ID_RC) {
 
1631
                error("slurmdbd: response type not DBD_ID_RC: %u", 
1431
1632
                      msg_rc.msg_type);
1432
1633
        } else {
1433
 
                resp = (dbd_job_start_rc_msg_t *) msg_rc.data;
1434
 
                job_ptr->db_index = resp->db_index;
 
1634
                resp = (dbd_id_rc_msg_t *) msg_rc.data;
 
1635
                job_ptr->db_index = resp->id;
1435
1636
                rc = resp->return_code;
1436
1637
                //info("here got %d for return code", resp->return_code);
1437
 
                slurmdbd_free_job_start_rc_msg(SLURMDBD_VERSION, resp);
 
1638
                slurmdbd_free_id_rc_msg(SLURMDBD_VERSION, resp);
1438
1639
        }
1439
1640
        xfree(block_id);
1440
1641
        
1457
1658
                return SLURM_ERROR;
1458
1659
        }
1459
1660
 
 
1661
        memset(&req, 0, sizeof(dbd_job_comp_msg_t));
 
1662
 
1460
1663
        req.assoc_id    = job_ptr->assoc_id;
1461
1664
        req.db_index    = job_ptr->db_index;
1462
1665
        req.end_time    = job_ptr->end_time;
1483
1686
extern int jobacct_storage_p_step_start(void *db_conn,
1484
1687
                                        struct step_record *step_ptr)
1485
1688
{
1486
 
        uint32_t cpus = 0;
 
1689
        uint32_t cpus = 0, tasks = 0, nodes = 0, task_dist = 0;
1487
1690
        char node_list[BUFFER_SIZE];
1488
1691
        slurmdbd_msg_t msg;
1489
1692
        dbd_step_start_msg_t req;
 
1693
        char temp_bit[BUF_SIZE];
1490
1694
 
1491
1695
#ifdef HAVE_BG
1492
1696
        char *ionodes = NULL;
1493
1697
 
1494
 
        cpus = step_ptr->job_ptr->num_procs;
 
1698
        cpus = tasks = step_ptr->job_ptr->num_procs;
1495
1699
        select_g_get_jobinfo(step_ptr->job_ptr->select_jobinfo, 
1496
1700
                             SELECT_DATA_IONODES, 
1497
1701
                             &ionodes);
1503
1707
                snprintf(node_list, BUFFER_SIZE, "%s",
1504
1708
                         step_ptr->job_ptr->nodes);
1505
1709
        }
1506
 
        
 
1710
        select_g_get_jobinfo(step_ptr->job_ptr->select_jobinfo, 
 
1711
                             SELECT_DATA_NODE_CNT, 
 
1712
                             &nodes);
1507
1713
#else
1508
1714
        if (!step_ptr->step_layout || !step_ptr->step_layout->task_cnt) {
1509
 
                cpus = step_ptr->job_ptr->total_procs;
 
1715
                cpus = tasks = step_ptr->job_ptr->total_procs;
1510
1716
                snprintf(node_list, BUFFER_SIZE, "%s",
1511
1717
                         step_ptr->job_ptr->nodes);
 
1718
                nodes = step_ptr->job_ptr->node_cnt;
1512
1719
        } else {
1513
 
                cpus = step_ptr->step_layout->task_cnt;
 
1720
                cpus = step_ptr->cpu_count; 
 
1721
                tasks = step_ptr->step_layout->task_cnt;
 
1722
                nodes = step_ptr->step_layout->node_cnt;
 
1723
                task_dist = step_ptr->step_layout->task_dist;
1514
1724
                snprintf(node_list, BUFFER_SIZE, "%s", 
1515
1725
                         step_ptr->step_layout->node_list);
1516
1726
        }
1523
1733
                      "Not inputing this job, it has no submit time.");
1524
1734
                return SLURM_ERROR;
1525
1735
        }
 
1736
        memset(&req, 0, sizeof(dbd_step_start_msg_t));
1526
1737
 
1527
1738
        req.assoc_id    = step_ptr->job_ptr->assoc_id;
1528
1739
        req.db_index    = step_ptr->job_ptr->db_index;
1529
1740
        req.job_id      = step_ptr->job_ptr->job_id;
1530
1741
        req.name        = step_ptr->name;
1531
1742
        req.nodes       = node_list;
 
1743
        if(step_ptr->step_node_bitmap) 
 
1744
                req.node_inx = bit_fmt(temp_bit, sizeof(temp_bit), 
 
1745
                                       step_ptr->step_node_bitmap);
 
1746
        req.node_cnt    = nodes;
1532
1747
        req.start_time  = step_ptr->start_time;
1533
1748
        if (step_ptr->job_ptr->details)
1534
1749
                req.job_submit_time   = step_ptr->job_ptr->details->submit_time;
1535
1750
        req.step_id     = step_ptr->step_id;
 
1751
        if (step_ptr->step_layout)
 
1752
                req.task_dist   = step_ptr->step_layout->task_dist;
 
1753
        req.task_dist   = task_dist;
1536
1754
        req.total_procs = cpus;
 
1755
        req.total_tasks = tasks;
1537
1756
 
1538
1757
        msg.msg_type    = DBD_STEP_START;
1539
1758
        msg.data        = &req;
1550
1769
extern int jobacct_storage_p_step_complete(void *db_conn,
1551
1770
                                           struct step_record *step_ptr)
1552
1771
{
1553
 
        uint32_t cpus = 0;
 
1772
        uint32_t cpus = 0, tasks = 0;
1554
1773
        char node_list[BUFFER_SIZE];
1555
1774
        slurmdbd_msg_t msg;
1556
1775
        dbd_step_comp_msg_t req;
1558
1777
#ifdef HAVE_BG
1559
1778
        char *ionodes = NULL;
1560
1779
 
1561
 
        cpus = step_ptr->job_ptr->num_procs;
 
1780
        cpus = tasks = step_ptr->job_ptr->num_procs;
1562
1781
        select_g_get_jobinfo(step_ptr->job_ptr->select_jobinfo, 
1563
1782
                             SELECT_DATA_IONODES, 
1564
1783
                             &ionodes);
1573
1792
        
1574
1793
#else
1575
1794
        if (!step_ptr->step_layout || !step_ptr->step_layout->task_cnt) {
1576
 
                cpus = step_ptr->job_ptr->total_procs;
 
1795
                cpus = tasks = step_ptr->job_ptr->total_procs;
1577
1796
                snprintf(node_list, BUFFER_SIZE, "%s", 
1578
1797
                         step_ptr->job_ptr->nodes);
1579
1798
        } else {
1580
 
                cpus = step_ptr->step_layout->task_cnt;
 
1799
                cpus = step_ptr->cpu_count; 
 
1800
                tasks = step_ptr->step_layout->task_cnt;
1581
1801
                snprintf(node_list, BUFFER_SIZE, "%s", 
1582
1802
                         step_ptr->step_layout->node_list);
1583
1803
        }
1591
1811
                return SLURM_ERROR;
1592
1812
        }
1593
1813
 
 
1814
        memset(&req, 0, sizeof(dbd_step_comp_msg_t));
 
1815
 
1594
1816
        req.assoc_id    = step_ptr->job_ptr->assoc_id;
1595
1817
        req.db_index    = step_ptr->job_ptr->db_index;
1596
1818
        req.end_time    = time(NULL);   /* called at step completion */
1603
1825
                req.job_submit_time   = step_ptr->job_ptr->details->submit_time;
1604
1826
        req.step_id     = step_ptr->step_id;
1605
1827
        req.total_procs = cpus;
 
1828
        req.total_tasks = tasks;
1606
1829
 
1607
1830
        msg.msg_type    = DBD_STEP_COMPLETE;
1608
1831
        msg.data        = &req;
1622
1845
        slurmdbd_msg_t msg;
1623
1846
        dbd_job_suspend_msg_t req;
1624
1847
 
 
1848
        memset(&req, 0, sizeof(dbd_job_suspend_msg_t));
 
1849
        
1625
1850
        req.assoc_id     = job_ptr->assoc_id;
1626
1851
        req.job_id       = job_ptr->job_id;
1627
1852
        req.db_index     = job_ptr->db_index;
1652
1877
        int rc;
1653
1878
        List job_list = NULL;
1654
1879
                
 
1880
        memset(&get_msg, 0, sizeof(dbd_cond_msg_t));
 
1881
 
1655
1882
        get_msg.cond = job_cond;
1656
1883
 
1657
1884
        req.msg_type = DBD_GET_JOBS_COND;
1692
1919
        dbd_cond_msg_t msg;
1693
1920
        int rc = SLURM_SUCCESS;
1694
1921
 
 
1922
        memset(&msg, 0, sizeof(dbd_cond_msg_t));
 
1923
 
1695
1924
        msg.cond     = arch_cond;
1696
1925
 
1697
1926
        req.msg_type = DBD_ARCHIVE_DUMP;
1726
1955
{
1727
1956
        slurmdbd_msg_t req, resp;
1728
1957
        int rc = SLURM_SUCCESS;
1729
 
 
 
1958
        
1730
1959
        req.msg_type = DBD_ARCHIVE_LOAD;
1731
1960
        req.data     = arch_rec;
1732
1961
 
1754
1983
extern int acct_storage_p_update_shares_used(void *db_conn,
1755
1984
                                             List shares_used)
1756
1985
{
1757
 
        slurmdbd_msg_t req;
1758
 
        dbd_list_msg_t shares_used_msg;
1759
 
        int rc, resp_code;
1760
 
 
1761
 
        shares_used_msg.my_list = shares_used;
1762
 
 
1763
 
        req.msg_type = DBD_UPDATE_SHARES_USED;
1764
 
        req.data = &shares_used_msg;
1765
 
        rc = slurm_send_slurmdbd_recv_rc_msg(SLURMDBD_VERSION,
1766
 
                                             &req, &resp_code);
1767
 
 
1768
 
        if(resp_code != SLURM_SUCCESS)
1769
 
                rc = resp_code;
1770
 
 
1771
 
        return rc;
 
1986
        return SLURM_SUCCESS;
1772
1987
}
1773
1988
 
1774
1989
extern int acct_storage_p_flush_jobs_on_cluster(void *db_conn, char *cluster,
1779
1994
 
1780
1995
        info("Ending any jobs in accounting that were running when controller "
1781
1996
             "went down on cluster %s", cluster);
 
1997
 
 
1998
        memset(&req, 0, sizeof(dbd_cluster_procs_msg_t));
 
1999
 
1782
2000
        req.cluster_name = cluster;
1783
2001
        req.proc_count   = 0;
1784
2002
        req.event_time   = event_time;
 
2003
 
1785
2004
        msg.msg_type     = DBD_FLUSH_JOBS;
1786
2005
        msg.data         = &req;
1787
2006