Ignore:
Timestamp:
Nov 14, 2012, 12:59:34 PM (13 years ago)
Author:
Silvan Scherrer
Message:

Samba Server: update vendor to 3.6.0

File:
1 edited

Legend:

Unmodified
Added
Removed

  • vendor/current/source3/smbd/blocking.c

    r427 r740  
    1919
    2020#include "includes.h"
     21#include "smbd/smbd.h"
    2122#include "smbd/globals.h"
     23#include "messages.h"
    2224
    2325#undef DBGC_CLASS
    … …  
    3436                                DATA_BLOB *data);
    3537
    36 static void brl_timeout_fn(struct event_context *event_ctx,
     38void brl_timeout_fn(struct event_context *event_ctx,
    3739                           struct timed_event *te,
    3840                           struct timeval now,
    3941                           void *private_data)
    4042{
    41         SMB_ASSERT(brl_timeout == te);
    42         TALLOC_FREE(brl_timeout);
     43        struct smbd_server_connection *sconn = talloc_get_type_abort(
     44                private_data, struct smbd_server_connection);
     45
     46        if (sconn->using_smb2) {
     47                SMB_ASSERT(sconn->smb2.locks.brl_timeout == te);
     48                TALLOC_FREE(sconn->smb2.locks.brl_timeout);
     49        } else {
     50                SMB_ASSERT(sconn->smb1.locks.brl_timeout == te);
     51                TALLOC_FREE(sconn->smb1.locks.brl_timeout);
     52        }
    4353
    4454        change_to_root_user();  /* TODO: Possibly run all timed events as
    4555                                 * root */
    4656
    47         process_blocking_lock_queue();
     57        process_blocking_lock_queue(sconn);
    4858}
    4959
    … …  
    5262****************************************************************************/
    5363
    54 static struct timeval timeval_brl_min(const struct timeval *tv1,
     64struct timeval timeval_brl_min(const struct timeval *tv1,
    5565                                        const struct timeval *tv2)
    5666{
    … …  
    6979****************************************************************************/
    7080
    71 static bool recalc_brl_timeout(void)
     81static bool recalc_brl_timeout(struct smbd_server_connection *sconn)
    7282{
    7383        struct blocking_lock_record *blr;
    … …  
    7585        int max_brl_timeout = lp_parm_int(-1, "brl", "recalctime", 5);
    7686
    77         TALLOC_FREE(brl_timeout);
    78 
    79         next_timeout = timeval_zero(); 
    80 
    81         for (blr = blocking_lock_queue; blr; blr = blr->next) {
     87        TALLOC_FREE(sconn->smb1.locks.brl_timeout);
     88
     89        next_timeout = timeval_zero();
     90
     91        for (blr = sconn->smb1.locks.blocking_lock_queue; blr; blr = blr->next) {
    8292                if (timeval_is_zero(&blr->expire_time)) {
    8393                        /*
    84                          * If we're blocked on pid 0xFFFFFFFF this is
     94                         * If we're blocked on pid 0xFFFFFFFFFFFFFFFFLL this is
    8595                         * a POSIX lock, so calculate a timeout of
    8696                         * 10 seconds into the future.
    8797                         */
    88                         if (blr->blocking_pid == 0xFFFFFFFF) {
     98                        if (blr->blocking_smblctx == 0xFFFFFFFFFFFFFFFFLL) {
    8999                                struct timeval psx_to = timeval_current_ofs(10, 0);
    90100                                next_timeout = timeval_brl_min(&next_timeout, &psx_to);
    … …  
    118128        if (max_brl_timeout > 0) {
    119129                struct timeval min_to = timeval_current_ofs(max_brl_timeout, 0);
    120                 next_timeout = timeval_min(&next_timeout, &min_to);             
     130                next_timeout = timeval_min(&next_timeout, &min_to);
    121131        }
    122132
    … …  
    130140        }
    131141
    132         if (!(brl_timeout = event_add_timed(smbd_event_context(), NULL,
    133                                             next_timeout,
    134                                             brl_timeout_fn, NULL))) {
     142        sconn->smb1.locks.brl_timeout = event_add_timed(smbd_event_context(),
     143                                                        NULL, next_timeout,
     144                                                        brl_timeout_fn, sconn);
     145        if (sconn->smb1.locks.brl_timeout == NULL) {
    135146                return False;
    136147        }
    … …  
    149160                int lock_timeout,
    150161                int lock_num,
    151                 uint32_t lock_pid,
     162                uint64_t smblctx,
    152163                enum brl_type lock_type,
    153164                enum brl_flavour lock_flav,
    154165                uint64_t offset,
    155166                uint64_t count,
    156                 uint32_t blocking_pid)
    157 {
     167                uint64_t blocking_smblctx)
     168{
     169        struct smbd_server_connection *sconn = req->sconn;
    158170        struct blocking_lock_record *blr;
    159171        NTSTATUS status;
     172
     173        if (req->smb2req) {
     174                return push_blocking_lock_request_smb2(br_lck,
     175                                req,
     176                                fsp,
     177                                lock_timeout,
     178                                lock_num,
     179                                smblctx,
     180                                lock_type,
     181                                lock_flav,
     182                                offset,
     183                                count,
     184                                blocking_smblctx);
     185        }
    160186
    161187        if(req_is_in_chain(req)) {
    … …  
    187213        }
    188214        blr->lock_num = lock_num;
    189         blr->lock_pid = lock_pid;
    190         blr->blocking_pid = blocking_pid;
     215        blr->smblctx = smblctx;
     216        blr->blocking_smblctx = blocking_smblctx;
    191217        blr->lock_flav = lock_flav;
    192218        blr->lock_type = lock_type;
    … …  
    198224
    199225        /* Add a pending lock record for this. */
    200         status = brl_lock(smbd_messaging_context(),
     226        status = brl_lock(req->sconn->msg_ctx,
    201227                        br_lck,
    202                         lock_pid,
    203                         procid_self(),
     228                        smblctx,
     229                        sconn_server_id(req->sconn),
    204230                        offset,
    205231                        count,
    … …  
    219245        blr->req = talloc_move(blr, &req);
    220246
    221         DLIST_ADD_END(blocking_lock_queue, blr, struct blocking_lock_record *);
    222         recalc_brl_timeout();
     247        DLIST_ADD_END(sconn->smb1.locks.blocking_lock_queue, blr, struct blocking_lock_record *);
     248        recalc_brl_timeout(sconn);
    223249
    224250        /* Ensure we'll receive messages when this is unlocked. */
    225         if (!blocking_lock_unlock_state) {
    226                 messaging_register(smbd_messaging_context(), NULL,
     251        if (!sconn->smb1.locks.blocking_lock_unlock_state) {
     252                messaging_register(sconn->msg_ctx, NULL,
    227253                                   MSG_SMB_UNLOCK, received_unlock_msg);
    228                 blocking_lock_unlock_state = true;
     254                sconn->smb1.locks.blocking_lock_unlock_state = true;
    229255        }
    230256
    … …  
    275301
    276302                if (fsp) {
    277                         fsp->last_lock_failure.context.smbpid = blr->lock_pid;
     303                        fsp->last_lock_failure.context.smblctx = blr->smblctx;
    278304                        fsp->last_lock_failure.context.tid = fsp->conn->cnum;
    279                         fsp->last_lock_failure.context.pid = procid_self();
     305                        fsp->last_lock_failure.context.pid =
     306                                sconn_server_id(fsp->conn->sconn);
    280307                        fsp->last_lock_failure.start = blr->offset;
    281308                        fsp->last_lock_failure.size = blr->count;
    … …  
    287314
    288315        reply_nterror(blr->req, status);
    289         if (!srv_send_smb(smbd_server_fd(), (char *)blr->req->outbuf,
     316        if (!srv_send_smb(blr->req->sconn, (char *)blr->req->outbuf,
    290317                          true, blr->req->seqnum+1,
    291318                          blr->req->encrypted, NULL)) {
    … …  
    305332        uint16 num_ulocks = SVAL(blr->req->vwv+6, 0);
    306333        uint64_t count = (uint64_t)0, offset = (uint64_t) 0;
    307         uint32 lock_pid;
     334        uint64_t smblctx;
    308335        unsigned char locktype = CVAL(blr->req->vwv+3, 0);
    309336        bool large_file_format = (locktype & LOCKING_ANDX_LARGE_FILES);
    … …  
    328355                bool err;
    329356
    330                 lock_pid = get_lock_pid( data, i, large_file_format);
     357                smblctx = get_lock_pid( data, i, large_file_format);
    331358                count = get_lock_count( data, i, large_file_format);
    332359                offset = get_lock_offset( data, i, large_file_format, &err);
    … …  
    337364                 */
    338365
    339                 do_unlock(smbd_messaging_context(),
     366                do_unlock(fsp->conn->sconn->msg_ctx,
    340367                        fsp,
    341                         lock_pid,
     368                        smblctx,
    342369                        count,
    343370                        offset,
    … …  
    370397                SCVAL(blr->req->outbuf,smb_com,SMBtrans2);
    371398
    372                 if (!srv_send_smb(smbd_server_fd(),
     399                if (!srv_send_smb(blr->req->sconn,
    373400                                  (char *)blr->req->outbuf,
    374401                                  true, blr->req->seqnum+1,
    … …  
    398425        uint16 num_locks = SVAL(blr->req->vwv+7, 0);
    399426        uint64_t count = (uint64_t)0, offset = (uint64_t)0;
    400         uint32 lock_pid;
     427        uint64_t smblctx;
    401428        bool large_file_format = (locktype & LOCKING_ANDX_LARGE_FILES);
    402429        uint8_t *data;
    … …  
    415442                bool err;
    416443
    417                 lock_pid = get_lock_pid( data, blr->lock_num, large_file_format);
     444                smblctx = get_lock_pid( data, blr->lock_num, large_file_format);
    418445                count = get_lock_count( data, blr->lock_num, large_file_format);
    419446                offset = get_lock_offset( data, blr->lock_num, large_file_format, &err);
    … …  
    424451                 */
    425452                errno = 0;
    426                 br_lck = do_lock(smbd_messaging_context(),
     453                br_lck = do_lock(fsp->conn->sconn->msg_ctx,
    427454                                fsp,
    428                                 lock_pid,
     455                                smblctx,
    429456                                count,
    430                                 offset, 
     457                                offset,
    431458                                ((locktype & LOCKING_ANDX_SHARED_LOCK) ?
    432459                                        READ_LOCK : WRITE_LOCK),
    … …  
    434461                                True,
    435462                                &status,
    436                                 &blr->blocking_pid,
     463                                &blr->blocking_smblctx,
    437464                                blr);
    438465
    … …  
    488515        char params[2];
    489516        NTSTATUS status;
    490         struct byte_range_lock *br_lck = do_lock(smbd_messaging_context(),
     517        struct byte_range_lock *br_lck = do_lock(
     518                                                blr->fsp->conn->sconn->msg_ctx,
    491519                                                blr->fsp,
    492                                                 blr->lock_pid,
     520                                                blr->smblctx,
    493521                                                blr->count,
    494522                                                blr->offset,
    … …  
    497525                                                True,
    498526                                                &status,
    499                                                 &blr->blocking_pid,
     527                                                &blr->blocking_smblctx,
    500528                                                blr);
    501529        TALLOC_FREE(br_lck);
    … …  
    545573/****************************************************************************
    546574 Cancel entries by fnum from the blocking lock pending queue.
    547 *****************************************************************************/
    548 
    549 void cancel_pending_lock_requests_by_fid(files_struct *fsp, struct byte_range_lock *br_lck)
    550 {
     575 Called when a file is closed.
     576*****************************************************************************/
     577
     578void cancel_pending_lock_requests_by_fid(files_struct *fsp,
     579                        struct byte_range_lock *br_lck,
     580                        enum file_close_type close_type)
     581{
     582        struct smbd_server_connection *sconn = fsp->conn->sconn;
    551583        struct blocking_lock_record *blr, *blr_cancelled, *next = NULL;
    552584
    553         for(blr = blocking_lock_queue; blr; blr = next) {
     585        if (sconn->using_smb2) {
     586                cancel_pending_lock_requests_by_fid_smb2(fsp,
     587                                        br_lck,
     588                                        close_type);
     589                return;
     590        }
     591
     592        for(blr = sconn->smb1.locks.blocking_lock_queue; blr; blr = next) {
    554593                unsigned char locktype = 0;
    555594
    … …  
    567606                           blr->req->cmd, fsp_str_dbg(fsp), fsp->fnum));
    568607
    569                 blr_cancelled = blocking_lock_cancel(fsp,
    570                                      blr->lock_pid,
     608                blr_cancelled = blocking_lock_cancel_smb1(fsp,
     609                                     blr->smblctx,
    571610                                     blr->offset,
    572611                                     blr->count,
    … …  
    578617
    579618                brl_lock_cancel(br_lck,
    580                                 blr->lock_pid,
    581                                 procid_self(),
     619                                blr->smblctx,
     620                                sconn_server_id(sconn),
    582621                                blr->offset,
    583622                                blr->count,
    … …  
    593632/****************************************************************************
    594633 Delete entries by mid from the blocking lock pending queue. Always send reply.
    595 *****************************************************************************/
    596 
    597 void remove_pending_lock_requests_by_mid(int mid)
     634 Only called from the SMB1 cancel code.
     635*****************************************************************************/
     636
     637void remove_pending_lock_requests_by_mid_smb1(
     638        struct smbd_server_connection *sconn, uint64_t mid)
    598639{
    599640        struct blocking_lock_record *blr, *next = NULL;
    600641
    601         for(blr = blocking_lock_queue; blr; blr = next) {
     642        for(blr = sconn->smb1.locks.blocking_lock_queue; blr; blr = next) {
    602643                files_struct *fsp;
    603644                struct byte_range_lock *br_lck;
    … …  
    613654
    614655                if (br_lck) {
    615                         DEBUG(10, ("remove_pending_lock_requests_by_mid - "
     656                        DEBUG(10, ("remove_pending_lock_requests_by_mid_smb1 - "
    616657                                   "removing request type %d for file %s fnum "
    617658                                   "= %d\n", blr->req->cmd, fsp_str_dbg(fsp),
    … …  
    619660
    620661                        brl_lock_cancel(br_lck,
    621                                         blr->lock_pid,
    622                                         procid_self(),
     662                                        blr->smblctx,
     663                                        sconn_server_id(sconn),
    623664                                        blr->offset,
    624665                                        blr->count,
    … …  
    629670
    630671                blocking_lock_reply_error(blr,NT_STATUS_FILE_LOCK_CONFLICT);
    631                 DLIST_REMOVE(blocking_lock_queue, blr);
     672                DLIST_REMOVE(sconn->smb1.locks.blocking_lock_queue, blr);
    632673                TALLOC_FREE(blr);
    633674        }
    … …  
    636677/****************************************************************************
    637678 Is this mid a blocking lock request on the queue ?
    638 *****************************************************************************/
    639 
    640 bool blocking_lock_was_deferred(int mid)
     679 Currently only called from the SMB1 unix extensions POSIX lock code.
     680*****************************************************************************/
     681
     682bool blocking_lock_was_deferred_smb1(
     683        struct smbd_server_connection *sconn, uint64_t mid)
    641684{
    642685        struct blocking_lock_record *blr, *next = NULL;
    643686
    644         for(blr = blocking_lock_queue; blr; blr = next) {
     687        for(blr = sconn->smb1.locks.blocking_lock_queue; blr; blr = next) {
    645688                next = blr->next;
    646689                if(blr->req->mid == mid) {
    … …  
    661704                                DATA_BLOB *data)
    662705{
     706        struct smbd_server_connection *sconn;
     707
     708        sconn = msg_ctx_to_sconn(msg);
     709        if (sconn == NULL) {
     710                DEBUG(1, ("could not find sconn\n"));
     711                return;
     712        }
     713
    663714        DEBUG(10,("received_unlock_msg\n"));
    664         process_blocking_lock_queue();
     715        process_blocking_lock_queue(sconn);
    665716}
    666717
    … …  
    669720*****************************************************************************/
    670721
    671 void process_blocking_lock_queue(void)
     722void process_blocking_lock_queue(struct smbd_server_connection *sconn)
    672723{
    673724        struct timeval tv_curr = timeval_current();
    674725        struct blocking_lock_record *blr, *next = NULL;
     726
     727        if (sconn->using_smb2) {
     728                process_blocking_lock_queue_smb2(sconn, tv_curr);
     729                return;
     730        }
    675731
    676732        /*
    … …  
    678734         */
    679735
    680         for (blr = blocking_lock_queue; blr; blr = next) {
     736        for (blr = sconn->smb1.locks.blocking_lock_queue; blr; blr = next) {
    681737
    682738                next = blr->next;
    … …  
    707763                        if (br_lck) {
    708764                                brl_lock_cancel(br_lck,
    709                                         blr->lock_pid,
    710                                         procid_self(),
     765                                        blr->smblctx,
     766                                        sconn_server_id(sconn),
    711767                                        blr->offset,
    712768                                        blr->count,
    … …  
    716772                        }
    717773
    718                         DLIST_REMOVE(blocking_lock_queue, blr);
     774                        DLIST_REMOVE(sconn->smb1.locks.blocking_lock_queue, blr);
    719775                        TALLOC_FREE(blr);
    720776                        continue;
    … …  
    744800
    745801                                brl_lock_cancel(br_lck,
    746                                         blr->lock_pid,
    747                                         procid_self(),
     802                                        blr->smblctx,
     803                                        sconn_server_id(sconn),
    748804                                        blr->offset,
    749805                                        blr->count,
    … …  
    754810
    755811                        blocking_lock_reply_error(blr,NT_STATUS_FILE_LOCK_CONFLICT);
    756                         DLIST_REMOVE(blocking_lock_queue, blr);
     812                        DLIST_REMOVE(sconn->smb1.locks.blocking_lock_queue, blr);
    757813                        TALLOC_FREE(blr);
    758814                }
    759815        }
    760816
    761         recalc_brl_timeout();
     817        recalc_brl_timeout(sconn);
    762818}
    763819
    … …  
    774830                                                 DATA_BLOB *data)
    775831{
     832        struct smbd_server_connection *sconn;
    776833        NTSTATUS err;
    777834        const char *msg = (const char *)data->data;
    … …  
    788845        }
    789846
     847        sconn = msg_ctx_to_sconn(ctx);
     848        if (sconn == NULL) {
     849                DEBUG(1, ("could not find sconn\n"));
     850                return;
     851        }
     852
    790853        memcpy(&blr, msg, sizeof(blr));
    791854        memcpy(&err, &msg[sizeof(blr)], sizeof(NTSTATUS));
    … …  
    795858
    796859        blocking_lock_reply_error(blr, err);
    797         DLIST_REMOVE(blocking_lock_cancelled_queue, blr);
     860        DLIST_REMOVE(sconn->smb1.locks.blocking_lock_cancelled_queue, blr);
    798861        TALLOC_FREE(blr);
    799862}
    … …  
    802865 Send ourselves a blocking lock cancelled message. Handled asynchronously above.
    803866 Returns the blocking_lock_record that is being cancelled.
    804 *****************************************************************************/
    805 
    806 struct blocking_lock_record *blocking_lock_cancel(files_struct *fsp,
    807                         uint32 lock_pid,
     867 Only called from the SMB1 code.
     868*****************************************************************************/
     869
     870struct blocking_lock_record *blocking_lock_cancel_smb1(files_struct *fsp,
     871                        uint64_t smblctx,
    808872                        uint64_t offset,
    809873                        uint64_t count,
    … …  
    812876                        NTSTATUS err)
    813877{
     878        struct smbd_server_connection *sconn = fsp->conn->sconn;
    814879        char msg[MSG_BLOCKING_LOCK_CANCEL_SIZE];
    815880        struct blocking_lock_record *blr;
    816881
    817         if (!blocking_lock_cancel_state) {
     882        if (!sconn->smb1.locks.blocking_lock_cancel_state) {
    818883                /* Register our message. */
    819                 messaging_register(smbd_messaging_context(), NULL,
     884                messaging_register(sconn->msg_ctx, NULL,
    820885                                   MSG_SMB_BLOCKING_LOCK_CANCEL,
    821886                                   process_blocking_lock_cancel_message);
    822887
    823                 blocking_lock_cancel_state = True;
    824         }
    825 
    826         for (blr = blocking_lock_queue; blr; blr = blr->next) {
     888                sconn->smb1.locks.blocking_lock_cancel_state = True;
     889        }
     890
     891        for (blr = sconn->smb1.locks.blocking_lock_queue; blr; blr = blr->next) {
    827892                if (fsp == blr->fsp &&
    828                                 lock_pid == blr->lock_pid &&
     893                                smblctx == blr->smblctx &&
    829894                                offset == blr->offset &&
    830895                                count == blr->count &&
    … …  
    846911
    847912        /* Move to cancelled queue. */
    848         DLIST_REMOVE(blocking_lock_queue, blr);
    849         DLIST_ADD(blocking_lock_cancelled_queue, blr);
     913        DLIST_REMOVE(sconn->smb1.locks.blocking_lock_queue, blr);
     914        DLIST_ADD(sconn->smb1.locks.blocking_lock_cancelled_queue, blr);
    850915
    851916        /* Create the message. */
    … …  
    853918        memcpy(&msg[sizeof(blr)], &err, sizeof(NTSTATUS));
    854919
    855         messaging_send_buf(smbd_messaging_context(), procid_self(),
     920        messaging_send_buf(sconn->msg_ctx, sconn_server_id(sconn),
    856921                           MSG_SMB_BLOCKING_LOCK_CANCEL,
    857922                           (uint8 *)&msg, sizeof(msg));
Note: See TracChangeset for help on using the changeset viewer.