smbd: smb2-operations per-share profile counters

Allow per-share profile counters for SMB2 operations.

Signed-off-by: Shachar Sharon <ssharon@redhat.com>
Reviewed-by: Volker Lendecke <vl@samba.org>
Reviewed-by: Anoop C S <anoopcs@samba.org>

diff --git a/source3/smbd/globals.h b/source3/smbd/globals.h
index fc5184961c6a3d735d5f70b23a6e582d36d25b31..c74762248c1b0ab5ae3a1ef39aa468f01acbdeed 100644 (file)
--- a/source3/smbd/globals.h
+++ b/source3/smbd/globals.h
@@ -657,6 +657,7 @@ struct smbd_smb2_request {
        struct timeval request_time;
 
        SMBPROFILE_IOBYTES_ASYNC_STATE(profile);
+       SMBPROFILE_IOBYTES_ASYNC_STATE(profile_x);
 
        /* fake smb1 request. */
        struct smb_request *smb1req;

diff --git a/source3/smbd/smb2_create.c b/source3/smbd/smb2_create.c
index 6f4f3ed47de382ea6567a8c318e7fed3d6db419e..12e87ec7b6f02729d772c88e0b46904827dbf537 100644 (file)
--- a/source3/smbd/smb2_create.c
+++ b/source3/smbd/smb2_create.c
@@ -1316,7 +1316,8 @@ static struct tevent_req *smbd_smb2_create_send(TALLOC_CTX *mem_ctx,
        }
        if (!NT_STATUS_IS_OK(status)) {
                if (open_was_deferred(smb1req->xconn, smb1req->mid)) {
-                       SMBPROFILE_IOBYTES_ASYNC_SET_IDLE(smb2req->profile);
+                       SMBPROFILE_IOBYTES_ASYNC_SET_IDLE_X(smb2req->profile,
+                                                           smb2req->profile_x);
                        return req;
                }
                tevent_req_nterror(req, status);

diff --git a/source3/smbd/smb2_notify.c b/source3/smbd/smb2_notify.c
index 2f4176f3fbbfe98e13564bda454ed49995221a2e..45ea6046a94989fc1046b83061b58e659304792b 100644 (file)
--- a/source3/smbd/smb2_notify.c
+++ b/source3/smbd/smb2_notify.c
@@ -313,7 +313,8 @@ static struct tevent_req *smbd_smb2_notify_send(TALLOC_CTX *mem_ctx,
        /* allow this request to be canceled */
        tevent_req_set_cancel_fn(req, smbd_smb2_notify_cancel);
 
-       SMBPROFILE_IOBYTES_ASYNC_SET_IDLE(state->smb2req->profile);
+       SMBPROFILE_IOBYTES_ASYNC_SET_IDLE_X(state->smb2req->profile,
+                                           state->smb2req->profile_x);
        return req;
 }
 
@@ -330,7 +331,8 @@ static void smbd_smb2_notify_reply(struct smb_request *smbreq,
                return;
        }
 
-       SMBPROFILE_IOBYTES_ASYNC_SET_BUSY(state->smb2req->profile);
+       SMBPROFILE_IOBYTES_ASYNC_SET_BUSY_X(state->smb2req->profile,
+                                           state->smb2req->profile_x);
 
        state->status = error_code;
        if (!NT_STATUS_IS_OK(error_code)) {

diff --git a/source3/smbd/smb2_server.c b/source3/smbd/smb2_server.c
index ff0e708e938d8ec5e41059da400c3d211a104096..138ada1db5965258d0f06f87c9f6415a3966f9f3 100644 (file)
--- a/source3/smbd/smb2_server.c
+++ b/source3/smbd/smb2_server.c
@@ -3056,6 +3056,13 @@ static NTSTATUS smbd_smb2_request_dispatch_update_counts(
        return status;
 }
 
+static int smb2_request_to_snum(const struct smbd_smb2_request *req)
+{
+       return (req->tcon != NULL) && (req->tcon->compat != NULL)
+                      ? SNUM(req->tcon->compat)
+                      : GLOBAL_SECTION_SNUM;
+}
+
 NTSTATUS smbd_smb2_request_dispatch(struct smbd_smb2_request *req)
 {
        struct smbXsrv_connection *xconn = req->xconn;
@@ -3483,89 +3490,131 @@ skipped_signing:
 
        switch (opcode) {
        case SMB2_OP_NEGPROT:
-               SMBPROFILE_IOBYTES_ASYNC_START(smb2_negprot, profile_p,
-                                              req->profile, _INBYTES(req));
+               SMBPROFILE_IOBYTES_ASYNC_START_X(smb2_request_to_snum(req),
+                                                smb2_negprot,
+                                                req->profile,
+                                                req->profile_x,
+                                                _INBYTES(req));
                return_value = smbd_smb2_request_process_negprot(req);
                break;
 
        case SMB2_OP_SESSSETUP:
-               SMBPROFILE_IOBYTES_ASYNC_START(smb2_sesssetup, profile_p,
-                                              req->profile, _INBYTES(req));
+               SMBPROFILE_IOBYTES_ASYNC_START_X(smb2_request_to_snum(req),
+                                                smb2_sesssetup,
+                                                req->profile,
+                                                req->profile_x,
+                                                _INBYTES(req));
                return_value = smbd_smb2_request_process_sesssetup(req);
                break;
 
        case SMB2_OP_LOGOFF:
-               SMBPROFILE_IOBYTES_ASYNC_START(smb2_logoff, profile_p,
-                                              req->profile, _INBYTES(req));
+               SMBPROFILE_IOBYTES_ASYNC_START_X(smb2_request_to_snum(req),
+                                                smb2_logoff,
+                                                req->profile,
+                                                req->profile_x,
+                                                _INBYTES(req));
                return_value = smbd_smb2_request_process_logoff(req);
                break;
 
        case SMB2_OP_TCON:
-               SMBPROFILE_IOBYTES_ASYNC_START(smb2_tcon, profile_p,
-                                              req->profile, _INBYTES(req));
+               SMBPROFILE_IOBYTES_ASYNC_START_X(smb2_request_to_snum(req),
+                                                smb2_tcon,
+                                                req->profile,
+                                                req->profile_x,
+                                                _INBYTES(req));
                return_value = smbd_smb2_request_process_tcon(req);
                break;
 
        case SMB2_OP_TDIS:
-               SMBPROFILE_IOBYTES_ASYNC_START(smb2_tdis, profile_p,
-                                              req->profile, _INBYTES(req));
+               SMBPROFILE_IOBYTES_ASYNC_START_X(smb2_request_to_snum(req),
+                                                smb2_tdis,
+                                                req->profile,
+                                                req->profile_x,
+                                                _INBYTES(req));
                return_value = smbd_smb2_request_process_tdis(req);
                break;
 
        case SMB2_OP_CREATE:
                if (req->subreq == NULL) {
-                       SMBPROFILE_IOBYTES_ASYNC_START(smb2_create, profile_p,
-                                                      req->profile, _INBYTES(req));
+                       SMBPROFILE_IOBYTES_ASYNC_START_X(smb2_request_to_snum(
+                                                                req),
+                                                        smb2_create,
+                                                        req->profile,
+                                                        req->profile_x,
+                                                        _INBYTES(req));
                } else {
-                       SMBPROFILE_IOBYTES_ASYNC_SET_BUSY(req->profile);
+                       SMBPROFILE_IOBYTES_ASYNC_SET_BUSY_X(req->profile,
+                                                           req->profile_x);
                }
                return_value = smbd_smb2_request_process_create(req);
                break;
 
        case SMB2_OP_CLOSE:
-               SMBPROFILE_IOBYTES_ASYNC_START(smb2_close, profile_p,
-                                              req->profile, _INBYTES(req));
+               SMBPROFILE_IOBYTES_ASYNC_START_X(smb2_request_to_snum(req),
+                                                smb2_close,
+                                                req->profile,
+                                                req->profile_x,
+                                                _INBYTES(req));
                return_value = smbd_smb2_request_process_close(req);
                break;
 
        case SMB2_OP_FLUSH:
-               SMBPROFILE_IOBYTES_ASYNC_START(smb2_flush, profile_p,
-                                              req->profile, _INBYTES(req));
+               SMBPROFILE_IOBYTES_ASYNC_START_X(smb2_request_to_snum(req),
+                                                smb2_flush,
+                                                req->profile,
+                                                req->profile_x,
+                                                _INBYTES(req));
                return_value = smbd_smb2_request_process_flush(req);
                break;
 
        case SMB2_OP_READ:
-               SMBPROFILE_IOBYTES_ASYNC_START(smb2_read, profile_p,
-                                              req->profile, _INBYTES(req));
+               SMBPROFILE_IOBYTES_ASYNC_START_X(smb2_request_to_snum(req),
+                                                smb2_read,
+                                                req->profile,
+                                                req->profile_x,
+                                                _INBYTES(req));
                return_value = smbd_smb2_request_process_read(req);
                break;
 
        case SMB2_OP_WRITE:
-               SMBPROFILE_IOBYTES_ASYNC_START(smb2_write, profile_p,
-                                              req->profile, _INBYTES(req));
+               SMBPROFILE_IOBYTES_ASYNC_START_X(smb2_request_to_snum(req),
+                                                smb2_write,
+                                                req->profile,
+                                                req->profile_x,
+                                                _INBYTES(req));
                return_value = smbd_smb2_request_process_write(req);
                break;
 
        case SMB2_OP_LOCK:
-               SMBPROFILE_IOBYTES_ASYNC_START(smb2_lock, profile_p,
-                                              req->profile, _INBYTES(req));
+               SMBPROFILE_IOBYTES_ASYNC_START_X(smb2_request_to_snum(req),
+                                                smb2_lock,
+                                                req->profile,
+                                                req->profile_x,
+                                                _INBYTES(req));
                return_value = smbd_smb2_request_process_lock(req);
                break;
 
        case SMB2_OP_IOCTL:
-               SMBPROFILE_IOBYTES_ASYNC_START(smb2_ioctl, profile_p,
-                                              req->profile, _INBYTES(req));
+               SMBPROFILE_IOBYTES_ASYNC_START_X(smb2_request_to_snum(req),
+                                                smb2_ioctl,
+                                                req->profile,
+                                                req->profile_x,
+                                                _INBYTES(req));
                return_value = smbd_smb2_request_process_ioctl(req);
                break;
 
        case SMB2_OP_CANCEL:
-               SMBPROFILE_IOBYTES_ASYNC_START(smb2_cancel, profile_p,
-                                              req->profile, _INBYTES(req));
+               SMBPROFILE_IOBYTES_ASYNC_START_X(smb2_request_to_snum(req),
+                                                smb2_cancel,
+                                                req->profile,
+                                                req->profile_x,
+                                                _INBYTES(req));
                return_value = smbd_smb2_request_process_cancel(req);
-               SMBPROFILE_IOBYTES_ASYNC_END(req->profile,
-                                            0,
-                                            SMB2_OP_CANCEL,
-                                            NT_STATUS_OK);
+               SMBPROFILE_IOBYTES_ASYNC_END_X(req->profile,
+                                              req->profile_x,
+                                              0,
+                                              SMB2_OP_CANCEL,
+                                              NT_STATUS_OK);
 
                /*
                 * We don't need the request anymore cancel requests never
@@ -3579,38 +3628,56 @@ skipped_signing:
                break;
 
        case SMB2_OP_KEEPALIVE:
-               SMBPROFILE_IOBYTES_ASYNC_START(smb2_keepalive, profile_p,
-                                              req->profile, _INBYTES(req));
+               SMBPROFILE_IOBYTES_ASYNC_START_X(smb2_request_to_snum(req),
+                                                smb2_keepalive,
+                                                req->profile,
+                                                req->profile_x,
+                                                _INBYTES(req));
                return_value = smbd_smb2_request_process_keepalive(req);
                break;
 
        case SMB2_OP_QUERY_DIRECTORY:
-               SMBPROFILE_IOBYTES_ASYNC_START(smb2_find, profile_p,
-                                              req->profile, _INBYTES(req));
+               SMBPROFILE_IOBYTES_ASYNC_START_X(smb2_request_to_snum(req),
+                                                smb2_find,
+                                                req->profile,
+                                                req->profile_x,
+                                                _INBYTES(req));
                return_value = smbd_smb2_request_process_query_directory(req);
                break;
 
        case SMB2_OP_NOTIFY:
-               SMBPROFILE_IOBYTES_ASYNC_START(smb2_notify, profile_p,
-                                              req->profile, _INBYTES(req));
+               SMBPROFILE_IOBYTES_ASYNC_START_X(smb2_request_to_snum(req),
+                                                smb2_notify,
+                                                req->profile,
+                                                req->profile_x,
+                                                _INBYTES(req));
                return_value = smbd_smb2_request_process_notify(req);
                break;
 
        case SMB2_OP_GETINFO:
-               SMBPROFILE_IOBYTES_ASYNC_START(smb2_getinfo, profile_p,
-                                              req->profile, _INBYTES(req));
+               SMBPROFILE_IOBYTES_ASYNC_START_X(smb2_request_to_snum(req),
+                                                smb2_getinfo,
+                                                req->profile,
+                                                req->profile_x,
+                                                _INBYTES(req));
                return_value = smbd_smb2_request_process_getinfo(req);
                break;
 
        case SMB2_OP_SETINFO:
-               SMBPROFILE_IOBYTES_ASYNC_START(smb2_setinfo, profile_p,
-                                              req->profile, _INBYTES(req));
+               SMBPROFILE_IOBYTES_ASYNC_START_X(smb2_request_to_snum(req),
+                                                smb2_setinfo,
+                                                req->profile,
+                                                req->profile_x,
+                                                _INBYTES(req));
                return_value = smbd_smb2_request_process_setinfo(req);
                break;
 
        case SMB2_OP_BREAK:
-               SMBPROFILE_IOBYTES_ASYNC_START(smb2_break, profile_p,
-                                              req->profile, _INBYTES(req));
+               SMBPROFILE_IOBYTES_ASYNC_START_X(smb2_request_to_snum(req),
+                                                smb2_break,
+                                                req->profile,
+                                                req->profile_x,
+                                                _INBYTES(req));
                return_value = smbd_smb2_request_process_break(req);
                break;
 
@@ -3750,8 +3817,9 @@ static NTSTATUS smbd_smb2_request_reply(struct smbd_smb2_request *req)
        }
        TALLOC_FREE(req->last_sign_key);
 
-       SMBPROFILE_IOBYTES_ASYNC_END(
+       SMBPROFILE_IOBYTES_ASYNC_END_X(
                req->profile,
+               req->profile_x,
                iov_buflen(outhdr, SMBD_SMB2_NUM_IOV_PER_REQ - 1),
                PULL_LE_U16(outhdr->iov_base, SMB2_HDR_OPCODE),
                NT_STATUS(IVAL(outhdr->iov_base, SMB2_HDR_STATUS)));