← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/common/slurmdbd_defs.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/common/slurmdbd_defs.c
1
1
/****************************************************************************\
2
2
 *  slurmdbd_defs.c - functions for use with Slurm DBD RPCs
3
3
 *****************************************************************************
4
 
 *  Copyright (C) 2008 Lawrence Livermore National Security.
 
4
 *  Copyright (C) 2008-2009 Lawrence Livermore National Security.
5
5
 *  Produced at Lawrence Livermore National Laboratory (cf, DISCLAIMER).
6
6
 *  Written by Morris Jette <jette1@llnl.gov>
7
 
 *  LLNL-CODE-402394.
 
7
 *  CODE-OCEC-09-009. All rights reserved.
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
75
76
#define DBD_MAGIC               0xDEAD3219
76
77
#define MAX_AGENT_QUEUE         10000
77
78
#define MAX_DBD_MSG_LEN         16384
78
 
#define SLURMDBD_TIMEOUT        300     /* Seconds SlurmDBD for response */
 
79
#define SLURMDBD_TIMEOUT        900     /* Seconds SlurmDBD for response */
79
80
 
80
81
uint16_t running_cache = 0;
81
82
pthread_mutex_t assoc_cache_mutex = PTHREAD_MUTEX_INITIALIZER;
88
89
static time_t    agent_shutdown = 0;
89
90
 
90
91
static pthread_mutex_t slurmdbd_lock = PTHREAD_MUTEX_INITIALIZER;
 
92
static pthread_cond_t  slurmdbd_cond = PTHREAD_COND_INITIALIZER;
91
93
static slurm_fd  slurmdbd_fd         = -1;
92
94
static char *    slurmdbd_auth_info  = NULL;
93
95
static bool      rollback_started    = 0;
 
96
static bool      halt_agent          = 0;
94
97
 
95
98
static void * _agent(void *x);
96
99
static void   _agent_queue_del(void *x);
231
234
        xassert(req);
232
235
        xassert(resp);
233
236
 
 
237
        /* To make sure we can get this to send instead of the agent
 
238
           sending stuff that can happen anytime we set halt_agent and
 
239
           then after we get into the mutex we unset.
 
240
        */
 
241
        halt_agent = 1;
234
242
        read_timeout = SLURMDBD_TIMEOUT * 1000;
235
243
        slurm_mutex_lock(&slurmdbd_lock);
 
244
        halt_agent = 0;
236
245
        if (slurmdbd_fd < 0) {
237
246
                /* Either slurm_open_slurmdbd_conn() was not executed or
238
247
                 * the connection to Slurm DBD has been closed */
239
248
                _open_slurmdbd_fd();
240
249
                if (slurmdbd_fd < 0) {
241
 
                        slurm_mutex_unlock(&slurmdbd_lock);
242
 
                        return SLURM_ERROR;
 
250
                        rc = SLURM_ERROR;
 
251
                        goto end_it;
243
252
                }
244
253
        }
245
254
 
250
259
        if (rc != SLURM_SUCCESS) {
251
260
                error("slurmdbd: Sending message type %u: %d: %m",
252
261
                      req->msg_type, rc);
253
 
                slurm_mutex_unlock(&slurmdbd_lock);
254
 
                return rc;
 
262
                goto end_it;
255
263
        }
256
264
 
257
265
        buffer = _recv_msg(read_timeout);
258
266
        if (buffer == NULL) {
259
267
                error("slurmdbd: Getting response to message type %u", 
260
268
                      req->msg_type);
261
 
                slurm_mutex_unlock(&slurmdbd_lock);
262
 
                return SLURM_ERROR;
 
269
                rc = SLURM_ERROR;
 
270
                goto end_it;
263
271
        }
264
272
                
265
273
        rc = unpack_slurmdbd_msg(rpc_version, resp, buffer);
266
274
 
267
275
        /* check for the rc of the start job message */
268
 
        if (rc == SLURM_SUCCESS && resp->msg_type == DBD_JOB_START_RC) 
269
 
                rc = ((dbd_job_start_rc_msg_t *)resp->data)->return_code;
 
276
        if (rc == SLURM_SUCCESS && resp->msg_type == DBD_ID_RC) 
 
277
                rc = ((dbd_id_rc_msg_t *)resp->data)->return_code;
270
278
        
271
279
        free_buf(buffer);
 
280
end_it:
 
281
        pthread_cond_signal(&slurmdbd_cond);
272
282
        slurm_mutex_unlock(&slurmdbd_lock);
273
283
        
274
284
        return rc;
314
324
                error("slurmdbd: agent queue is full, discarding request");
315
325
                rc = SLURM_ERROR;
316
326
        }
317
 
        slurm_mutex_unlock(&agent_lock);
 
327
 
318
328
        pthread_cond_broadcast(&agent_cond);
 
329
        slurm_mutex_unlock(&agent_lock);
319
330
        return rc;
320
331
}
321
332
 
325
336
        slurm_addr dbd_addr;
326
337
        uint16_t slurmdbd_port;
327
338
        char *   slurmdbd_host;
328
 
 
 
339
        bool try_backup = true;
329
340
        if (slurmdbd_fd >= 0) {
330
341
                debug("Attempt to re-open slurmdbd socket");
331
342
                /* clear errno (checked after this for errors) */
335
346
 
336
347
        slurmdbd_host = slurm_get_accounting_storage_host();
337
348
        slurmdbd_port = slurm_get_accounting_storage_port();
338
 
        if (slurmdbd_host == NULL)
 
349
        if (slurmdbd_host == NULL) {
339
350
                slurmdbd_host = xstrdup(DEFAULT_STORAGE_HOST);
340
 
        
 
351
                slurm_set_accounting_storage_host(slurmdbd_host);
 
352
        }
 
353
 
341
354
        if (slurmdbd_port == 0) {
342
355
                slurmdbd_port = SLURMDBD_PORT;
343
356
                slurm_set_accounting_storage_port(slurmdbd_port);
344
357
        }
 
358
again:
345
359
        slurm_set_addr(&dbd_addr, slurmdbd_port, slurmdbd_host);
346
360
        if (dbd_addr.sin_port == 0)
347
361
                error("Unable to locate SlurmDBD host %s:%u", 
349
363
        else {
350
364
                slurmdbd_fd = slurm_open_msg_conn(&dbd_addr);
351
365
 
352
 
                if (slurmdbd_fd < 0)
353
 
                        error("slurmdbd: slurm_open_msg_conn: %m");
354
 
                else {
 
366
                if (slurmdbd_fd < 0) {
 
367
                        debug("slurmdbd: slurm_open_msg_conn to %s:%u: %m",
 
368
                              slurmdbd_host, slurmdbd_port);
 
369
                        if(try_backup) {
 
370
                                try_backup = false;
 
371
                                xfree(slurmdbd_host);
 
372
                                if((slurmdbd_host = 
 
373
                                    slurm_get_accounting_storage_backup_host()))
 
374
                                        goto again;                     
 
375
                        }
 
376
                } else {
355
377
                        fd_set_nonblocking(slurmdbd_fd);
356
378
                        if (_send_init_msg() != SLURM_SUCCESS)  {
357
379
                                error("slurmdbd: Sending DdbInit msg: %m");
385
407
        case DBD_GOT_LIST:
386
408
        case DBD_ADD_QOS:
387
409
        case DBD_GOT_QOS:
 
410
        case DBD_GOT_RESVS:
388
411
        case DBD_ADD_WCKEYS:
389
412
        case DBD_GOT_WCKEYS:
390
413
        case DBD_GOT_TXN:
391
414
        case DBD_GOT_USERS:
392
 
        case DBD_UPDATE_SHARES_USED:
 
415
        case DBD_GOT_CONFIG:
393
416
                slurmdbd_pack_list_msg(
394
417
                        rpc_version, req->msg_type, 
395
418
                        (dbd_list_msg_t *)req->data, buffer);
414
437
        case DBD_GET_CLUSTERS:
415
438
        case DBD_GET_JOBS_COND:
416
439
        case DBD_GET_QOS:
 
440
        case DBD_GET_RESVS:
417
441
        case DBD_GET_WCKEYS:
418
442
        case DBD_GET_TXN:
419
443
        case DBD_GET_USERS:
462
486
                                            (dbd_job_start_msg_t *)req->data, 
463
487
                                            buffer);
464
488
                break;
465
 
        case DBD_JOB_START_RC:
466
 
                slurmdbd_pack_job_start_rc_msg(
 
489
        case DBD_ID_RC:
 
490
                slurmdbd_pack_id_rc_msg(
467
491
                        rpc_version,
468
 
                        (dbd_job_start_rc_msg_t *)req->data, buffer);
 
492
                        (dbd_id_rc_msg_t *)req->data, buffer);
469
493
                break;          
470
494
        case DBD_JOB_SUSPEND:
471
495
                slurmdbd_pack_job_suspend_msg(
509
533
                                             (dbd_roll_usage_msg_t *)
510
534
                                             req->data, buffer);
511
535
                break;
 
536
        case DBD_ADD_RESV:
 
537
        case DBD_REMOVE_RESV:
 
538
        case DBD_MODIFY_RESV:
 
539
                slurmdbd_pack_rec_msg(
 
540
                        rpc_version, req->msg_type,
 
541
                        (dbd_rec_msg_t *)req->data, buffer);
 
542
                break;
 
543
        case DBD_GET_CONFIG:
 
544
                /* No message to pack */
 
545
                break;
512
546
        default:
513
547
                error("slurmdbd: Invalid message type pack %u(%s:%u)",
514
548
                      req->msg_type,
539
573
        case DBD_GOT_LIST:
540
574
        case DBD_ADD_QOS:
541
575
        case DBD_GOT_QOS:
 
576
        case DBD_GOT_RESVS:
542
577
        case DBD_ADD_WCKEYS:
543
578
        case DBD_GOT_WCKEYS:
544
579
        case DBD_GOT_TXN:
545
580
        case DBD_GOT_USERS:
546
 
        case DBD_UPDATE_SHARES_USED:
 
581
        case DBD_GOT_CONFIG:
547
582
                rc = slurmdbd_unpack_list_msg(
548
583
                        rpc_version, resp->msg_type,
549
584
                        (dbd_list_msg_t **)&resp->data, buffer);
569
604
        case DBD_GET_JOBS_COND:
570
605
        case DBD_GET_USERS:
571
606
        case DBD_GET_QOS:
 
607
        case DBD_GET_RESVS:
572
608
        case DBD_GET_WCKEYS:
573
609
        case DBD_GET_TXN:
574
610
        case DBD_REMOVE_ACCOUNTS:
619
655
                        rpc_version,
620
656
                        (dbd_job_start_msg_t **)&resp->data, buffer);
621
657
                break;
622
 
        case DBD_JOB_START_RC:
623
 
                rc = slurmdbd_unpack_job_start_rc_msg(
 
658
        case DBD_ID_RC:
 
659
                rc = slurmdbd_unpack_id_rc_msg(
624
660
                        rpc_version,
625
 
                        (dbd_job_start_rc_msg_t **)&resp->data, buffer);
 
661
                        (dbd_id_rc_msg_t **)&resp->data, buffer);
626
662
                break;          
627
663
        case DBD_JOB_SUSPEND:
628
664
                rc = slurmdbd_unpack_job_suspend_msg(
668
704
                        rpc_version,
669
705
                        (dbd_roll_usage_msg_t **)&resp->data, buffer);
670
706
                break;
 
707
        case DBD_ADD_RESV:
 
708
        case DBD_REMOVE_RESV:
 
709
        case DBD_MODIFY_RESV:
 
710
                rc = slurmdbd_unpack_rec_msg(
 
711
                        rpc_version, resp->msg_type,
 
712
                        (dbd_rec_msg_t **)&resp->data, buffer);
 
713
                break;
 
714
        case DBD_GET_CONFIG:
 
715
                /* No message to unpack */
 
716
                break;
671
717
        default:
672
718
                error("slurmdbd: Invalid message type unpack %u(%s)",
673
719
                      resp->msg_type,
737
783
                return DBD_JOB_COMPLETE;
738
784
        } else if(!strcasecmp(msg_type, "Job Start")) {
739
785
                return DBD_JOB_START;
740
 
        } else if(!strcasecmp(msg_type, "Job Start RC")) {
741
 
                return DBD_JOB_START_RC;
 
786
        } else if(!strcasecmp(msg_type, "ID RC")) {
 
787
                return DBD_ID_RC;
742
788
        } else if(!strcasecmp(msg_type, "Job Suspend")) {
743
789
                return DBD_JOB_SUSPEND;
744
790
        } else if(!strcasecmp(msg_type, "Modify Accounts")) {
775
821
                return DBD_STEP_COMPLETE;
776
822
        } else if(!strcasecmp(msg_type, "Step Start")) {
777
823
                return DBD_STEP_START;
778
 
        } else if(!strcasecmp(msg_type, "Update Shares Used")) {
779
 
                return DBD_UPDATE_SHARES_USED;
780
824
        } else if(!strcasecmp(msg_type, "Get Jobs Conditional")) {
781
825
                return DBD_GET_JOBS_COND;
782
826
        } else if(!strcasecmp(msg_type, "Get Transations")) {
803
847
                return DBD_GET_WCKEY_USAGE;
804
848
        } else if(!strcasecmp(msg_type, "Got WCKey Usage")) {
805
849
                return DBD_GOT_WCKEY_USAGE;
 
850
        } else if(!strcasecmp(msg_type, "Add Reservation")) {
 
851
                return DBD_ADD_RESV;
 
852
        } else if(!strcasecmp(msg_type, "Remove Reservation")) {
 
853
                return DBD_REMOVE_RESV;
 
854
        } else if(!strcasecmp(msg_type, "Modify Reservation")) {
 
855
                return DBD_MODIFY_RESV;
 
856
        } else if(!strcasecmp(msg_type, "Get Reservations")) {
 
857
                return DBD_GET_RESVS;
 
858
        } else if(!strcasecmp(msg_type, "Got Reservations")) {
 
859
                return DBD_GOT_RESVS;
 
860
        } else if(!strcasecmp(msg_type, "Get Config")) {
 
861
                return DBD_GET_CONFIG;
 
862
        } else if(!strcasecmp(msg_type, "Got Config")) {
 
863
                return DBD_GOT_CONFIG;
806
864
        } else {
807
865
                return NO_VAL;          
808
866
        }
969
1027
                } else
970
1028
                        return "Job Start";
971
1029
                break;
972
 
        case DBD_JOB_START_RC:
 
1030
        case DBD_ID_RC:
973
1031
                if(get_enum) {
974
 
                        return "DBD_JOB_START_RC";
 
1032
                        return "DBD_ID_RC";
975
1033
                } else
976
 
                        return "Job Start RC";
 
1034
                        return "ID RC";
977
1035
                break;
978
1036
        case DBD_JOB_SUSPEND:
979
1037
                if(get_enum) {
1083
1141
                } else
1084
1142
                        return "Step Start";
1085
1143
                break;
1086
 
        case DBD_UPDATE_SHARES_USED:
1087
 
                if(get_enum) {
1088
 
                        return "DBD_UPDATE_SHARES_USED";
1089
 
                } else
1090
 
                        return "Update Shares Used";
1091
 
                break;
1092
1144
        case DBD_GET_JOBS_COND:
1093
1145
                if(get_enum) {
1094
1146
                        return "DBD_GET_JOBS_COND";
1167
1219
                } else
1168
1220
                        return "Got WCKey Usage";
1169
1221
                break;
 
1222
        case DBD_ADD_RESV:
 
1223
                if(get_enum) {
 
1224
                        return "DBD_ADD_RESV";
 
1225
                } else
 
1226
                        return "Add Reservation";
 
1227
                break;
 
1228
        case DBD_REMOVE_RESV:
 
1229
                if(get_enum) {
 
1230
                        return "DBD_REMOVE_RESV";
 
1231
                } else
 
1232
                        return "Remove Reservation";
 
1233
                break;
 
1234
        case DBD_MODIFY_RESV:
 
1235
                if(get_enum) {
 
1236
                        return "DBD_MODIFY_RESV";
 
1237
                } else
 
1238
                        return "Modify Reservation";
 
1239
                break;
 
1240
        case DBD_GET_RESVS:
 
1241
                if(get_enum) {
 
1242
                        return "DBD_GET_RESVS";
 
1243
                } else
 
1244
                        return "Get Reservations";
 
1245
                break;
 
1246
        case DBD_GOT_RESVS:
 
1247
                if(get_enum) {
 
1248
                        return "DBD_GOT_RESVS";
 
1249
                } else
 
1250
                        return "Got Reservations";
 
1251
                break;
 
1252
        case DBD_GET_CONFIG:
 
1253
                if(get_enum) {
 
1254
                        return "DBD_GET_CONFIG";
 
1255
                } else
 
1256
                        return "Get Config";
 
1257
                break;
 
1258
        case DBD_GOT_CONFIG:
 
1259
                if(get_enum) {
 
1260
                        return "DBD_GOT_CONFIG";
 
1261
                } else
 
1262
                        return "Got Config";
 
1263
                break;
1170
1264
        default:
1171
1265
                return "Unknown";
1172
1266
                break;
1293
1387
        Buf buffer;
1294
1388
        uint16_t msg_type;
1295
1389
        dbd_rc_msg_t *msg;
1296
 
        dbd_job_start_rc_msg_t *js_msg;
 
1390
        dbd_id_rc_msg_t *id_msg;
1297
1391
        int rc = SLURM_ERROR;
1298
1392
 
1299
1393
        buffer = _recv_msg(read_timeout);
1302
1396
 
1303
1397
        safe_unpack16(&msg_type, buffer);
1304
1398
        switch(msg_type) {
1305
 
        case DBD_JOB_START_RC:
1306
 
                if (slurmdbd_unpack_job_start_rc_msg(rpc_version, 
1307
 
                                                     &js_msg, buffer)
 
1399
        case DBD_ID_RC:
 
1400
                if (slurmdbd_unpack_id_rc_msg(rpc_version, &id_msg, buffer)
1308
1401
                    == SLURM_SUCCESS) {
1309
 
                        rc = js_msg->return_code;
1310
 
                        slurmdbd_free_job_start_rc_msg(rpc_version, js_msg);
 
1402
                        rc = id_msg->return_code;
 
1403
                        slurmdbd_free_id_rc_msg(rpc_version, id_msg);
1311
1404
                        if (rc != SLURM_SUCCESS)
1312
 
                                error("slurmdbd: DBD_JOB_START_RC is %d", rc);
 
1405
                                error("slurmdbd: DBD_ID_RC is %d", rc);
1313
1406
                } else
1314
1407
                        error("slurmdbd: unpack message error");
1315
1408
                break;
1462
1555
        return false;
1463
1556
}
1464
1557
 
1465
 
/* Wait until a file is writable, 
 
1558
/* Wait until a file is writeable, 
1466
1559
 * RET 1 if file can be written now,
1467
1560
 *     0 if can not be written to within 5 seconds
1468
1561
 *     -1 if file has been closed POLLHUP
1605
1698
        xsignal_unblock(sigarray);
1606
1699
 
1607
1700
        while (agent_shutdown == 0) {
1608
 
 
1609
1701
                slurm_mutex_lock(&slurmdbd_lock);
 
1702
                if(halt_agent)
 
1703
                        pthread_cond_wait(&slurmdbd_cond, &slurmdbd_lock);
 
1704
 
1610
1705
                if ((slurmdbd_fd < 0) && 
1611
1706
                    (difftime(time(NULL), fail_time) >= 10)) {                  
1612
1707
                        /* The connection to Slurm DBD is not open */
1644
1739
                        if(slurmdbd_fd >= 0 && running_cache)
1645
1740
                                pthread_cond_signal(&assoc_cache_cond);
1646
1741
                        slurm_mutex_unlock(&assoc_cache_mutex);
1647
 
 
 
1742
                        
1648
1743
                        continue;
1649
1744
                }
1650
1745
 
1921
2016
{
1922
2017
        if (msg) {
1923
2018
                xfree(msg->cluster_name);
 
2019
                xfree(msg->cluster_nodes);
 
2020
                xfree(msg);
 
2021
        }
 
2022
}
 
2023
 
 
2024
void inline slurmdbd_free_rec_msg(uint16_t rpc_version, 
 
2025
                                   slurmdbd_msg_type_t type,
 
2026
                                   dbd_rec_msg_t *msg)
 
2027
{
 
2028
        void (*my_destroy) (void *object);
 
2029
 
 
2030
        if (msg) {
 
2031
                switch(type) {
 
2032
                case DBD_ADD_RESV:
 
2033
                case DBD_REMOVE_RESV:
 
2034
                case DBD_MODIFY_RESV:
 
2035
                        my_destroy = destroy_acct_reservation_rec;
 
2036
                        break;
 
2037
                default:
 
2038
                        fatal("Unknown rec type");
 
2039
                        return;
 
2040
                }
 
2041
                if(msg->rec)
 
2042
                        (*(my_destroy))(msg->rec);
1924
2043
                xfree(msg);
1925
2044
        }
1926
2045
}
1966
2085
                case DBD_ARCHIVE_DUMP:
1967
2086
                        my_destroy = destroy_acct_archive_cond;
1968
2087
                        break;
 
2088
                case DBD_GET_RESVS:
 
2089
                        my_destroy = destroy_acct_reservation_cond;
 
2090
                        break;
1969
2091
                default:
1970
2092
                        fatal("Unknown cond type");
1971
2093
                        return;
2020
2142
                xfree(msg->cluster);
2021
2143
                xfree(msg->name);
2022
2144
                xfree(msg->nodes);
 
2145
                xfree(msg->node_inx);
2023
2146
                xfree(msg->partition);
 
2147
                xfree(msg->wckey);
2024
2148
                xfree(msg);
2025
2149
        }
2026
2150
}
2027
2151
 
2028
 
void inline slurmdbd_free_job_start_rc_msg(uint16_t rpc_version, 
2029
 
                                           dbd_job_start_rc_msg_t *msg)
 
2152
void inline slurmdbd_free_id_rc_msg(uint16_t rpc_version, 
 
2153
                                           dbd_id_rc_msg_t *msg)
2030
2154
{
2031
2155
        xfree(msg);
2032
2156
}
2135
2259
        if (msg) {
2136
2260
                xfree(msg->name);
2137
2261
                xfree(msg->nodes);
 
2262
                xfree(msg->node_inx);
2138
2263
                xfree(msg);
2139
2264
        }
2140
2265
}
2231
2356
slurmdbd_pack_cluster_procs_msg(uint16_t rpc_version, 
2232
2357
                                dbd_cluster_procs_msg_t *msg, Buf buffer)
2233
2358
{
2234
 
        packstr(msg->cluster_name, buffer);
2235
 
        pack32(msg->proc_count,    buffer);
2236
 
        pack_time(msg->event_time, buffer);
 
2359
        if(rpc_version >= 5) {
 
2360
                packstr(msg->cluster_name, buffer);
 
2361
                packstr(msg->cluster_nodes, buffer);
 
2362
                pack32(msg->proc_count,    buffer);
 
2363
                pack_time(msg->event_time, buffer);
 
2364
        } else {
 
2365
                packstr(msg->cluster_name, buffer);
 
2366
                pack32(msg->proc_count,    buffer);
 
2367
                pack_time(msg->event_time, buffer);
 
2368
        }
2237
2369
}
2238
2370
 
2239
2371
int inline
2245
2377
 
2246
2378
        msg_ptr = xmalloc(sizeof(dbd_cluster_procs_msg_t));
2247
2379
        *msg = msg_ptr;
2248
 
        safe_unpackstr_xmalloc(&msg_ptr->cluster_name, &uint32_tmp, buffer);
2249
 
        safe_unpack32(&msg_ptr->proc_count, buffer);
2250
 
        safe_unpack_time(&msg_ptr->event_time, buffer);
 
2380
 
 
2381
        if(rpc_version >= 5) {
 
2382
                safe_unpackstr_xmalloc(&msg_ptr->cluster_name,
 
2383
                                       &uint32_tmp, buffer);
 
2384
                safe_unpackstr_xmalloc(&msg_ptr->cluster_nodes,
 
2385
                                       &uint32_tmp, buffer);
 
2386
                safe_unpack32(&msg_ptr->proc_count, buffer);
 
2387
                safe_unpack_time(&msg_ptr->event_time, buffer);
 
2388
        } else {
 
2389
                safe_unpackstr_xmalloc(&msg_ptr->cluster_name,
 
2390
                                       &uint32_tmp, buffer);
 
2391
                safe_unpack32(&msg_ptr->proc_count, buffer);
 
2392
                safe_unpack_time(&msg_ptr->event_time, buffer);
 
2393
        }
2251
2394
        return SLURM_SUCCESS;
2252
2395
 
2253
2396
unpack_error:
2256
2399
        return SLURM_ERROR;
2257
2400
}
2258
2401
 
 
2402
void inline slurmdbd_pack_rec_msg(uint16_t rpc_version, 
 
2403
                                  slurmdbd_msg_type_t type,
 
2404
                                  dbd_rec_msg_t *msg, Buf buffer)
 
2405
{
 
2406
        void (*my_function) (void *object, uint16_t rpc_version, Buf buffer);
 
2407
 
 
2408
        switch(type) {
 
2409
        case DBD_ADD_RESV:
 
2410
        case DBD_REMOVE_RESV:
 
2411
        case DBD_MODIFY_RESV:
 
2412
                my_function = pack_acct_reservation_rec;
 
2413
                break;
 
2414
        default:
 
2415
                fatal("Unknown pack type");
 
2416
                return;
 
2417
        }
 
2418
 
 
2419
        (*(my_function))(msg->rec, rpc_version, buffer);
 
2420
}
 
2421
 
 
2422
int inline slurmdbd_unpack_rec_msg(uint16_t rpc_version, 
 
2423
                                   slurmdbd_msg_type_t type,
 
2424
                                   dbd_rec_msg_t **msg, Buf buffer)
 
2425
{
 
2426
        dbd_rec_msg_t *msg_ptr = NULL;
 
2427
        int (*my_function) (void **object, uint16_t rpc_version, Buf buffer);
 
2428
 
 
2429
        switch(type) {
 
2430
        case DBD_ADD_RESV:
 
2431
        case DBD_REMOVE_RESV:
 
2432
        case DBD_MODIFY_RESV:
 
2433
                my_function = unpack_acct_reservation_rec;
 
2434
                break;
 
2435
        default:
 
2436
                fatal("Unknown unpack type");
 
2437
                return SLURM_ERROR;
 
2438
        }
 
2439
 
 
2440
        msg_ptr = xmalloc(sizeof(dbd_rec_msg_t));
 
2441
        *msg = msg_ptr;
 
2442
 
 
2443
        if((*(my_function))(&msg_ptr->rec, rpc_version, buffer) == SLURM_ERROR)
 
2444
                goto unpack_error;
 
2445
        
 
2446
        return SLURM_SUCCESS;
 
2447
 
 
2448
unpack_error:
 
2449
        slurmdbd_free_rec_msg(rpc_version, type, msg_ptr);
 
2450
        *msg = NULL;
 
2451
        return SLURM_ERROR;
 
2452
}
 
2453
 
2259
2454
void inline slurmdbd_pack_cond_msg(uint16_t rpc_version, 
2260
2455
                                   slurmdbd_msg_type_t type,
2261
2456
                                   dbd_cond_msg_t *msg, Buf buffer)
2296
2491
        case DBD_ARCHIVE_DUMP:
2297
2492
                my_function = pack_acct_archive_cond;
2298
2493
                break;
 
2494
        case DBD_GET_RESVS:
 
2495
                my_function = pack_acct_reservation_cond;
 
2496
                break;
2299
2497
        default:
2300
2498
                fatal("Unknown pack type");
2301
2499
                return;
2345
2543
        case DBD_ARCHIVE_DUMP:
2346
2544
                my_function = unpack_acct_archive_cond;
2347
2545
                break;
 
2546
        case DBD_GET_RESVS:
 
2547
                my_function = unpack_acct_reservation_cond;
 
2548
                break;
2348
2549
        default:
2349
2550
                fatal("Unknown unpack type");
2350
2551
                return SLURM_ERROR;
2588
2789
slurmdbd_pack_job_start_msg(uint16_t rpc_version, 
2589
2790
                            dbd_job_start_msg_t *msg, Buf buffer)
2590
2791
{
2591
 
        if(rpc_version >= 3) {
 
2792
        if(rpc_version >= 5) {
 
2793
                packstr(msg->account, buffer);
 
2794
                pack32(msg->alloc_cpus, buffer);
 
2795
                pack32(msg->alloc_nodes, buffer);
 
2796
                pack32(msg->assoc_id, buffer);
 
2797
                packstr(msg->block_id, buffer);
 
2798
                packstr(msg->cluster, buffer);
 
2799
                pack32(msg->db_index, buffer);
 
2800
                pack_time(msg->eligible_time, buffer);
 
2801
                pack32(msg->gid, buffer);
 
2802
                pack32(msg->job_id, buffer);
 
2803
                pack16(msg->job_state, buffer);
 
2804
                packstr(msg->name, buffer);
 
2805
                packstr(msg->nodes, buffer);
 
2806
                packstr(msg->node_inx, buffer);
 
2807
                packstr(msg->partition, buffer);
 
2808
                pack32(msg->priority, buffer);
 
2809
                pack32(msg->req_cpus, buffer);
 
2810
                pack32(msg->resv_id, buffer);
 
2811
                pack_time(msg->start_time, buffer);
 
2812
                pack_time(msg->submit_time, buffer);
 
2813
                pack32(msg->timelimit, buffer);         
 
2814
                pack32(msg->uid, buffer);               
 
2815
                packstr(msg->wckey, buffer);
 
2816
        } else if(rpc_version >= 3) {
2592
2817
                packstr(msg->account, buffer);
2593
2818
                pack32(msg->alloc_cpus, buffer);
2594
2819
                pack32(msg->assoc_id, buffer);
2636
2861
        dbd_job_start_msg_t *msg_ptr = xmalloc(sizeof(dbd_job_start_msg_t));
2637
2862
        *msg = msg_ptr;
2638
2863
 
2639
 
        if(rpc_version >= 3) {
2640
 
                safe_unpackstr_xmalloc(&msg_ptr->account, &uint32_tmp, buffer);
2641
 
                safe_unpack32(&msg_ptr->alloc_cpus, buffer);
2642
 
                safe_unpack32(&msg_ptr->assoc_id, buffer);
2643
 
                safe_unpackstr_xmalloc(&msg_ptr->block_id, &uint32_tmp, buffer);
2644
 
                safe_unpackstr_xmalloc(&msg_ptr->cluster, &uint32_tmp, buffer);
2645
 
                safe_unpack32(&msg_ptr->db_index, buffer);
2646
 
                safe_unpack_time(&msg_ptr->eligible_time, buffer);
2647
 
                safe_unpack32(&msg_ptr->gid, buffer);
2648
 
                safe_unpack32(&msg_ptr->job_id, buffer);
2649
 
                safe_unpack16(&msg_ptr->job_state, buffer);
2650
 
                safe_unpackstr_xmalloc(&msg_ptr->name, &uint32_tmp, buffer);
2651
 
                safe_unpackstr_xmalloc(&msg_ptr->nodes, &uint32_tmp, buffer);
2652
 
                safe_unpackstr_xmalloc(&msg_ptr->partition,
2653
 
                                       &uint32_tmp, buffer);
2654
 
                safe_unpack32(&msg_ptr->priority, buffer);
2655
 
                safe_unpack32(&msg_ptr->req_cpus, buffer);
2656
 
                safe_unpack_time(&msg_ptr->start_time, buffer);
2657
 
                safe_unpack_time(&msg_ptr->submit_time, buffer);
2658
 
                safe_unpack32(&msg_ptr->uid, buffer);   
 
2864
        if(rpc_version >= 5) {
 
2865
                safe_unpackstr_xmalloc(&msg_ptr->account, &uint32_tmp, buffer);
 
2866
                safe_unpack32(&msg_ptr->alloc_cpus, buffer);
 
2867
                safe_unpack32(&msg_ptr->alloc_nodes, buffer);
 
2868
                safe_unpack32(&msg_ptr->assoc_id, buffer);
 
2869
                safe_unpackstr_xmalloc(&msg_ptr->block_id, &uint32_tmp, buffer);
 
2870
                safe_unpackstr_xmalloc(&msg_ptr->cluster, &uint32_tmp, buffer);
 
2871
                safe_unpack32(&msg_ptr->db_index, buffer);
 
2872
                safe_unpack_time(&msg_ptr->eligible_time, buffer);
 
2873
                safe_unpack32(&msg_ptr->gid, buffer);
 
2874
                safe_unpack32(&msg_ptr->job_id, buffer);
 
2875
                safe_unpack16(&msg_ptr->job_state, buffer);
 
2876
                safe_unpackstr_xmalloc(&msg_ptr->name, &uint32_tmp, buffer);
 
2877
                safe_unpackstr_xmalloc(&msg_ptr->nodes, &uint32_tmp, buffer);
 
2878
                safe_unpackstr_xmalloc(&msg_ptr->node_inx, &uint32_tmp, buffer);
 
2879
                safe_unpackstr_xmalloc(&msg_ptr->partition,
 
2880
                                       &uint32_tmp, buffer);
 
2881
                safe_unpack32(&msg_ptr->priority, buffer);
 
2882
                safe_unpack32(&msg_ptr->req_cpus, buffer);
 
2883
                safe_unpack32(&msg_ptr->resv_id, buffer);
 
2884
                safe_unpack_time(&msg_ptr->start_time, buffer);
 
2885
                safe_unpack_time(&msg_ptr->submit_time, buffer);
 
2886
                safe_unpack32(&msg_ptr->timelimit, buffer);     
 
2887
                safe_unpack32(&msg_ptr->uid, buffer);   
 
2888
                safe_unpackstr_xmalloc(&msg_ptr->wckey, &uint32_tmp, buffer);
 
2889
        } else if(rpc_version >= 3) {
 
2890
                char *temp = NULL, *jname = NULL;
 
2891
                safe_unpackstr_xmalloc(&msg_ptr->account, &uint32_tmp, buffer);
 
2892
                safe_unpack32(&msg_ptr->alloc_cpus, buffer);
 
2893
                safe_unpack32(&msg_ptr->assoc_id, buffer);
 
2894
                safe_unpackstr_xmalloc(&msg_ptr->block_id, &uint32_tmp, buffer);
 
2895
                safe_unpackstr_xmalloc(&msg_ptr->cluster, &uint32_tmp, buffer);
 
2896
                safe_unpack32(&msg_ptr->db_index, buffer);
 
2897
                safe_unpack_time(&msg_ptr->eligible_time, buffer);
 
2898
                safe_unpack32(&msg_ptr->gid, buffer);
 
2899
                safe_unpack32(&msg_ptr->job_id, buffer);
 
2900
                safe_unpack16(&msg_ptr->job_state, buffer);
 
2901
                safe_unpackstr_xmalloc(&msg_ptr->name, &uint32_tmp, buffer);
 
2902
                safe_unpackstr_xmalloc(&msg_ptr->nodes, &uint32_tmp, buffer);
 
2903
                safe_unpackstr_xmalloc(&msg_ptr->partition,
 
2904
                                       &uint32_tmp, buffer);
 
2905
                safe_unpack32(&msg_ptr->priority, buffer);
 
2906
                safe_unpack32(&msg_ptr->req_cpus, buffer);
 
2907
                safe_unpack_time(&msg_ptr->start_time, buffer);
 
2908
                safe_unpack_time(&msg_ptr->submit_time, buffer);
 
2909
                safe_unpack32(&msg_ptr->uid, buffer);   
 
2910
 
 
2911
                /* first set the jname to the msg_ptr->name */
 
2912
                jname = xstrdup(msg_ptr->name);
 
2913
                /* then grep for " since that is the delimiter for
 
2914
                   the wckey */
 
2915
                if((temp = strchr(jname, '\"'))) {
 
2916
                        if(strrchr(jname, '\"') != temp) {
 
2917
                                error("job %u has quotes in it's name '%s', "
 
2918
                                      "no way to get correct wckey, "
 
2919
                                      "setting name to 'bad_name'", 
 
2920
                                      msg_ptr->job_id, jname);
 
2921
                                xfree(jname);
 
2922
                                jname = xstrdup("bad_name");
 
2923
                        } else {                        
 
2924
                                /* if we have a wckey set the " to NULL to
 
2925
                                 * end the jname */
 
2926
                                temp[0] = '\0';
 
2927
                                /* increment and copy the remainder */
 
2928
                                temp++;
 
2929
                                msg_ptr->wckey = xstrdup(temp);
 
2930
                        }
 
2931
                }
 
2932
                xfree(msg_ptr->name);
 
2933
                msg_ptr->name = xstrdup(jname);
 
2934
                xfree(jname);
2659
2935
        } else {
2660
2936
                safe_unpackstr_xmalloc(&msg_ptr->account, &uint32_tmp, buffer);
2661
2937
                safe_unpack32(&msg_ptr->alloc_cpus, buffer);
2686
2962
}
2687
2963
 
2688
2964
void inline 
2689
 
slurmdbd_pack_job_start_rc_msg(uint16_t rpc_version, 
2690
 
                               dbd_job_start_rc_msg_t *msg, Buf buffer)
 
2965
slurmdbd_pack_id_rc_msg(uint16_t rpc_version, 
 
2966
                        dbd_id_rc_msg_t *msg, Buf buffer)
2691
2967
{
2692
 
        pack32(msg->db_index, buffer);
 
2968
        pack32(msg->id, buffer);
2693
2969
        pack32(msg->return_code, buffer);
2694
2970
}
2695
2971
 
2696
2972
int inline 
2697
 
slurmdbd_unpack_job_start_rc_msg(uint16_t rpc_version, 
2698
 
                                 dbd_job_start_rc_msg_t **msg, Buf buffer)
 
2973
slurmdbd_unpack_id_rc_msg(uint16_t rpc_version, 
 
2974
                          dbd_id_rc_msg_t **msg, Buf buffer)
2699
2975
{
2700
 
        dbd_job_start_rc_msg_t *msg_ptr = 
2701
 
                xmalloc(sizeof(dbd_job_start_rc_msg_t));
 
2976
        dbd_id_rc_msg_t *msg_ptr = xmalloc(sizeof(dbd_id_rc_msg_t));
2702
2977
        *msg = msg_ptr;
2703
 
        safe_unpack32(&msg_ptr->db_index, buffer);
 
2978
        safe_unpack32(&msg_ptr->id, buffer);
2704
2979
        safe_unpack32(&msg_ptr->return_code, buffer);
2705
2980
        return SLURM_SUCCESS;
2706
2981
 
2707
2982
unpack_error:
2708
 
        slurmdbd_free_job_start_rc_msg(rpc_version, msg_ptr);
 
2983
        slurmdbd_free_id_rc_msg(rpc_version, msg_ptr);
2709
2984
        *msg = NULL;
2710
2985
        return SLURM_ERROR;
2711
2986
}
2764
3039
        case DBD_GOT_CLUSTERS:
2765
3040
                my_function = pack_acct_cluster_rec;
2766
3041
                break;
 
3042
        case DBD_GOT_CONFIG:
 
3043
                my_function = pack_config_key_pair;
 
3044
                break;
2767
3045
        case DBD_GOT_JOBS:
2768
3046
                my_function = pack_jobacct_job_rec;
2769
3047
                break;
2774
3052
        case DBD_GOT_QOS:
2775
3053
                my_function = pack_acct_qos_rec;
2776
3054
                break;
 
3055
        case DBD_GOT_RESVS:
 
3056
                my_function = pack_acct_reservation_rec;
 
3057
                break;
2777
3058
        case DBD_ADD_WCKEYS:
2778
3059
        case DBD_GOT_WCKEYS:
2779
3060
                my_function = pack_acct_wckey_rec;
2785
3066
        case DBD_GOT_TXN:
2786
3067
                my_function = pack_acct_txn_rec;
2787
3068
                break;
2788
 
        case DBD_UPDATE_SHARES_USED:
2789
 
                my_function = pack_update_shares_used;
2790
 
                break;
2791
3069
        default:
2792
3070
                fatal("Unknown pack type");
2793
3071
                return;
2835
3113
                my_function = unpack_acct_cluster_rec;
2836
3114
                my_destroy = destroy_acct_cluster_rec;
2837
3115
                break;
 
3116
        case DBD_GOT_CONFIG:
 
3117
                my_function = unpack_config_key_pair;
 
3118
                my_destroy = destroy_config_key_pair;
 
3119
                break;
2838
3120
        case DBD_GOT_JOBS:
2839
3121
                my_function = unpack_jobacct_job_rec;
2840
3122
                my_destroy = destroy_jobacct_job_rec;
2848
3130
                my_function = unpack_acct_qos_rec;
2849
3131
                my_destroy = destroy_acct_qos_rec;
2850
3132
                break;
 
3133
        case DBD_GOT_RESVS:
 
3134
                my_function = unpack_acct_reservation_rec;
 
3135
                my_destroy = destroy_acct_reservation_rec;
 
3136
                break;
2851
3137
        case DBD_ADD_WCKEYS:
2852
3138
        case DBD_GOT_WCKEYS:
2853
3139
                my_function = unpack_acct_wckey_rec;
2862
3148
                my_function = unpack_acct_txn_rec;
2863
3149
                my_destroy = destroy_acct_txn_rec;
2864
3150
                break;
2865
 
        case DBD_UPDATE_SHARES_USED:
2866
 
                my_function = unpack_update_shares_used;
2867
 
                my_destroy = destroy_update_shares_rec;
2868
 
                break;
2869
3151
        default:
2870
3152
                fatal("Unknown unpack type");
2871
3153
                return SLURM_ERROR;
2977
3259
slurmdbd_pack_node_state_msg(uint16_t rpc_version,
2978
3260
                             dbd_node_state_msg_t *msg, Buf buffer)
2979
3261
{
2980
 
        packstr(msg->cluster_name, buffer);
2981
 
        pack32(msg->cpu_count, buffer);
2982
 
        packstr(msg->hostlist, buffer);
2983
 
        packstr(msg->reason, buffer);
2984
 
        pack16(msg->new_state, buffer);
2985
 
        pack_time(msg->event_time, buffer);
 
3262
        if(rpc_version >= 5) {
 
3263
                packstr(msg->cluster_name, buffer);
 
3264
                pack32(msg->cpu_count, buffer);
 
3265
                packstr(msg->hostlist, buffer);
 
3266
                packstr(msg->reason, buffer);
 
3267
                pack16(msg->new_state, buffer);
 
3268
                pack_time(msg->event_time, buffer);
 
3269
                pack16(msg->state, buffer);
 
3270
        } else {
 
3271
                packstr(msg->cluster_name, buffer);
 
3272
                pack32(msg->cpu_count, buffer);
 
3273
                packstr(msg->hostlist, buffer);
 
3274
                packstr(msg->reason, buffer);
 
3275
                pack16(msg->new_state, buffer);
 
3276
                pack_time(msg->event_time, buffer);
 
3277
        }
2986
3278
}
2987
3279
 
2988
3280
int inline
2994
3286
 
2995
3287
        msg_ptr = xmalloc(sizeof(dbd_node_state_msg_t));
2996
3288
        *msg = msg_ptr;
2997
 
        safe_unpackstr_xmalloc(&msg_ptr->cluster_name, &uint32_tmp, buffer);
2998
 
        safe_unpack32(&msg_ptr->cpu_count, buffer);
2999
 
        safe_unpackstr_xmalloc(&msg_ptr->hostlist, &uint32_tmp, buffer);
3000
 
        safe_unpackstr_xmalloc(&msg_ptr->reason,   &uint32_tmp, buffer);
3001
 
        safe_unpack16(&msg_ptr->new_state, buffer);
3002
 
        safe_unpack_time(&msg_ptr->event_time, buffer);
 
3289
 
 
3290
        if(rpc_version >= 5) {
 
3291
                safe_unpackstr_xmalloc(&msg_ptr->cluster_name, 
 
3292
                                       &uint32_tmp, buffer);
 
3293
                safe_unpack32(&msg_ptr->cpu_count, buffer);
 
3294
                safe_unpackstr_xmalloc(&msg_ptr->hostlist, &uint32_tmp, buffer);
 
3295
                safe_unpackstr_xmalloc(&msg_ptr->reason,   &uint32_tmp, buffer);
 
3296
                safe_unpack16(&msg_ptr->new_state, buffer);
 
3297
                safe_unpack_time(&msg_ptr->event_time, buffer);
 
3298
                safe_unpack16(&msg_ptr->state, buffer);
 
3299
        } else {
 
3300
                safe_unpackstr_xmalloc(&msg_ptr->cluster_name, 
 
3301
                                       &uint32_tmp, buffer);
 
3302
                safe_unpack32(&msg_ptr->cpu_count, buffer);
 
3303
                safe_unpackstr_xmalloc(&msg_ptr->hostlist, &uint32_tmp, buffer);
 
3304
                safe_unpackstr_xmalloc(&msg_ptr->reason,   &uint32_tmp, buffer);
 
3305
                safe_unpack16(&msg_ptr->new_state, buffer);
 
3306
                safe_unpack_time(&msg_ptr->event_time, buffer); 
 
3307
        }
 
3308
 
3003
3309
        return SLURM_SUCCESS;
3004
3310
 
3005
3311
unpack_error:
3065
3371
slurmdbd_pack_roll_usage_msg(uint16_t rpc_version,
3066
3372
                             dbd_roll_usage_msg_t *msg, Buf buffer)
3067
3373
{
3068
 
        pack_time(msg->start, buffer);
 
3374
        if(rpc_version >= 5) {
 
3375
                pack16(msg->archive_data, buffer);
 
3376
                pack_time(msg->end, buffer);
 
3377
                pack_time(msg->start, buffer);
 
3378
        } else {
 
3379
                pack_time(msg->start, buffer);
 
3380
        }
3069
3381
}
3070
3382
 
3071
3383
int inline 
3075
3387
        dbd_roll_usage_msg_t *msg_ptr = xmalloc(sizeof(dbd_roll_usage_msg_t));
3076
3388
 
3077
3389
        *msg = msg_ptr;
3078
 
        safe_unpack_time(&msg_ptr->start, buffer);
 
3390
 
 
3391
        if(rpc_version >= 5) {
 
3392
                safe_unpack16(&msg_ptr->archive_data, buffer);
 
3393
                safe_unpack_time(&msg_ptr->end, buffer);
 
3394
                safe_unpack_time(&msg_ptr->start, buffer);
 
3395
        } else {
 
3396
                safe_unpack_time(&msg_ptr->start, buffer);
 
3397
        }
3079
3398
        return SLURM_SUCCESS;
3080
3399
        
3081
3400
unpack_error:
3130
3449
slurmdbd_pack_step_start_msg(uint16_t rpc_version, dbd_step_start_msg_t *msg,
3131
3450
                             Buf buffer)
3132
3451
{
3133
 
        pack32(msg->assoc_id, buffer);
3134
 
        pack32(msg->db_index, buffer);
3135
 
        pack32(msg->job_id, buffer);
3136
 
        packstr(msg->name, buffer);
3137
 
        packstr(msg->nodes, buffer);
3138
 
        pack_time(msg->start_time, buffer);
3139
 
        pack_time(msg->job_submit_time, buffer);
3140
 
        pack32(msg->step_id, buffer);
3141
 
        pack32(msg->total_procs, buffer);
 
3452
        if(rpc_version >= 5) {
 
3453
                pack32(msg->assoc_id, buffer);
 
3454
                pack32(msg->db_index, buffer);
 
3455
                pack32(msg->job_id, buffer);
 
3456
                packstr(msg->name, buffer);
 
3457
                packstr(msg->nodes, buffer);
 
3458
                packstr(msg->node_inx, buffer);
 
3459
                pack32(msg->node_cnt, buffer);
 
3460
                pack_time(msg->start_time, buffer);
 
3461
                pack_time(msg->job_submit_time, buffer);
 
3462
                pack32(msg->step_id, buffer);
 
3463
                pack16(msg->task_dist, buffer);
 
3464
                pack32(msg->total_procs, buffer);
 
3465
                pack32(msg->total_tasks, buffer);
 
3466
        } else {
 
3467
                pack32(msg->assoc_id, buffer);
 
3468
                pack32(msg->db_index, buffer);
 
3469
                pack32(msg->job_id, buffer);
 
3470
                packstr(msg->name, buffer);
 
3471
                packstr(msg->nodes, buffer);
 
3472
                pack_time(msg->start_time, buffer);
 
3473
                pack_time(msg->job_submit_time, buffer);
 
3474
                pack32(msg->step_id, buffer);
 
3475
                pack32(msg->total_procs, buffer);
 
3476
        }
3142
3477
}
3143
3478
 
3144
3479
int inline 
3148
3483
        uint32_t uint32_tmp;
3149
3484
        dbd_step_start_msg_t *msg_ptr = xmalloc(sizeof(dbd_step_start_msg_t));
3150
3485
        *msg = msg_ptr;
3151
 
        safe_unpack32(&msg_ptr->assoc_id, buffer);
3152
 
        safe_unpack32(&msg_ptr->db_index, buffer);
3153
 
        safe_unpack32(&msg_ptr->job_id, buffer);
3154
 
        safe_unpackstr_xmalloc(&msg_ptr->name, &uint32_tmp, buffer);
3155
 
        safe_unpackstr_xmalloc(&msg_ptr->nodes, &uint32_tmp, buffer);
3156
 
        safe_unpack_time(&msg_ptr->start_time, buffer);
3157
 
        safe_unpack_time(&msg_ptr->job_submit_time, buffer);
3158
 
        safe_unpack32(&msg_ptr->step_id, buffer);
3159
 
        safe_unpack32(&msg_ptr->total_procs, buffer);
 
3486
        if(rpc_version >= 5) {
 
3487
                safe_unpack32(&msg_ptr->assoc_id, buffer);
 
3488
                safe_unpack32(&msg_ptr->db_index, buffer);
 
3489
                safe_unpack32(&msg_ptr->job_id, buffer);
 
3490
                safe_unpackstr_xmalloc(&msg_ptr->name, &uint32_tmp, buffer);
 
3491
                safe_unpackstr_xmalloc(&msg_ptr->nodes, &uint32_tmp, buffer);
 
3492
                safe_unpackstr_xmalloc(&msg_ptr->node_inx, &uint32_tmp, buffer);
 
3493
                safe_unpack32(&msg_ptr->node_cnt, buffer);
 
3494
                safe_unpack_time(&msg_ptr->start_time, buffer);
 
3495
                safe_unpack_time(&msg_ptr->job_submit_time, buffer);
 
3496
                safe_unpack32(&msg_ptr->step_id, buffer);
 
3497
                safe_unpack16(&msg_ptr->task_dist, buffer);
 
3498
                safe_unpack32(&msg_ptr->total_procs, buffer);
 
3499
                safe_unpack32(&msg_ptr->total_tasks, buffer);
 
3500
        } else {
 
3501
                safe_unpack32(&msg_ptr->assoc_id, buffer);
 
3502
                safe_unpack32(&msg_ptr->db_index, buffer);
 
3503
                safe_unpack32(&msg_ptr->job_id, buffer);
 
3504
                safe_unpackstr_xmalloc(&msg_ptr->name, &uint32_tmp, buffer);
 
3505
                safe_unpackstr_xmalloc(&msg_ptr->nodes, &uint32_tmp, buffer);
 
3506
                safe_unpack_time(&msg_ptr->start_time, buffer);
 
3507
                safe_unpack_time(&msg_ptr->job_submit_time, buffer);
 
3508
                safe_unpack32(&msg_ptr->step_id, buffer);
 
3509
                safe_unpack32(&msg_ptr->total_procs, buffer);           
 
3510
        }
 
3511
 
3160
3512
        return SLURM_SUCCESS;
3161
3513
 
3162
3514
unpack_error: