Ignore:
Timestamp:
Nov 25, 2016, 8:04:54 PM (9 years ago)
Author:
Silvan Scherrer
Message:

Samba Server: update vendor to version 4.4.7

Location:
vendor/current/ctdb/protocol
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • vendor/current/ctdb/protocol/protocol.h

    r988 r989  
    121121/* SRVID prefix used by CTDB */
    122122#define CTDB_SRVID_PREFIX       0xF000000000000000LL
     123
     124/* SRVID prefix used during recovery for pulling and pushing databases */
     125#define CTDB_SRVID_RECOVERY     0xF001000000000000LL
     126
     127/* SRVID to assign of banning credits */
     128#define CTDB_SRVID_BANNING      0xF002000000000000LL
    123129
    124130/* SRVID to inform of election data */
    … …  
    356362                    CTDB_CONTROL_DB_TRANSACTION_COMMIT   = 144,
    357363                    CTDB_CONTROL_DB_TRANSACTION_CANCEL   = 145,
     364                    CTDB_CONTROL_DB_PULL                 = 146,
     365                    CTDB_CONTROL_DB_PUSH_START           = 147,
     366                    CTDB_CONTROL_DB_PUSH_CONFIRM         = 148,
    358367};
    359368
    … …  
    456465#define CTDB_LMASTER_ANY        0xffffffff
    457466        uint32_t lmaster;
     467};
     468
     469struct ctdb_pulldb_ext {
     470        uint32_t db_id;
     471        uint32_t lmaster;
     472        uint64_t srvid;
    458473};
    459474
    … …  
    620635        uint32_t mutex_enabled;
    621636        uint32_t lock_processes_per_db;
     637        uint32_t rec_buffer_size_limit;
    622638};
    623639
    … …  
    705721 */
    706722#define CTDB_CAP_PARALLEL_RECOVERY      0x00010000
    707 
    708 #define CTDB_CAP_FEATURES               (CTDB_CAP_PARALLEL_RECOVERY)
     723#define CTDB_CAP_FRAGMENTED_CONTROLS    0x00020000
     724
     725#define CTDB_CAP_FEATURES               (CTDB_CAP_PARALLEL_RECOVERY | \
     726                                         CTDB_CAP_FRAGMENTED_CONTROLS)
    709727
    710728#define CTDB_CAP_DEFAULT                (CTDB_CAP_RECMASTER | \
    … …  
    856874                uint32_t loglevel;
    857875                struct ctdb_pulldb *pulldb;
     876                struct ctdb_pulldb_ext *pulldb_ext;
    858877                struct ctdb_rec_buffer *recbuf;
    859878                uint32_t recmode;
    … …  
    924943                struct ctdb_db_statistics *dbstats;
    925944                enum ctdb_runstate runstate;
     945                uint32_t num_records;
    926946        } data;
    927947};
    … …  
    977997        /* SRVID_MEM_DUMP, SRVID_TAKEOVER_RUN */
    978998        struct ctdb_srvid_message *msg;
    979         /* SRVID_REBALANCE_NODE */
     999        /* SRVID_BANNING, SRVID_REBALANCE_NODE */
    9801000        uint32_t pnn;
    9811001        /* SRVID_DISABLE_TAKEOVER_RUNS, SRVID_DISABLE_RECOVERIES */

  • vendor/current/ctdb/protocol/protocol_api.h

    r988 r989  
    5353                             void *private_data);
    5454
     55int ctdb_rec_buffer_write(struct ctdb_rec_buffer *recbuf, int fd);
     56int ctdb_rec_buffer_read(int fd, TALLOC_CTX *mem_ctx,
     57                         struct ctdb_rec_buffer **out);
     58
    5559size_t ctdb_server_id_len(struct ctdb_server_id *sid);
    5660void ctdb_server_id_push(struct ctdb_server_id *sid, uint8_t *buf);
    … …  
    635639int ctdb_reply_control_db_transaction_cancel(struct ctdb_reply_control *reply);
    636640
     641void ctdb_req_control_db_pull(struct ctdb_req_control *request,
     642                              struct ctdb_pulldb_ext *pulldb_ext);
     643int ctdb_reply_control_db_pull(struct ctdb_reply_control *reply,
     644                               uint32_t *num_records);
     645
     646void ctdb_req_control_db_push_start(struct ctdb_req_control *request,
     647                                    struct ctdb_pulldb_ext *pulldb_ext);
     648int ctdb_reply_control_db_push_start(struct ctdb_reply_control *reply);
     649
     650void ctdb_req_control_db_push_confirm(struct ctdb_req_control *request,
     651                                      uint32_t db_id);
     652int ctdb_reply_control_db_push_confirm(struct ctdb_reply_control *reply,
     653                                       uint32_t *num_records);
     654
    637655/* From protocol/protocol_message.c */
    638656

  • vendor/current/ctdb/protocol/protocol_client.c

    r988 r989  
    24692469        return ctdb_reply_control_generic(reply);
    24702470}
     2471
     2472/* CTDB_CONTROL_DB_PULL */
     2473
     2474void ctdb_req_control_db_pull(struct ctdb_req_control *request,
     2475                              struct ctdb_pulldb_ext *pulldb_ext)
     2476{
     2477        request->opcode = CTDB_CONTROL_DB_PULL;
     2478        request->pad = 0;
     2479        request->srvid = 0;
     2480        request->client_id = 0;
     2481        request->flags = 0;
     2482
     2483        request->rdata.opcode = CTDB_CONTROL_DB_PULL;
     2484        request->rdata.data.pulldb_ext = pulldb_ext;
     2485}
     2486
     2487int ctdb_reply_control_db_pull(struct ctdb_reply_control *reply,
     2488                               uint32_t *num_records)
     2489{
     2490        if (reply->status == 0 &&
     2491            reply->rdata.opcode == CTDB_CONTROL_DB_PULL) {
     2492                *num_records = reply->rdata.data.num_records;
     2493        }
     2494        return reply->status;
     2495}
     2496
     2497/* CTDB_CONTROL_DB_PUSH_START */
     2498
     2499void ctdb_req_control_db_push_start(struct ctdb_req_control *request,
     2500                                    struct ctdb_pulldb_ext *pulldb_ext)
     2501{
     2502        request->opcode = CTDB_CONTROL_DB_PUSH_START;
     2503        request->pad = 0;
     2504        request->srvid = 0;
     2505        request->client_id = 0;
     2506        request->flags = 0;
     2507
     2508        request->rdata.opcode = CTDB_CONTROL_DB_PUSH_START;
     2509        request->rdata.data.pulldb_ext = pulldb_ext;
     2510}
     2511
     2512int ctdb_reply_control_db_push_start(struct ctdb_reply_control *reply)
     2513{
     2514        return ctdb_reply_control_generic(reply);
     2515}
     2516
     2517/* CTDB_CONTROL_DB_PUSH_CONFIRM */
     2518
     2519void ctdb_req_control_db_push_confirm(struct ctdb_req_control *request,
     2520                                      uint32_t db_id)
     2521{
     2522        request->opcode = CTDB_CONTROL_DB_PUSH_CONFIRM;
     2523        request->pad = 0;
     2524        request->srvid = 0;
     2525        request->client_id = 0;
     2526        request->flags = 0;
     2527
     2528        request->rdata.opcode = CTDB_CONTROL_DB_PUSH_CONFIRM;
     2529        request->rdata.data.db_id = db_id;
     2530}
     2531
     2532int ctdb_reply_control_db_push_confirm(struct ctdb_reply_control *reply,
     2533                                       uint32_t *num_records)
     2534{
     2535        if (reply->status == 0 &&
     2536            reply->rdata.opcode == CTDB_CONTROL_DB_PUSH_CONFIRM) {
     2537                *num_records = reply->rdata.data.num_records;
     2538        }
     2539        return reply->status;
     2540}

  • vendor/current/ctdb/protocol/protocol_control.c

    r988 r989  
    5050{
    5151        size_t len = 0;
    52         uint64_t u64;
    5352
    5453        if (cd == NULL) {
    … …  
    385384
    386385        case CTDB_CONTROL_GET_DB_SEQNUM:
    387                 u64 = cd->data.db_id;
    388                 len = ctdb_uint64_len(u64);
     386                len = ctdb_uint64_len((uint64_t)cd->data.db_id);
    389387                break;
    390388
    … …  
    480478
    481479        case CTDB_CONTROL_DB_TRANSACTION_CANCEL:
     480                len = ctdb_uint32_len(cd->data.db_id);
     481                break;
     482
     483        case CTDB_CONTROL_DB_PULL:
     484                len = ctdb_pulldb_ext_len(cd->data.pulldb_ext);
     485                break;
     486
     487        case CTDB_CONTROL_DB_PUSH_START:
     488                len = ctdb_pulldb_ext_len(cd->data.pulldb_ext);
     489                break;
     490
     491        case CTDB_CONTROL_DB_PUSH_CONFIRM:
    482492                len = ctdb_uint32_len(cd->data.db_id);
    483493                break;
    … …  
    490500                                       uint8_t *buf)
    491501{
    492         uint64_t u64;
    493 
    494502        switch (cd->opcode) {
    495503        case CTDB_CONTROL_PROCESS_EXISTS:
    … …  
    713721
    714722        case CTDB_CONTROL_GET_DB_SEQNUM:
    715                 u64 = cd->data.db_id;
    716                 ctdb_uint64_push(u64, buf);
     723                ctdb_uint32_push(cd->data.db_id, buf);
    717724                break;
    718725
    … …  
    790797
    791798        case CTDB_CONTROL_DB_TRANSACTION_CANCEL:
     799                ctdb_uint32_push(cd->data.db_id, buf);
     800                break;
     801
     802        case CTDB_CONTROL_DB_PULL:
     803                ctdb_pulldb_ext_push(cd->data.pulldb_ext, buf);
     804                break;
     805
     806        case CTDB_CONTROL_DB_PUSH_START:
     807                ctdb_pulldb_ext_push(cd->data.pulldb_ext, buf);
     808                break;
     809
     810        case CTDB_CONTROL_DB_PUSH_CONFIRM:
    792811                ctdb_uint32_push(cd->data.db_id, buf);
    793812                break;
    … …  
    801820{
    802821        int ret = 0;
    803         uint64_t u64 = 0;
    804822
    805823        cd->opcode = opcode;
    … …  
    10801098
    10811099        case CTDB_CONTROL_GET_DB_SEQNUM:
    1082                 ret = ctdb_uint64_pull(buf, buflen, mem_ctx, &u64);
    1083                 cd->data.db_id = (uint32_t)u64;
     1100                ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
     1101                                       &cd->data.db_id);
    10841102                break;
    10851103
    … …  
    11781196                                        &cd->data.db_id);
    11791197                break;
     1198
     1199        case CTDB_CONTROL_DB_PULL:
     1200                ret = ctdb_pulldb_ext_pull(buf, buflen, mem_ctx,
     1201                                           &cd->data.pulldb_ext);
     1202                break;
     1203
     1204        case CTDB_CONTROL_DB_PUSH_START:
     1205                ret = ctdb_pulldb_ext_pull(buf, buflen, mem_ctx,
     1206                                           &cd->data.pulldb_ext);
     1207                break;
     1208
     1209        case CTDB_CONTROL_DB_PUSH_CONFIRM:
     1210                ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
     1211                                       &cd->data.db_id);
     1212                break;
    11801213        }
    11811214
    … …  
    15741607
    15751608        case CTDB_CONTROL_DB_TRANSACTION_CANCEL:
     1609                break;
     1610
     1611        case CTDB_CONTROL_DB_PULL:
     1612                len = ctdb_uint32_len(cd->data.num_records);
     1613                break;
     1614
     1615        case CTDB_CONTROL_DB_PUSH_START:
     1616                break;
     1617
     1618        case CTDB_CONTROL_DB_PUSH_CONFIRM:
     1619                len = ctdb_uint32_len(cd->data.num_records);
    15761620                break;
    15771621        }
    … …  
    17271771                ctdb_node_map_push(cd->data.nodemap, buf);
    17281772                break;
     1773
     1774        case CTDB_CONTROL_DB_PULL:
     1775                ctdb_uint32_push(cd->data.num_records, buf);
     1776                break;
     1777
     1778        case CTDB_CONTROL_DB_PUSH_CONFIRM:
     1779                ctdb_uint32_push(cd->data.num_records, buf);
     1780                break;
    17291781        }
    17301782}
    … …  
    19131965                ret = ctdb_node_map_pull(buf, buflen, mem_ctx,
    19141966                                         &cd->data.nodemap);
     1967                break;
     1968
     1969        case CTDB_CONTROL_DB_PULL:
     1970                ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
     1971                                       &cd->data.num_records);
     1972                break;
     1973
     1974        case CTDB_CONTROL_DB_PUSH_CONFIRM:
     1975                ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
     1976                                       &cd->data.num_records);
    19151977                break;
    19161978        }

  • vendor/current/ctdb/protocol/protocol_message.c

    r988 r989  
    4141
    4242        switch (srvid) {
     43        case CTDB_SRVID_BANNING:
     44                len = ctdb_uint32_len(mdata->pnn);
     45                break;
     46
    4347        case CTDB_SRVID_ELECTION:
    4448                len = ctdb_election_message_len(mdata->election);
    … …  
    115119{
    116120        switch (srvid) {
     121        case CTDB_SRVID_BANNING:
     122                ctdb_uint32_push(mdata->pnn, buf);
     123                break;
     124
    117125        case CTDB_SRVID_ELECTION:
    118126                ctdb_election_message_push(mdata->election, buf);
    … …  
    190198
    191199        switch (srvid) {
     200        case CTDB_SRVID_BANNING:
     201                ret = ctdb_uint32_pull(buf, buflen, mem_ctx, &mdata->pnn);
     202                break;
     203
    192204        case CTDB_SRVID_ELECTION:
    193205                ret = ctdb_election_message_pull(buf, buflen, mem_ctx,

  • vendor/current/ctdb/protocol/protocol_private.h

    r988 r989  
    9191int ctdb_pulldb_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
    9292                     struct ctdb_pulldb **out);
     93
     94size_t ctdb_pulldb_ext_len(struct ctdb_pulldb_ext *pulldb);
     95void ctdb_pulldb_ext_push(struct ctdb_pulldb_ext *pulldb, uint8_t *buf);
     96int ctdb_pulldb_ext_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
     97                         struct ctdb_pulldb_ext **out);
    9398
    9499size_t ctdb_traverse_start_len(struct ctdb_traverse_start *traverse);

  • vendor/current/ctdb/protocol/protocol_types.c

    r988 r989  
    466466
    467467        pulldb = talloc_memdup(mem_ctx, buf, sizeof(struct ctdb_pulldb));
     468        if (pulldb == NULL) {
     469                return ENOMEM;
     470        }
     471
     472        *out = pulldb;
     473        return 0;
     474}
     475
     476size_t ctdb_pulldb_ext_len(struct ctdb_pulldb_ext *pulldb)
     477{
     478        return sizeof(struct ctdb_pulldb_ext);
     479}
     480
     481void ctdb_pulldb_ext_push(struct ctdb_pulldb_ext *pulldb, uint8_t *buf)
     482{
     483        memcpy(buf, pulldb, sizeof(struct ctdb_pulldb_ext));
     484}
     485
     486int ctdb_pulldb_ext_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
     487                         struct ctdb_pulldb_ext **out)
     488{
     489        struct ctdb_pulldb_ext *pulldb;
     490
     491        if (buflen < sizeof(struct ctdb_pulldb_ext)) {
     492                return EMSGSIZE;
     493        }
     494
     495        pulldb = talloc_memdup(mem_ctx, buf, sizeof(struct ctdb_pulldb_ext));
    468496        if (pulldb == NULL) {
    469497                return ENOMEM;
    … …  
    771799
    772800        return ret;
     801}
     802
     803int ctdb_rec_buffer_write(struct ctdb_rec_buffer *recbuf, int fd)
     804{
     805        ssize_t n;
     806
     807        n = write(fd, &recbuf->db_id, sizeof(uint32_t));
     808        if (n == -1 || n != sizeof(uint32_t)) {
     809                return (errno != 0 ? errno : EIO);
     810        }
     811        n = write(fd, &recbuf->count, sizeof(uint32_t));
     812        if (n == -1 || n != sizeof(uint32_t)) {
     813                return (errno != 0 ? errno : EIO);
     814        }
     815        n = write(fd, &recbuf->buflen, sizeof(size_t));
     816        if (n == -1 || n != sizeof(size_t)) {
     817                return (errno != 0 ? errno : EIO);
     818        }
     819        n = write(fd, recbuf->buf, recbuf->buflen);
     820        if (n == -1 || n != recbuf->buflen) {
     821                return (errno != 0 ? errno : EIO);
     822        }
     823
     824        return 0;
     825}
     826
     827int ctdb_rec_buffer_read(int fd, TALLOC_CTX *mem_ctx,
     828                         struct ctdb_rec_buffer **out)
     829{
     830        struct ctdb_rec_buffer *recbuf;
     831        ssize_t n;
     832
     833        recbuf = talloc(mem_ctx, struct ctdb_rec_buffer);
     834        if (recbuf == NULL) {
     835                return ENOMEM;
     836        }
     837
     838        n = read(fd, &recbuf->db_id, sizeof(uint32_t));
     839        if (n == -1 || n != sizeof(uint32_t)) {
     840                return (errno != 0 ? errno : EIO);
     841        }
     842        n = read(fd, &recbuf->count, sizeof(uint32_t));
     843        if (n == -1 || n != sizeof(uint32_t)) {
     844                return (errno != 0 ? errno : EIO);
     845        }
     846        n = read(fd, &recbuf->buflen, sizeof(size_t));
     847        if (n == -1 || n != sizeof(size_t)) {
     848                return (errno != 0 ? errno : EIO);
     849        }
     850
     851        recbuf->buf = talloc_size(recbuf, recbuf->buflen);
     852        if (recbuf->buf == NULL) {
     853                return ENOMEM;
     854        }
     855
     856        n = read(fd, recbuf->buf, recbuf->buflen);
     857        if (n == -1 || n != recbuf->buflen) {
     858                return (errno != 0 ? errno : EIO);
     859        }
     860
     861        *out = recbuf;
     862        return 0;
    773863}
    774864
Note: See TracChangeset for help on using the changeset viewer.