Adding a new VFS Lttng module for performance testing
Ralph Böhme
slow at samba.org
Mon Mar 18 22:15:47 UTC 2019
On Tue, Jan 15, 2019 at 08:11:36AM +0100, Ralph Böhme wrote:
>On Tue, Jan 15, 2019 at 02:45:18PM +0800, deanraccoon wrote:
>>ping Ralph?
>
>Sorry! I have it on my list and will try to get to it over the next days.
took a little longer, but here we go! Sorry! :)
I've took the liberty to do some reformatting and cleanup so the code better
matches the Samba coding style, much of which is summarized in README.Coding.
I've added a call to smb_vfs_assert_all_fns() to the init function of the
module. That asserts that the module implements all VFS functions. Currently
quite a bunch are missing, eg pread_send but also stuff that has been added
recently, like get_dos_attributes_send_fn or vfswrap_getxattrat_send.
Can you add the missing functions or do you want us to do that?
-slow
--
Ralph Boehme, Samba Team https://samba.org/
Samba Developer, SerNet GmbH https://sernet.de/en/samba/
GPG-Fingerprint FAE2C6088A24252051C559E4AA1E9B7126399E46
-------------- next part --------------
From 07d13c86bac4498e1fd26c08645944bb2c75c3df Mon Sep 17 00:00:00 2001
From: Dongmao Zhang <deanraccoon at gmail.com>
Date: Mon, 13 Aug 2018 19:00:33 +0800
Subject: [PATCH 1/3] Add a lttng VFS module for samba.
Tracing VFS functions using lttng is now possible
https://lttng.org/
Signed-off-by: Dongmao Zhang <deanraccoon at gmail.com>
---
source3/modules/vfs_lttng.c | 1520 +++++++++++++++++++++
source3/modules/vfs_lttng_tp.h | 2321 ++++++++++++++++++++++++++++++++
source3/modules/wscript_build | 9 +
source3/wscript | 3 +
4 files changed, 3853 insertions(+)
create mode 100644 source3/modules/vfs_lttng.c
create mode 100644 source3/modules/vfs_lttng_tp.h
diff --git a/source3/modules/vfs_lttng.c b/source3/modules/vfs_lttng.c
new file mode 100644
index 00000000000..829bf664bad
--- /dev/null
+++ b/source3/modules/vfs_lttng.c
@@ -0,0 +1,1520 @@
+/*
+
+ * Lttng VFS module for samba. Trace VFS functions using lttng userspace
+ tools
+
+ Copyright (C) Dongmao Zhang <deanraccoon at gmail.com>
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+/*
+ * This module enables lttng tracing for samba
+ *
+ * /etc/samba/smb.conf
+ *
+ * vfs objects = lttng
+ *
+ * RUN smbd such as this:
+ * LD_PRELOAD=/usr/lib64/liblttng-ust-fork.so.0 /usr/sbin/smbd --foreground --no-process-group
+ *
+ * lttng create
+ * lttng enable-event -u vfs_lttng:*
+ * lttng start
+ *
+ * RUN some performance test...
+ *
+ * lttng stop
+ * lttng destroy
+ *
+ * Use babeltrace or some other tools(https://lttng.org) to checkout the result
+ *
+ */
+
+#define TRACEPOINT_CREATE_PROBES
+/*
+* The header containing our TRACEPOINT_EVENTs.
+*/
+#define TRACEPOINT_DEFINE
+
+
+#include "includes.h"
+#include "smbd/smbd.h"
+#include "ntioctl.h"
+#include "lib/util/tevent_unix.h"
+#include "lib/util/tevent_ntstatus.h"
+
+#include "vfs_lttng_tp.h"
+
+
+
+static int vfs_lttng_connect(vfs_handle_struct *handle,
+ const char *svc, const char *user)
+
+{
+ int result;
+ tracepoint(vfs_lttng, vfs_lttng_connect_enter );
+ result = SMB_VFS_NEXT_CONNECT(handle, svc, user);
+ tracepoint(vfs_lttng, vfs_lttng_connect_exit, result);
+ return result;
+}
+
+
+static void vfs_lttng_disconnect(vfs_handle_struct *handle)
+
+{
+ tracepoint(vfs_lttng, vfs_lttng_disconnect_enter );
+ SMB_VFS_NEXT_DISCONNECT(handle);
+ tracepoint(vfs_lttng, vfs_lttng_disconnect_exit);
+}
+
+
+static uint64_t vfs_lttng_disk_free(vfs_handle_struct *handle,
+ const struct smb_filename *smb_fname,
+ uint64_t *bsize,
+ uint64_t *dfree,
+ uint64_t *dsize)
+
+{
+ uint64_t result;
+ tracepoint(vfs_lttng, vfs_lttng_disk_free_enter , smb_fname);
+ result = SMB_VFS_NEXT_DISK_FREE(handle, smb_fname, bsize, dfree, dsize);
+ tracepoint(vfs_lttng, vfs_lttng_disk_free_exit, result);
+ return result;
+}
+
+
+static int vfs_lttng_get_quota(struct vfs_handle_struct *handle,
+ const struct smb_filename *smb_fname,
+ enum SMB_QUOTA_TYPE qtype,
+ unid_t id,
+ SMB_DISK_QUOTA *qt)
+
+{
+ int result;
+ tracepoint(vfs_lttng, vfs_lttng_get_quota_enter , smb_fname);
+ result = SMB_VFS_NEXT_GET_QUOTA(handle, smb_fname, qtype, id, qt);
+ tracepoint(vfs_lttng, vfs_lttng_get_quota_exit, result);
+ return result;
+}
+
+
+static int vfs_lttng_set_quota(struct vfs_handle_struct *handle,
+ enum SMB_QUOTA_TYPE qtype, unid_t id,
+ SMB_DISK_QUOTA *qt)
+
+{
+ int result;
+ tracepoint(vfs_lttng, vfs_lttng_set_quota_enter );
+ result = SMB_VFS_NEXT_SET_QUOTA(handle, qtype, id, qt);
+ tracepoint(vfs_lttng, vfs_lttng_set_quota_exit, result);
+ return result;
+}
+
+
+static int vfs_lttng_get_shadow_copy_data(struct vfs_handle_struct *handle,
+ struct files_struct *fsp,
+ struct shadow_copy_data *shadow_copy_data,
+ bool labels)
+
+{
+ int result;
+ tracepoint(vfs_lttng, vfs_lttng_get_shadow_copy_data_enter , fsp);
+ result = SMB_VFS_NEXT_GET_SHADOW_COPY_DATA(handle, fsp, shadow_copy_data, labels);
+ tracepoint(vfs_lttng, vfs_lttng_get_shadow_copy_data_exit, result);
+ return result;
+}
+
+
+static int vfs_lttng_statvfs(struct vfs_handle_struct *handle,
+ const struct smb_filename *smb_fname,
+ struct vfs_statvfs_struct *statbuf)
+
+{
+ int result;
+ tracepoint(vfs_lttng, vfs_lttng_statvfs_enter , smb_fname);
+ result = SMB_VFS_NEXT_STATVFS(handle, smb_fname, statbuf);
+ tracepoint(vfs_lttng, vfs_lttng_statvfs_exit, result);
+ return result;
+}
+
+
+static uint32_t vfs_lttng_fs_capabilities(struct vfs_handle_struct *handle,
+ enum timestamp_set_resolution *p_ts_res)
+
+{
+ uint32_t result;
+ tracepoint(vfs_lttng, vfs_lttng_fs_capabilities_enter );
+ result = SMB_VFS_NEXT_FS_CAPABILITIES(handle, p_ts_res);
+ tracepoint(vfs_lttng, vfs_lttng_fs_capabilities_exit, result);
+ return result;
+}
+
+
+static NTSTATUS vfs_lttng_get_dfs_referrals(
+ struct vfs_handle_struct *handle,
+ struct dfs_GetDFSReferral *r)
+
+{
+ NTSTATUS result;
+ tracepoint(vfs_lttng, vfs_lttng_get_dfs_referrals_enter );
+ result = SMB_VFS_NEXT_GET_DFS_REFERRALS(handle, r);
+ tracepoint(vfs_lttng, vfs_lttng_get_dfs_referrals_exit, result);
+ return result;
+}
+
+
+static DIR *vfs_lttng_opendir(vfs_handle_struct *handle,
+ const struct smb_filename *smb_fname,
+ const char *mask, uint32_t attr)
+
+{
+ DIR * result;
+ tracepoint(vfs_lttng, vfs_lttng_opendir_enter , smb_fname);
+ result = SMB_VFS_NEXT_OPENDIR(handle, smb_fname, mask, attr);
+ tracepoint(vfs_lttng, vfs_lttng_opendir_exit);
+ return result;
+}
+
+
+static DIR *vfs_lttng_fdopendir(vfs_handle_struct *handle,
+ files_struct *fsp,
+ const char *mask, uint32_t attr)
+
+{
+ DIR * result;
+ tracepoint(vfs_lttng, vfs_lttng_fdopendir_enter , fsp);
+ result = SMB_VFS_NEXT_FDOPENDIR(handle, fsp, mask, attr);
+ tracepoint(vfs_lttng, vfs_lttng_fdopendir_exit);
+ return result;
+}
+
+
+static struct dirent *vfs_lttng_readdir(vfs_handle_struct *handle,
+ DIR *dirp,
+ SMB_STRUCT_STAT *sbuf)
+
+{
+ struct dirent * result;
+ tracepoint(vfs_lttng, vfs_lttng_readdir_enter );
+ result = SMB_VFS_NEXT_READDIR(handle, dirp, sbuf);
+ tracepoint(vfs_lttng, vfs_lttng_readdir_exit);
+ return result;
+}
+
+
+static void vfs_lttng_seekdir(vfs_handle_struct *handle,
+ DIR *dirp, long offset)
+
+{
+ tracepoint(vfs_lttng, vfs_lttng_seekdir_enter , offset);
+ SMB_VFS_NEXT_SEEKDIR(handle, dirp, offset);
+ tracepoint(vfs_lttng, vfs_lttng_seekdir_exit);
+}
+
+
+static long vfs_lttng_telldir(vfs_handle_struct *handle,
+ DIR *dirp)
+
+{
+ long result;
+ tracepoint(vfs_lttng, vfs_lttng_telldir_enter );
+ result = SMB_VFS_NEXT_TELLDIR(handle, dirp);
+ tracepoint(vfs_lttng, vfs_lttng_telldir_exit, result);
+ return result;
+}
+
+
+static int vfs_lttng_mkdir(vfs_handle_struct *handle,
+ const struct smb_filename *smb_fname,
+ mode_t mode)
+
+{
+ int result;
+ tracepoint(vfs_lttng, vfs_lttng_mkdir_enter , smb_fname, mode);
+ result = SMB_VFS_NEXT_MKDIR(handle, smb_fname, mode);
+ tracepoint(vfs_lttng, vfs_lttng_mkdir_exit, result);
+ return result;
+}
+
+
+static int vfs_lttng_rmdir(vfs_handle_struct *handle,
+ const struct smb_filename *smb_fname)
+
+{
+ int result;
+ tracepoint(vfs_lttng, vfs_lttng_rmdir_enter , smb_fname);
+ result = SMB_VFS_NEXT_RMDIR(handle, smb_fname);
+ tracepoint(vfs_lttng, vfs_lttng_rmdir_exit, result);
+ return result;
+}
+
+
+static int vfs_lttng_closedir(vfs_handle_struct *handle,
+ DIR *dirp)
+
+{
+ int result;
+ tracepoint(vfs_lttng, vfs_lttng_closedir_enter );
+ result = SMB_VFS_NEXT_CLOSEDIR(handle, dirp);
+ tracepoint(vfs_lttng, vfs_lttng_closedir_exit, result);
+ return result;
+}
+
+
+
+static int vfs_lttng_open(vfs_handle_struct *handle,
+ struct smb_filename *fname,
+ files_struct *fsp,
+ int flags, mode_t mode)
+
+{
+ int result;
+ tracepoint(vfs_lttng, vfs_lttng_open_enter , fname, flags, mode);
+ result = SMB_VFS_NEXT_OPEN(handle, fname, fsp, flags, mode);
+ tracepoint(vfs_lttng, vfs_lttng_open_exit, result);
+ return result;
+}
+
+
+static NTSTATUS vfs_lttng_create_file(vfs_handle_struct *handle,
+ struct smb_request *req,
+ uint16_t root_dir_fid,
+ struct smb_filename *fname,
+ uint32_t access_mask,
+ uint32_t share_access,
+ uint32_t create_disposition,
+ uint32_t create_options,
+ uint32_t file_attributes,
+ uint32_t oplock_request,
+ struct smb2_lease *lease,
+ uint64_t allocation_size,
+ uint32_t private_flags,
+ struct security_descriptor *sd,
+ struct ea_list *ea_list,
+ files_struct **result_fsp,
+ int *pinfo,
+ const struct smb2_create_blobs *in_context_blobs,
+ struct smb2_create_blobs *out_context_blobs)
+
+{
+ NTSTATUS result;
+ tracepoint(vfs_lttng, vfs_lttng_create_file_enter , fname);
+ result = SMB_VFS_NEXT_CREATE_FILE(handle, req, root_dir_fid, fname, access_mask, share_access, create_disposition, create_options, file_attributes, oplock_request, lease, allocation_size, private_flags, sd, ea_list, result_fsp, pinfo, in_context_blobs, out_context_blobs);
+ tracepoint(vfs_lttng, vfs_lttng_create_file_exit, result);
+ return result;
+}
+
+
+static int vfs_lttng_close(vfs_handle_struct *handle, files_struct *fsp)
+
+{
+ int result;
+ tracepoint(vfs_lttng, vfs_lttng_close_enter , fsp);
+ result = SMB_VFS_NEXT_CLOSE(handle, fsp);
+ tracepoint(vfs_lttng, vfs_lttng_close_exit, result);
+ return result;
+}
+
+
+
+
+static ssize_t vfs_lttng_pread(vfs_handle_struct *handle,
+ files_struct *fsp,
+ void *data, size_t n, off_t offset)
+
+{
+ ssize_t result;
+ tracepoint(vfs_lttng, vfs_lttng_pread_enter , fsp, n, offset);
+ result = SMB_VFS_NEXT_PREAD(handle, fsp, data, n, offset);
+ tracepoint(vfs_lttng, vfs_lttng_pread_exit, result);
+ return result;
+}
+
+
+static ssize_t vfs_lttng_pwrite(vfs_handle_struct *handle,
+ files_struct *fsp,
+ const void *data, size_t n,
+ off_t offset)
+
+{
+ ssize_t result;
+ tracepoint(vfs_lttng, vfs_lttng_pwrite_enter , fsp, n, offset);
+ result = SMB_VFS_NEXT_PWRITE(handle, fsp, data, n, offset);
+ tracepoint(vfs_lttng, vfs_lttng_pwrite_exit, result);
+ return result;
+}
+
+
+static off_t vfs_lttng_lseek(vfs_handle_struct *handle,
+ files_struct *fsp,
+ off_t offset, int whence)
+
+{
+ off_t result;
+ tracepoint(vfs_lttng, vfs_lttng_lseek_enter , fsp, offset);
+ result = SMB_VFS_NEXT_LSEEK(handle, fsp, offset, whence);
+ tracepoint(vfs_lttng, vfs_lttng_lseek_exit, result);
+ return result;
+}
+
+
+static ssize_t vfs_lttng_sendfile(vfs_handle_struct *handle, int tofd,
+ files_struct *fromfsp,
+ const DATA_BLOB *hdr, off_t offset,
+ size_t n)
+
+{
+ ssize_t result;
+ tracepoint(vfs_lttng, vfs_lttng_sendfile_enter , tofd, offset, n);
+ result = SMB_VFS_NEXT_SENDFILE(handle, tofd, fromfsp, hdr, offset, n);
+ tracepoint(vfs_lttng, vfs_lttng_sendfile_exit, result);
+ return result;
+}
+
+
+static ssize_t vfs_lttng_recvfile(vfs_handle_struct *handle, int fromfd,
+ files_struct *tofsp,
+ off_t offset,
+ size_t n)
+
+{
+ ssize_t result;
+ tracepoint(vfs_lttng, vfs_lttng_recvfile_enter , offset, n);
+ result = SMB_VFS_NEXT_RECVFILE(handle, fromfd, tofsp, offset, n);
+ tracepoint(vfs_lttng, vfs_lttng_recvfile_exit, result);
+ return result;
+}
+
+
+static int vfs_lttng_rename(vfs_handle_struct *handle,
+ const struct smb_filename *oldname,
+ const struct smb_filename *newname)
+
+{
+ int result;
+ tracepoint(vfs_lttng, vfs_lttng_rename_enter );
+ result = SMB_VFS_NEXT_RENAME(handle, oldname, newname);
+ tracepoint(vfs_lttng, vfs_lttng_rename_exit, result);
+ return result;
+}
+
+
+
+
+static int vfs_lttng_stat(vfs_handle_struct *handle,
+ struct smb_filename *fname)
+
+{
+ int result;
+ tracepoint(vfs_lttng, vfs_lttng_stat_enter , fname);
+ result = SMB_VFS_NEXT_STAT(handle, fname);
+ tracepoint(vfs_lttng, vfs_lttng_stat_exit, result);
+ return result;
+}
+
+
+static int vfs_lttng_fstat(vfs_handle_struct *handle, files_struct *fsp,
+ SMB_STRUCT_STAT *sbuf)
+
+{
+ int result;
+ tracepoint(vfs_lttng, vfs_lttng_fstat_enter , fsp);
+ result = SMB_VFS_NEXT_FSTAT(handle, fsp, sbuf);
+ tracepoint(vfs_lttng, vfs_lttng_fstat_exit, result);
+ return result;
+}
+
+
+static int vfs_lttng_lstat(vfs_handle_struct *handle,
+ struct smb_filename *path)
+
+{
+ int result;
+ tracepoint(vfs_lttng, vfs_lttng_lstat_enter );
+ result = SMB_VFS_NEXT_LSTAT(handle, path);
+ tracepoint(vfs_lttng, vfs_lttng_lstat_exit, result);
+ return result;
+}
+
+
+static uint64_t vfs_lttng_get_alloc_size(vfs_handle_struct *handle,
+ files_struct *fsp,
+ const SMB_STRUCT_STAT *sbuf)
+
+{
+ uint64_t result;
+ tracepoint(vfs_lttng, vfs_lttng_get_alloc_size_enter);
+ result = SMB_VFS_NEXT_GET_ALLOC_SIZE(handle, fsp, sbuf);
+ tracepoint(vfs_lttng, vfs_lttng_get_alloc_size_exit, result);
+ return result;
+}
+
+
+static int vfs_lttng_unlink(vfs_handle_struct *handle,
+ const struct smb_filename *path)
+
+{
+ int result;
+ tracepoint(vfs_lttng, vfs_lttng_unlink_enter );
+ result = SMB_VFS_NEXT_UNLINK(handle, path);
+ tracepoint(vfs_lttng, vfs_lttng_unlink_exit, result);
+ return result;
+}
+
+
+static int vfs_lttng_chmod(vfs_handle_struct *handle,
+ const struct smb_filename *smb_fname,
+ mode_t mode)
+
+{
+ int result;
+ tracepoint(vfs_lttng, vfs_lttng_chmod_enter , smb_fname, mode);
+ result = SMB_VFS_NEXT_CHMOD(handle, smb_fname, mode);
+ tracepoint(vfs_lttng, vfs_lttng_chmod_exit, result);
+ return result;
+}
+
+
+static int vfs_lttng_fchmod(vfs_handle_struct *handle, files_struct *fsp,
+ mode_t mode)
+
+{
+ int result;
+ tracepoint(vfs_lttng, vfs_lttng_fchmod_enter , fsp, mode);
+ result = SMB_VFS_NEXT_FCHMOD(handle, fsp, mode);
+ tracepoint(vfs_lttng, vfs_lttng_fchmod_exit, result);
+ return result;
+}
+
+
+static int vfs_lttng_chown(vfs_handle_struct *handle,
+ const struct smb_filename *smb_fname,
+ uid_t uid,
+ gid_t gid)
+
+{
+ int result;
+ tracepoint(vfs_lttng, vfs_lttng_chown_enter , smb_fname);
+ result = SMB_VFS_NEXT_CHOWN(handle, smb_fname, uid, gid);
+ tracepoint(vfs_lttng, vfs_lttng_chown_exit, result);
+ return result;
+}
+
+
+static int vfs_lttng_fchown(vfs_handle_struct *handle, files_struct *fsp,
+ uid_t uid, gid_t gid)
+
+{
+ int result;
+ tracepoint(vfs_lttng, vfs_lttng_fchown_enter , fsp);
+ result = SMB_VFS_NEXT_FCHOWN(handle, fsp, uid, gid);
+ tracepoint(vfs_lttng, vfs_lttng_fchown_exit, result);
+ return result;
+}
+
+
+static int vfs_lttng_lchown(vfs_handle_struct *handle,
+ const struct smb_filename *smb_fname,
+ uid_t uid,
+ gid_t gid)
+
+{
+ int result;
+ tracepoint(vfs_lttng, vfs_lttng_lchown_enter , smb_fname);
+ result = SMB_VFS_NEXT_LCHOWN(handle, smb_fname, uid, gid);
+ tracepoint(vfs_lttng, vfs_lttng_lchown_exit, result);
+ return result;
+}
+
+
+static int vfs_lttng_chdir(vfs_handle_struct *handle,
+ const struct smb_filename *smb_fname)
+
+{
+ int result;
+ tracepoint(vfs_lttng, vfs_lttng_chdir_enter , smb_fname);
+ result = SMB_VFS_NEXT_CHDIR(handle, smb_fname);
+ tracepoint(vfs_lttng, vfs_lttng_chdir_exit, result);
+ return result;
+}
+
+
+static struct smb_filename *vfs_lttng_getwd(vfs_handle_struct *handle,
+ TALLOC_CTX *mem_ctx)
+
+{
+ struct smb_filename * result;
+ tracepoint(vfs_lttng, vfs_lttng_getwd_enter );
+ result = SMB_VFS_NEXT_GETWD(handle, mem_ctx);
+ tracepoint(vfs_lttng, vfs_lttng_getwd_exit);
+ return result;
+}
+
+
+static int vfs_lttng_ntimes(vfs_handle_struct *handle,
+ const struct smb_filename *path,
+ struct smb_file_time *ft)
+
+{
+ int result;
+ tracepoint(vfs_lttng, vfs_lttng_ntimes_enter );
+ result = SMB_VFS_NEXT_NTIMES(handle, path, ft);
+ tracepoint(vfs_lttng, vfs_lttng_ntimes_exit, result);
+ return result;
+}
+
+
+static int vfs_lttng_ftruncate(vfs_handle_struct *handle,
+ files_struct *fsp,
+ off_t len)
+
+{
+ int result;
+ tracepoint(vfs_lttng, vfs_lttng_ftruncate_enter , fsp);
+ result = SMB_VFS_NEXT_FTRUNCATE(handle, fsp, len);
+ tracepoint(vfs_lttng, vfs_lttng_ftruncate_exit, result);
+ return result;
+}
+
+
+static int vfs_lttng_fallocate(vfs_handle_struct *handle,
+ files_struct *fsp,
+ uint32_t mode,
+ off_t offset,
+ off_t len)
+
+{
+ int result;
+ tracepoint(vfs_lttng, vfs_lttng_fallocate_enter , fsp, mode, offset);
+ result = SMB_VFS_NEXT_FALLOCATE(handle, fsp, mode, offset, len);
+ tracepoint(vfs_lttng, vfs_lttng_fallocate_exit, result);
+ return result;
+}
+
+
+static bool vfs_lttng_lock(vfs_handle_struct *handle, files_struct *fsp,
+ int op, off_t offset, off_t count,
+ int type)
+
+{
+ bool result;
+ tracepoint(vfs_lttng, vfs_lttng_lock_enter , fsp, offset);
+ result = SMB_VFS_NEXT_LOCK(handle, fsp, op, offset, count, type);
+ tracepoint(vfs_lttng, vfs_lttng_lock_exit, result);
+ return result;
+}
+
+
+static int vfs_lttng_kernel_flock(struct vfs_handle_struct *handle,
+ struct files_struct *fsp,
+ uint32_t share_mode, uint32_t access_mask)
+
+{
+ int result;
+ tracepoint(vfs_lttng, vfs_lttng_kernel_flock_enter , fsp);
+ result = SMB_VFS_NEXT_KERNEL_FLOCK(handle, fsp, share_mode, access_mask);
+ tracepoint(vfs_lttng, vfs_lttng_kernel_flock_exit, result);
+ return result;
+}
+
+
+static int vfs_lttng_linux_setlease(vfs_handle_struct *handle,
+ files_struct *fsp,
+ int leasetype)
+
+{
+ int result;
+ tracepoint(vfs_lttng, vfs_lttng_linux_setlease_enter , fsp);
+ result = SMB_VFS_NEXT_LINUX_SETLEASE(handle, fsp, leasetype);
+ tracepoint(vfs_lttng, vfs_lttng_linux_setlease_exit, result);
+ return result;
+}
+
+
+static bool vfs_lttng_getlock(vfs_handle_struct *handle,
+ files_struct *fsp,
+ off_t *poffset, off_t *pcount,
+ int *ptype, pid_t *ppid)
+
+{
+ bool result;
+ tracepoint(vfs_lttng, vfs_lttng_getlock_enter , fsp);
+ result = SMB_VFS_NEXT_GETLOCK(handle, fsp, poffset, pcount, ptype, ppid);
+ tracepoint(vfs_lttng, vfs_lttng_getlock_exit, result);
+ return result;
+}
+
+
+static int vfs_lttng_symlink(vfs_handle_struct *handle,
+ const char *link_contents,
+ const struct smb_filename *new_smb_fname)
+
+{
+ int result;
+ tracepoint(vfs_lttng, vfs_lttng_symlink_enter );
+ result = SMB_VFS_NEXT_SYMLINK(handle, link_contents, new_smb_fname);
+ tracepoint(vfs_lttng, vfs_lttng_symlink_exit, result);
+ return result;
+}
+
+
+static int vfs_lttng_readlink(vfs_handle_struct *handle,
+ const struct smb_filename *smb_fname,
+ char *buf,
+ size_t bufsiz)
+
+{
+ int result;
+ tracepoint(vfs_lttng, vfs_lttng_readlink_enter , smb_fname);
+ result = SMB_VFS_NEXT_READLINK(handle, smb_fname, buf, bufsiz);
+ tracepoint(vfs_lttng, vfs_lttng_readlink_exit, result);
+ return result;
+}
+
+
+static int vfs_lttng_link(vfs_handle_struct *handle,
+ const struct smb_filename *old_smb_fname,
+ const struct smb_filename *new_smb_fname)
+
+{
+ int result;
+ tracepoint(vfs_lttng, vfs_lttng_link_enter );
+ result = SMB_VFS_NEXT_LINK(handle, old_smb_fname, new_smb_fname);
+ tracepoint(vfs_lttng, vfs_lttng_link_exit, result);
+ return result;
+}
+
+
+static int vfs_lttng_mknod(vfs_handle_struct *handle,
+ const struct smb_filename *smb_fname,
+ mode_t mode,
+ SMB_DEV_T dev)
+
+{
+ int result;
+ tracepoint(vfs_lttng, vfs_lttng_mknod_enter , smb_fname, mode);
+ result = SMB_VFS_NEXT_MKNOD(handle, smb_fname, mode, dev);
+ tracepoint(vfs_lttng, vfs_lttng_mknod_exit, result);
+ return result;
+}
+
+
+static struct smb_filename *vfs_lttng_realpath(vfs_handle_struct *handle,
+ TALLOC_CTX *ctx,
+ const struct smb_filename *smb_fname)
+
+{
+ struct smb_filename * result;
+ tracepoint(vfs_lttng, vfs_lttng_realpath_enter , smb_fname);
+ result = SMB_VFS_NEXT_REALPATH(handle, ctx, smb_fname);
+ tracepoint(vfs_lttng, vfs_lttng_realpath_exit);
+ return result;
+}
+
+
+static int vfs_lttng_chflags(vfs_handle_struct *handle,
+ const struct smb_filename *smb_fname,
+ unsigned int flags)
+
+{
+ int result;
+ tracepoint(vfs_lttng, vfs_lttng_chflags_enter , smb_fname, flags);
+ result = SMB_VFS_NEXT_CHFLAGS(handle, smb_fname, flags);
+ tracepoint(vfs_lttng, vfs_lttng_chflags_exit, result);
+ return result;
+}
+
+
+static struct file_id vfs_lttng_file_id_create(struct vfs_handle_struct *handle,
+ const SMB_STRUCT_STAT *sbuf)
+
+{
+ struct file_id result;
+ tracepoint(vfs_lttng, vfs_lttng_file_id_create_enter );
+ result = SMB_VFS_NEXT_FILE_ID_CREATE(handle, sbuf);
+ tracepoint(vfs_lttng, vfs_lttng_file_id_create_exit);
+ return result;
+}
+
+
+static struct tevent_req *vfs_lttng_offload_read_send(
+ TALLOC_CTX *mem_ctx,
+ struct tevent_context *ev,
+ struct vfs_handle_struct *handle,
+ struct files_struct *fsp,
+ uint32_t fsctl,
+ uint32_t ttl,
+ off_t offset,
+ size_t to_copy)
+
+{
+ struct tevent_req * result;
+ tracepoint(vfs_lttng, vfs_lttng_offload_read_send_enter , fsp, offset);
+ result = SMB_VFS_NEXT_OFFLOAD_READ_SEND(mem_ctx, ev, handle, fsp, fsctl, ttl, offset, to_copy);
+ tracepoint(vfs_lttng, vfs_lttng_offload_read_send_exit);
+ return result;
+}
+
+
+static NTSTATUS vfs_lttng_offload_read_recv(
+ struct tevent_req *req,
+ struct vfs_handle_struct *handle,
+ TALLOC_CTX *mem_ctx,
+ DATA_BLOB *_token_blob)
+
+{
+ NTSTATUS result;
+ tracepoint(vfs_lttng, vfs_lttng_offload_read_recv_enter );
+ result = SMB_VFS_NEXT_OFFLOAD_READ_RECV(req, handle, mem_ctx, _token_blob);
+ tracepoint(vfs_lttng, vfs_lttng_offload_read_recv_exit, result);
+ return result;
+}
+
+
+static struct tevent_req *vfs_lttng_offload_write_send(struct vfs_handle_struct *handle,
+ TALLOC_CTX *mem_ctx,
+ struct tevent_context *ev,
+ uint32_t fsctl,
+ DATA_BLOB *token,
+ off_t transfer_offset,
+ struct files_struct *dest_fsp,
+ off_t dest_off,
+ off_t num)
+
+{
+ struct tevent_req * result;
+ tracepoint(vfs_lttng, vfs_lttng_offload_write_send_enter );
+ result = SMB_VFS_NEXT_OFFLOAD_WRITE_SEND(handle, mem_ctx, ev, fsctl, token, transfer_offset, dest_fsp, dest_off, num);
+ tracepoint(vfs_lttng, vfs_lttng_offload_write_send_exit);
+ return result;
+}
+
+
+static NTSTATUS vfs_lttng_offload_write_recv(struct vfs_handle_struct *handle,
+ struct tevent_req *req,
+ off_t *copied)
+
+{
+ NTSTATUS result;
+ tracepoint(vfs_lttng, vfs_lttng_offload_write_recv_enter );
+ result = SMB_VFS_NEXT_OFFLOAD_WRITE_RECV(handle, req, copied);
+ tracepoint(vfs_lttng, vfs_lttng_offload_write_recv_exit, result);
+ return result;
+}
+
+
+static NTSTATUS vfs_lttng_get_compression(vfs_handle_struct *handle,
+ TALLOC_CTX *mem_ctx,
+ struct files_struct *fsp,
+ struct smb_filename *smb_fname,
+ uint16_t *_compression_fmt)
+
+{
+ NTSTATUS result;
+ tracepoint(vfs_lttng, vfs_lttng_get_compression_enter , fsp);
+ result = SMB_VFS_NEXT_GET_COMPRESSION(handle, mem_ctx, fsp, smb_fname, _compression_fmt);
+ tracepoint(vfs_lttng, vfs_lttng_get_compression_exit, result);
+ return result;
+}
+
+
+static NTSTATUS vfs_lttng_set_compression(vfs_handle_struct *handle,
+ TALLOC_CTX *mem_ctx,
+ struct files_struct *fsp,
+ uint16_t compression_fmt)
+
+{
+ NTSTATUS result;
+ tracepoint(vfs_lttng, vfs_lttng_set_compression_enter , fsp);
+ result = SMB_VFS_NEXT_SET_COMPRESSION(handle, mem_ctx, fsp, compression_fmt);
+ tracepoint(vfs_lttng, vfs_lttng_set_compression_exit, result);
+ return result;
+}
+
+
+static NTSTATUS vfs_lttng_snap_check_path(struct vfs_handle_struct *handle,
+ TALLOC_CTX *mem_ctx,
+ const char *service_path,
+ char **base_volume)
+
+{
+ NTSTATUS result;
+ tracepoint(vfs_lttng, vfs_lttng_snap_check_path_enter );
+ result = SMB_VFS_NEXT_SNAP_CHECK_PATH(handle, mem_ctx, service_path, base_volume);
+ tracepoint(vfs_lttng, vfs_lttng_snap_check_path_exit, result);
+ return result;
+}
+
+
+static NTSTATUS vfs_lttng_snap_create(struct vfs_handle_struct *handle,
+ TALLOC_CTX *mem_ctx,
+ const char *base_volume,
+ time_t *tstamp,
+ bool rw,
+ char **base_path,
+ char **snap_path)
+
+{
+ NTSTATUS result;
+ tracepoint(vfs_lttng, vfs_lttng_snap_create_enter );
+ result = SMB_VFS_NEXT_SNAP_CREATE(handle, mem_ctx, base_volume, tstamp, rw, base_path, snap_path);
+ tracepoint(vfs_lttng, vfs_lttng_snap_create_exit, result);
+ return result;
+}
+
+
+static NTSTATUS vfs_lttng_snap_delete(struct vfs_handle_struct *handle,
+ TALLOC_CTX *mem_ctx,
+ char *base_path,
+ char *snap_path)
+
+{
+ NTSTATUS result;
+ tracepoint(vfs_lttng, vfs_lttng_snap_delete_enter );
+ result = SMB_VFS_NEXT_SNAP_DELETE(handle, mem_ctx, base_path, snap_path);
+ tracepoint(vfs_lttng, vfs_lttng_snap_delete_exit, result);
+ return result;
+}
+
+
+static NTSTATUS vfs_lttng_streaminfo(vfs_handle_struct *handle,
+ struct files_struct *fsp,
+ const struct smb_filename *smb_fname,
+ TALLOC_CTX *mem_ctx,
+ unsigned int *pnum_streams,
+ struct stream_struct **pstreams)
+
+{
+ NTSTATUS result;
+ tracepoint(vfs_lttng, vfs_lttng_streaminfo_enter , fsp);
+ result = SMB_VFS_NEXT_STREAMINFO(handle, fsp, smb_fname, mem_ctx, pnum_streams, pstreams);
+ tracepoint(vfs_lttng, vfs_lttng_streaminfo_exit, result);
+ return result;
+}
+
+
+static int vfs_lttng_get_real_filename(struct vfs_handle_struct *handle,
+ const char *path,
+ const char *name,
+ TALLOC_CTX *mem_ctx,
+ char **found_name)
+
+{
+ int result;
+ tracepoint(vfs_lttng, vfs_lttng_get_real_filename_enter , name);
+ result = SMB_VFS_NEXT_GET_REAL_FILENAME(handle, path, name, mem_ctx, found_name);
+ tracepoint(vfs_lttng, vfs_lttng_get_real_filename_exit, result);
+ return result;
+}
+
+
+static const char *vfs_lttng_connectpath(vfs_handle_struct *handle,
+ const struct smb_filename *smb_fname)
+
+{
+ const char * result;
+ tracepoint(vfs_lttng, vfs_lttng_connectpath_enter , smb_fname);
+ result = SMB_VFS_NEXT_CONNECTPATH(handle, smb_fname);
+ tracepoint(vfs_lttng, vfs_lttng_connectpath_exit);
+ return result;
+}
+
+
+static NTSTATUS vfs_lttng_brl_lock_windows(struct vfs_handle_struct *handle,
+ struct byte_range_lock *br_lck,
+ struct lock_struct *plock,
+ bool blocking_lock)
+
+{
+ NTSTATUS result;
+ tracepoint(vfs_lttng, vfs_lttng_brl_lock_windows_enter );
+ result = SMB_VFS_NEXT_BRL_LOCK_WINDOWS(handle, br_lck, plock, blocking_lock);
+ tracepoint(vfs_lttng, vfs_lttng_brl_lock_windows_exit, result);
+ return result;
+}
+
+
+static bool vfs_lttng_brl_unlock_windows(struct vfs_handle_struct *handle,
+ struct messaging_context *msg_ctx,
+ struct byte_range_lock *br_lck,
+ const struct lock_struct *plock)
+
+{
+ bool result;
+ tracepoint(vfs_lttng, vfs_lttng_brl_unlock_windows_enter );
+ result = SMB_VFS_NEXT_BRL_UNLOCK_WINDOWS(handle, msg_ctx, br_lck, plock);
+ tracepoint(vfs_lttng, vfs_lttng_brl_unlock_windows_exit, result);
+ return result;
+}
+
+
+static bool vfs_lttng_brl_cancel_windows(struct vfs_handle_struct *handle,
+ struct byte_range_lock *br_lck,
+ struct lock_struct *plock)
+
+{
+ bool result;
+ tracepoint(vfs_lttng, vfs_lttng_brl_cancel_windows_enter );
+ result = SMB_VFS_NEXT_BRL_CANCEL_WINDOWS(handle, br_lck, plock);
+ tracepoint(vfs_lttng, vfs_lttng_brl_cancel_windows_exit, result);
+ return result;
+}
+
+
+static bool vfs_lttng_strict_lock_check(struct vfs_handle_struct *handle,
+ struct files_struct *fsp,
+ struct lock_struct *plock)
+
+{
+ bool result;
+ tracepoint(vfs_lttng, vfs_lttng_strict_lock_check_enter , fsp);
+ result = SMB_VFS_NEXT_STRICT_LOCK_CHECK(handle, fsp, plock);
+ tracepoint(vfs_lttng, vfs_lttng_strict_lock_check_exit, result);
+ return result;
+}
+
+
+static NTSTATUS vfs_lttng_translate_name(struct vfs_handle_struct *handle,
+ const char *name,
+ enum vfs_translate_direction direction,
+ TALLOC_CTX *mem_ctx,
+ char **mapped_name)
+
+{
+ NTSTATUS result;
+ tracepoint(vfs_lttng, vfs_lttng_translate_name_enter , name);
+ result = SMB_VFS_NEXT_TRANSLATE_NAME(handle, name, direction, mem_ctx, mapped_name);
+ tracepoint(vfs_lttng, vfs_lttng_translate_name_exit, result);
+ return result;
+}
+
+
+static NTSTATUS vfs_lttng_fsctl(struct vfs_handle_struct *handle,
+ struct files_struct *fsp,
+ TALLOC_CTX *ctx,
+ uint32_t function,
+ uint16_t req_flags,
+ const uint8_t *_in_data,
+ uint32_t in_len,
+ uint8_t **_out_data,
+ uint32_t max_out_len,
+ uint32_t *out_len)
+
+{
+ NTSTATUS result;
+ tracepoint(vfs_lttng, vfs_lttng_fsctl_enter , fsp);
+ result = SMB_VFS_NEXT_FSCTL(handle, fsp, ctx, function, req_flags, _in_data, in_len, _out_data, max_out_len, out_len);
+ tracepoint(vfs_lttng, vfs_lttng_fsctl_exit, result);
+ return result;
+}
+
+
+static NTSTATUS vfs_lttng_get_dos_attributes(struct vfs_handle_struct *handle,
+ struct smb_filename *smb_fname,
+ uint32_t *dosmode)
+
+{
+ NTSTATUS result;
+ tracepoint(vfs_lttng, vfs_lttng_get_dos_attributes_enter , smb_fname);
+ result = SMB_VFS_NEXT_GET_DOS_ATTRIBUTES(handle, smb_fname, dosmode);
+ tracepoint(vfs_lttng, vfs_lttng_get_dos_attributes_exit, result);
+ return result;
+}
+
+
+static NTSTATUS vfs_lttng_fget_dos_attributes(struct vfs_handle_struct *handle,
+ struct files_struct *fsp,
+ uint32_t *dosmode)
+
+{
+ NTSTATUS result;
+ tracepoint(vfs_lttng, vfs_lttng_fget_dos_attributes_enter , fsp);
+ result = SMB_VFS_NEXT_FGET_DOS_ATTRIBUTES(handle, fsp, dosmode);
+ tracepoint(vfs_lttng, vfs_lttng_fget_dos_attributes_exit, result);
+ return result;
+}
+
+
+static NTSTATUS vfs_lttng_set_dos_attributes(struct vfs_handle_struct *handle,
+ const struct smb_filename *smb_fname,
+ uint32_t dosmode)
+
+{
+ NTSTATUS result;
+ tracepoint(vfs_lttng, vfs_lttng_set_dos_attributes_enter , smb_fname);
+ result = SMB_VFS_NEXT_SET_DOS_ATTRIBUTES(handle, smb_fname, dosmode);
+ tracepoint(vfs_lttng, vfs_lttng_set_dos_attributes_exit, result);
+ return result;
+}
+
+
+static NTSTATUS vfs_lttng_fset_dos_attributes(struct vfs_handle_struct *handle,
+ struct files_struct *fsp,
+ uint32_t dosmode)
+
+{
+ NTSTATUS result;
+ tracepoint(vfs_lttng, vfs_lttng_fset_dos_attributes_enter , fsp);
+ result = SMB_VFS_NEXT_FSET_DOS_ATTRIBUTES(handle, fsp, dosmode);
+ tracepoint(vfs_lttng, vfs_lttng_fset_dos_attributes_exit, result);
+ return result;
+}
+
+
+static NTSTATUS vfs_lttng_fget_nt_acl(vfs_handle_struct *handle,
+ files_struct *fsp,
+ uint32_t security_info,
+ TALLOC_CTX *mem_ctx,
+ struct security_descriptor **ppdesc)
+
+{
+ NTSTATUS result;
+ tracepoint(vfs_lttng, vfs_lttng_fget_nt_acl_enter , fsp);
+ result = SMB_VFS_NEXT_FGET_NT_ACL(handle, fsp, security_info, mem_ctx, ppdesc);
+ tracepoint(vfs_lttng, vfs_lttng_fget_nt_acl_exit, result);
+ return result;
+}
+
+
+static NTSTATUS vfs_lttng_get_nt_acl(vfs_handle_struct *handle,
+ const struct smb_filename *smb_fname,
+ uint32_t security_info,
+ TALLOC_CTX *mem_ctx,
+ struct security_descriptor **ppdesc)
+
+{
+ NTSTATUS result;
+ tracepoint(vfs_lttng, vfs_lttng_get_nt_acl_enter , smb_fname);
+ result = SMB_VFS_NEXT_GET_NT_ACL(handle, smb_fname, security_info, mem_ctx, ppdesc);
+ tracepoint(vfs_lttng, vfs_lttng_get_nt_acl_exit, result);
+ return result;
+}
+
+
+static NTSTATUS vfs_lttng_fset_nt_acl(vfs_handle_struct *handle,
+ files_struct *fsp,
+ uint32_t security_info_sent,
+ const struct security_descriptor *psd)
+
+{
+ NTSTATUS result;
+ tracepoint(vfs_lttng, vfs_lttng_fset_nt_acl_enter , fsp);
+ result = SMB_VFS_NEXT_FSET_NT_ACL(handle, fsp, security_info_sent, psd);
+ tracepoint(vfs_lttng, vfs_lttng_fset_nt_acl_exit, result);
+ return result;
+}
+
+
+static NTSTATUS vfs_lttng_audit_file(struct vfs_handle_struct *handle,
+ struct smb_filename *smb_fname,
+ struct security_acl *sacl,
+ uint32_t access_requested,
+ uint32_t access_denied)
+
+{
+ NTSTATUS result;
+ tracepoint(vfs_lttng, vfs_lttng_audit_file_enter , smb_fname);
+ result = SMB_VFS_NEXT_AUDIT_FILE(handle, smb_fname, sacl, access_requested, access_denied);
+ tracepoint(vfs_lttng, vfs_lttng_audit_file_exit, result);
+ return result;
+}
+
+
+static SMB_ACL_T vfs_lttng_sys_acl_get_file(vfs_handle_struct *handle,
+ const struct smb_filename *smb_fname,
+ SMB_ACL_TYPE_T type,
+ TALLOC_CTX *mem_ctx)
+
+{
+ SMB_ACL_T result;
+ tracepoint(vfs_lttng, vfs_lttng_sys_acl_get_file_enter , smb_fname);
+ result = SMB_VFS_NEXT_SYS_ACL_GET_FILE(handle, smb_fname, type, mem_ctx);
+ tracepoint(vfs_lttng, vfs_lttng_sys_acl_get_file_exit, result);
+ return result;
+}
+
+
+static SMB_ACL_T vfs_lttng_sys_acl_get_fd(vfs_handle_struct *handle,
+ files_struct *fsp,
+ TALLOC_CTX *mem_ctx)
+
+{
+ SMB_ACL_T result;
+ tracepoint(vfs_lttng, vfs_lttng_sys_acl_get_fd_enter , fsp);
+ result = SMB_VFS_NEXT_SYS_ACL_GET_FD(handle, fsp, mem_ctx);
+ tracepoint(vfs_lttng, vfs_lttng_sys_acl_get_fd_exit, result);
+ return result;
+}
+
+
+static int vfs_lttng_sys_acl_blob_get_file(vfs_handle_struct *handle,
+ const struct smb_filename *smb_fname,
+ TALLOC_CTX *mem_ctx,
+ char **blob_description,
+ DATA_BLOB *blob)
+
+{
+ int result;
+ tracepoint(vfs_lttng, vfs_lttng_sys_acl_blob_get_file_enter , smb_fname);
+ result = SMB_VFS_NEXT_SYS_ACL_BLOB_GET_FILE(handle, smb_fname, mem_ctx, blob_description, blob);
+ tracepoint(vfs_lttng, vfs_lttng_sys_acl_blob_get_file_exit, result);
+ return result;
+}
+
+
+static int vfs_lttng_sys_acl_blob_get_fd(vfs_handle_struct *handle,
+ files_struct *fsp,
+ TALLOC_CTX *mem_ctx,
+ char **blob_description,
+ DATA_BLOB *blob)
+
+{
+ int result;
+ tracepoint(vfs_lttng, vfs_lttng_sys_acl_blob_get_fd_enter , fsp);
+ result = SMB_VFS_NEXT_SYS_ACL_BLOB_GET_FD(handle, fsp, mem_ctx, blob_description, blob);
+ tracepoint(vfs_lttng, vfs_lttng_sys_acl_blob_get_fd_exit, result);
+ return result;
+}
+
+
+static int vfs_lttng_sys_acl_set_file(vfs_handle_struct *handle,
+ const struct smb_filename *smb_fname,
+ SMB_ACL_TYPE_T acltype,
+ SMB_ACL_T theacl)
+
+{
+ int result;
+ tracepoint(vfs_lttng, vfs_lttng_sys_acl_set_file_enter , smb_fname);
+ result = SMB_VFS_NEXT_SYS_ACL_SET_FILE(handle, smb_fname, acltype, theacl);
+ tracepoint(vfs_lttng, vfs_lttng_sys_acl_set_file_exit, result);
+ return result;
+}
+
+
+static int vfs_lttng_sys_acl_set_fd(vfs_handle_struct *handle,
+ files_struct *fsp,
+ SMB_ACL_T theacl)
+
+{
+ int result;
+ tracepoint(vfs_lttng, vfs_lttng_sys_acl_set_fd_enter , fsp);
+ result = SMB_VFS_NEXT_SYS_ACL_SET_FD(handle, fsp, theacl);
+ tracepoint(vfs_lttng, vfs_lttng_sys_acl_set_fd_exit, result);
+ return result;
+}
+
+
+static int vfs_lttng_sys_acl_delete_def_file(vfs_handle_struct *handle,
+ const struct smb_filename *smb_fname)
+
+{
+ int result;
+ tracepoint(vfs_lttng, vfs_lttng_sys_acl_delete_def_file_enter , smb_fname);
+ result = SMB_VFS_NEXT_SYS_ACL_DELETE_DEF_FILE(handle, smb_fname);
+ tracepoint(vfs_lttng, vfs_lttng_sys_acl_delete_def_file_exit, result);
+ return result;
+}
+
+
+static ssize_t vfs_lttng_getxattr(struct vfs_handle_struct *handle,
+ const struct smb_filename *smb_fname,
+ const char *name,
+ void *value,
+ size_t size)
+
+{
+ ssize_t result;
+ tracepoint(vfs_lttng, vfs_lttng_getxattr_enter , smb_fname, name);
+ result = SMB_VFS_NEXT_GETXATTR(handle, smb_fname, name, value, size);
+ tracepoint(vfs_lttng, vfs_lttng_getxattr_exit, result);
+ return result;
+}
+
+
+static ssize_t vfs_lttng_fgetxattr(struct vfs_handle_struct *handle,
+ struct files_struct *fsp,
+ const char *name, void *value,
+ size_t size)
+
+{
+ ssize_t result;
+ tracepoint(vfs_lttng, vfs_lttng_fgetxattr_enter , fsp, name);
+ result = SMB_VFS_NEXT_FGETXATTR(handle, fsp, name, value, size);
+ tracepoint(vfs_lttng, vfs_lttng_fgetxattr_exit, result);
+ return result;
+}
+
+
+static ssize_t vfs_lttng_listxattr(struct vfs_handle_struct *handle,
+ const struct smb_filename *smb_fname,
+ char *list,
+ size_t size)
+
+{
+ ssize_t result;
+ tracepoint(vfs_lttng, vfs_lttng_listxattr_enter , smb_fname);
+ result = SMB_VFS_NEXT_LISTXATTR(handle, smb_fname, list, size);
+ tracepoint(vfs_lttng, vfs_lttng_listxattr_exit, result);
+ return result;
+}
+
+
+static ssize_t vfs_lttng_flistxattr(struct vfs_handle_struct *handle,
+ struct files_struct *fsp, char *list,
+ size_t size)
+
+{
+ ssize_t result;
+ tracepoint(vfs_lttng, vfs_lttng_flistxattr_enter , fsp);
+ result = SMB_VFS_NEXT_FLISTXATTR(handle, fsp, list, size);
+ tracepoint(vfs_lttng, vfs_lttng_flistxattr_exit, result);
+ return result;
+}
+
+
+static int vfs_lttng_removexattr(struct vfs_handle_struct *handle,
+ const struct smb_filename *smb_fname,
+ const char *name)
+
+{
+ int result;
+ tracepoint(vfs_lttng, vfs_lttng_removexattr_enter , smb_fname, name);
+ result = SMB_VFS_NEXT_REMOVEXATTR(handle, smb_fname, name);
+ tracepoint(vfs_lttng, vfs_lttng_removexattr_exit, result);
+ return result;
+}
+
+
+static int vfs_lttng_fremovexattr(struct vfs_handle_struct *handle,
+ struct files_struct *fsp,
+ const char *name)
+
+{
+ int result;
+ tracepoint(vfs_lttng, vfs_lttng_fremovexattr_enter , fsp, name);
+ result = SMB_VFS_NEXT_FREMOVEXATTR(handle, fsp, name);
+ tracepoint(vfs_lttng, vfs_lttng_fremovexattr_exit, result);
+ return result;
+}
+
+
+static int vfs_lttng_setxattr(struct vfs_handle_struct *handle,
+ const struct smb_filename *smb_fname,
+ const char *name,
+ const void *value,
+ size_t size,
+ int flags)
+
+{
+ int result;
+ tracepoint(vfs_lttng, vfs_lttng_setxattr_enter , smb_fname, name, flags);
+ result = SMB_VFS_NEXT_SETXATTR(handle, smb_fname, name, value, size, flags);
+ tracepoint(vfs_lttng, vfs_lttng_setxattr_exit, result);
+ return result;
+}
+
+
+static int vfs_lttng_fsetxattr(struct vfs_handle_struct *handle,
+ struct files_struct *fsp, const char *name,
+ const void *value, size_t size, int flags)
+
+{
+ int result;
+ tracepoint(vfs_lttng, vfs_lttng_fsetxattr_enter , fsp, name, flags);
+ result = SMB_VFS_NEXT_FSETXATTR(handle, fsp, name, value, size, flags);
+ tracepoint(vfs_lttng, vfs_lttng_fsetxattr_exit, result);
+ return result;
+}
+
+
+static bool vfs_lttng_aio_force(struct vfs_handle_struct *handle,
+ struct files_struct *fsp)
+
+{
+ bool result;
+ tracepoint(vfs_lttng, vfs_lttng_aio_force_enter , fsp);
+ result = SMB_VFS_NEXT_AIO_FORCE(handle, fsp);
+ tracepoint(vfs_lttng, vfs_lttng_aio_force_exit, result);
+ return result;
+}
+
+
+static NTSTATUS vfs_lttng_durable_cookie(struct vfs_handle_struct *handle,
+ struct files_struct *fsp,
+ TALLOC_CTX *mem_ctx,
+ DATA_BLOB *cookie)
+
+{
+ NTSTATUS result;
+ tracepoint(vfs_lttng, vfs_lttng_durable_cookie_enter , fsp);
+ result = SMB_VFS_NEXT_DURABLE_COOKIE(handle, fsp, mem_ctx, cookie);
+ tracepoint(vfs_lttng, vfs_lttng_durable_cookie_exit, result);
+ return result;
+}
+
+
+static NTSTATUS vfs_lttng_durable_disconnect(struct vfs_handle_struct *handle,
+ struct files_struct *fsp,
+ const DATA_BLOB old_cookie,
+ TALLOC_CTX *mem_ctx,
+ DATA_BLOB *new_cookie)
+
+{
+ NTSTATUS result;
+ tracepoint(vfs_lttng, vfs_lttng_durable_disconnect_enter , fsp);
+ result = SMB_VFS_NEXT_DURABLE_DISCONNECT(handle, fsp, old_cookie, mem_ctx, new_cookie);
+ tracepoint(vfs_lttng, vfs_lttng_durable_disconnect_exit, result);
+ return result;
+}
+
+
+static NTSTATUS vfs_lttng_durable_reconnect(struct vfs_handle_struct *handle,
+ struct smb_request *smb1req,
+ struct smbXsrv_open *op,
+ const DATA_BLOB old_cookie,
+ TALLOC_CTX *mem_ctx,
+ struct files_struct **fsp,
+ DATA_BLOB *new_cookie)
+
+{
+ NTSTATUS result;
+ tracepoint(vfs_lttng, vfs_lttng_durable_reconnect_enter , fsp);
+ result = SMB_VFS_NEXT_DURABLE_RECONNECT(handle, smb1req, op, old_cookie, mem_ctx, fsp, new_cookie);
+ tracepoint(vfs_lttng, vfs_lttng_durable_reconnect_exit, result);
+ return result;
+}
+
+
+static NTSTATUS vfs_lttng_readdir_attr(struct vfs_handle_struct *handle,
+ const struct smb_filename *fname,
+ TALLOC_CTX *mem_ctx,
+ struct readdir_attr_data **pattr_data)
+
+{
+ NTSTATUS result;
+ tracepoint(vfs_lttng, vfs_lttng_readdir_attr_enter , fname);
+ result = SMB_VFS_NEXT_READDIR_ATTR(handle, fname, mem_ctx, pattr_data);
+ tracepoint(vfs_lttng, vfs_lttng_readdir_attr_exit, result);
+ return result;
+}
+
+static struct vfs_fn_pointers vfs_lttng_fns = {
+ .connect_fn = vfs_lttng_connect,
+ .disconnect_fn = vfs_lttng_disconnect,
+ .disk_free_fn = vfs_lttng_disk_free,
+ .get_quota_fn = vfs_lttng_get_quota,
+ .set_quota_fn = vfs_lttng_set_quota,
+ .get_shadow_copy_data_fn = vfs_lttng_get_shadow_copy_data,
+ .statvfs_fn = vfs_lttng_statvfs,
+ .fs_capabilities_fn = vfs_lttng_fs_capabilities,
+ .get_dfs_referrals_fn = vfs_lttng_get_dfs_referrals,
+ .opendir_fn = vfs_lttng_opendir,
+ .fdopendir_fn = vfs_lttng_fdopendir,
+ .readdir_fn = vfs_lttng_readdir,
+ .seekdir_fn = vfs_lttng_seekdir,
+ .telldir_fn = vfs_lttng_telldir,
+ .mkdir_fn = vfs_lttng_mkdir,
+ .rmdir_fn = vfs_lttng_rmdir,
+ .closedir_fn = vfs_lttng_closedir,
+ .open_fn = vfs_lttng_open,
+ .create_file_fn = vfs_lttng_create_file,
+ .close_fn = vfs_lttng_close,
+ .pread_fn = vfs_lttng_pread,
+ .pwrite_fn = vfs_lttng_pwrite,
+ .lseek_fn = vfs_lttng_lseek,
+ .sendfile_fn = vfs_lttng_sendfile,
+ .recvfile_fn = vfs_lttng_recvfile,
+ .rename_fn = vfs_lttng_rename,
+ .stat_fn = vfs_lttng_stat,
+ .fstat_fn = vfs_lttng_fstat,
+ .lstat_fn = vfs_lttng_lstat,
+ .get_alloc_size_fn = vfs_lttng_get_alloc_size,
+ .unlink_fn = vfs_lttng_unlink,
+ .chmod_fn = vfs_lttng_chmod,
+ .fchmod_fn = vfs_lttng_fchmod,
+ .chown_fn = vfs_lttng_chown,
+ .fchown_fn = vfs_lttng_fchown,
+ .lchown_fn = vfs_lttng_lchown,
+ .chdir_fn = vfs_lttng_chdir,
+ .getwd_fn = vfs_lttng_getwd,
+ .ntimes_fn = vfs_lttng_ntimes,
+ .ftruncate_fn = vfs_lttng_ftruncate,
+ .fallocate_fn = vfs_lttng_fallocate,
+ .lock_fn = vfs_lttng_lock,
+ .kernel_flock_fn = vfs_lttng_kernel_flock,
+ .linux_setlease_fn = vfs_lttng_linux_setlease,
+ .getlock_fn = vfs_lttng_getlock,
+ .symlink_fn = vfs_lttng_symlink,
+ .readlink_fn = vfs_lttng_readlink,
+ .link_fn = vfs_lttng_link,
+ .mknod_fn = vfs_lttng_mknod,
+ .realpath_fn = vfs_lttng_realpath,
+ .chflags_fn = vfs_lttng_chflags,
+ .file_id_create_fn = vfs_lttng_file_id_create,
+ .offload_read_send_fn = vfs_lttng_offload_read_send,
+ .offload_read_recv_fn = vfs_lttng_offload_read_recv,
+ .offload_write_send_fn = vfs_lttng_offload_write_send,
+ .offload_write_recv_fn = vfs_lttng_offload_write_recv,
+ .get_compression_fn = vfs_lttng_get_compression,
+ .set_compression_fn = vfs_lttng_set_compression,
+ .snap_check_path_fn = vfs_lttng_snap_check_path,
+ .snap_create_fn = vfs_lttng_snap_create,
+ .snap_delete_fn = vfs_lttng_snap_delete,
+ .streaminfo_fn = vfs_lttng_streaminfo,
+ .get_real_filename_fn = vfs_lttng_get_real_filename,
+ .connectpath_fn = vfs_lttng_connectpath,
+ .brl_lock_windows_fn = vfs_lttng_brl_lock_windows,
+ .brl_unlock_windows_fn = vfs_lttng_brl_unlock_windows,
+ .brl_cancel_windows_fn = vfs_lttng_brl_cancel_windows,
+ .strict_lock_check_fn = vfs_lttng_strict_lock_check,
+ .translate_name_fn = vfs_lttng_translate_name,
+ .fsctl_fn = vfs_lttng_fsctl,
+ .get_dos_attributes_fn = vfs_lttng_get_dos_attributes,
+ .fget_dos_attributes_fn = vfs_lttng_fget_dos_attributes,
+ .set_dos_attributes_fn = vfs_lttng_set_dos_attributes,
+ .fset_dos_attributes_fn = vfs_lttng_fset_dos_attributes,
+ .fget_nt_acl_fn = vfs_lttng_fget_nt_acl,
+ .get_nt_acl_fn = vfs_lttng_get_nt_acl,
+ .fset_nt_acl_fn = vfs_lttng_fset_nt_acl,
+ .audit_file_fn = vfs_lttng_audit_file,
+ .sys_acl_get_file_fn = vfs_lttng_sys_acl_get_file,
+ .sys_acl_get_fd_fn = vfs_lttng_sys_acl_get_fd,
+ .sys_acl_blob_get_file_fn = vfs_lttng_sys_acl_blob_get_file,
+ .sys_acl_blob_get_fd_fn = vfs_lttng_sys_acl_blob_get_fd,
+ .sys_acl_set_file_fn = vfs_lttng_sys_acl_set_file,
+ .sys_acl_set_fd_fn = vfs_lttng_sys_acl_set_fd,
+ .sys_acl_delete_def_file_fn = vfs_lttng_sys_acl_delete_def_file,
+ .getxattr_fn = vfs_lttng_getxattr,
+ .fgetxattr_fn = vfs_lttng_fgetxattr,
+ .listxattr_fn = vfs_lttng_listxattr,
+ .flistxattr_fn = vfs_lttng_flistxattr,
+ .removexattr_fn = vfs_lttng_removexattr,
+ .fremovexattr_fn = vfs_lttng_fremovexattr,
+ .setxattr_fn = vfs_lttng_setxattr,
+ .fsetxattr_fn = vfs_lttng_fsetxattr,
+ .aio_force_fn = vfs_lttng_aio_force,
+ .durable_cookie_fn = vfs_lttng_durable_cookie,
+ .durable_disconnect_fn = vfs_lttng_durable_disconnect,
+ .durable_reconnect_fn = vfs_lttng_durable_reconnect,
+ .readdir_attr_fn = vfs_lttng_readdir_attr
+};
+
+NTSTATUS vfs_lttng_init(TALLOC_CTX *);
+NTSTATUS vfs_lttng_init(TALLOC_CTX *ctx)
+{
+ return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "lttng",
+ &vfs_lttng_fns);
+}
+
diff --git a/source3/modules/vfs_lttng_tp.h b/source3/modules/vfs_lttng_tp.h
new file mode 100644
index 00000000000..5e8edeaf944
--- /dev/null
+++ b/source3/modules/vfs_lttng_tp.h
@@ -0,0 +1,2321 @@
+/*
+
+ * LTTNG VFS module for samba. Trace VFS functions using lttng
+
+ * Copyright (C) Dongmao Zhang <deanraccoon at gmail.com>
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#undef TRACEPOINT_PROVIDER
+#define TRACEPOINT_PROVIDER vfs_lttng
+
+#undef TRACEPOINT_INCLUDE
+#define TRACEPOINT_INCLUDE "modules/vfs_lttng_tp.h"
+
+#if !defined(VFS_LTTNG_TP_H) || defined(TRACEPOINT_HEADER_MULTI_READ)
+#define VFS_LTTNG_TP_H
+
+#include <lttng/tracepoint.h>
+#include <includes.h>
+
+/* vfs_lttng_connect START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_connect_enter,
+ TP_ARGS(
+
+ ),
+ TP_FIELDS(
+
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_connect_exit,
+ TP_ARGS(
+ int, result
+ ),
+ TP_FIELDS(
+ ctf_integer(int, retval, result)
+ )
+)
+/* vfs_lttng_connect END*/
+
+/* vfs_lttng_disconnect START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_disconnect_enter,
+ TP_ARGS(
+
+ ),
+ TP_FIELDS(
+
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_disconnect_exit,
+ TP_ARGS(
+ ),
+ TP_FIELDS(
+ )
+)
+/* vfs_lttng_disconnect END*/
+
+/* vfs_lttng_disk_free START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_disk_free_enter,
+ TP_ARGS(
+ const struct smb_filename *, smb_fname
+ ),
+ TP_FIELDS(
+ ctf_string(filename, smb_fname->base_name)
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_disk_free_exit,
+ TP_ARGS(
+ uint64_t, result
+ ),
+ TP_FIELDS(
+ ctf_integer(uint64_t, retval, result)
+ )
+)
+/* vfs_lttng_disk_free END*/
+
+/* vfs_lttng_get_quota START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_get_quota_enter,
+ TP_ARGS(
+ const struct smb_filename *, smb_fname
+ ),
+ TP_FIELDS(
+ ctf_string(filename, smb_fname->base_name)
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_get_quota_exit,
+ TP_ARGS(
+ int, result
+ ),
+ TP_FIELDS(
+ ctf_integer(int, retval, result)
+ )
+)
+/* vfs_lttng_get_quota END*/
+
+/* vfs_lttng_set_quota START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_set_quota_enter,
+ TP_ARGS(
+
+ ),
+ TP_FIELDS(
+
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_set_quota_exit,
+ TP_ARGS(
+ int, result
+ ),
+ TP_FIELDS(
+ ctf_integer(int, retval, result)
+ )
+)
+/* vfs_lttng_set_quota END*/
+
+/* vfs_lttng_get_shadow_copy_data START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_get_shadow_copy_data_enter,
+ TP_ARGS(
+ struct files_struct *, fsp
+ ),
+ TP_FIELDS(
+ ctf_string(filename, fsp->fsp_name->base_name)
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_get_shadow_copy_data_exit,
+ TP_ARGS(
+ int, result
+ ),
+ TP_FIELDS(
+ ctf_integer(int, retval, result)
+ )
+)
+/* vfs_lttng_get_shadow_copy_data END*/
+
+/* vfs_lttng_statvfs START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_statvfs_enter,
+ TP_ARGS(
+ const struct smb_filename *, smb_fname
+ ),
+ TP_FIELDS(
+ ctf_string(filename, smb_fname->base_name)
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_statvfs_exit,
+ TP_ARGS(
+ int, result
+ ),
+ TP_FIELDS(
+ ctf_integer(int, retval, result)
+ )
+)
+/* vfs_lttng_statvfs END*/
+
+/* vfs_lttng_fs_capabilities START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_fs_capabilities_enter,
+ TP_ARGS(
+
+ ),
+ TP_FIELDS(
+
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_fs_capabilities_exit,
+ TP_ARGS(
+ uint32_t, result
+ ),
+ TP_FIELDS(
+ ctf_integer(uint32_t, retval, result)
+ )
+)
+/* vfs_lttng_fs_capabilities END*/
+
+/* vfs_lttng_get_dfs_referrals START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_get_dfs_referrals_enter,
+ TP_ARGS(
+
+ ),
+ TP_FIELDS(
+
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_get_dfs_referrals_exit,
+ TP_ARGS(
+ NTSTATUS, result
+ ),
+ TP_FIELDS(
+ ctf_integer(int, retval, result.v)
+ )
+)
+/* vfs_lttng_get_dfs_referrals END*/
+
+/* vfs_lttng_opendir START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_opendir_enter,
+ TP_ARGS(
+ const struct smb_filename *, smb_fname
+ ),
+ TP_FIELDS(
+ ctf_string(filename, smb_fname->base_name)
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_opendir_exit,
+ TP_ARGS(
+ ),
+ TP_FIELDS(
+ )
+)
+/* vfs_lttng_opendir END*/
+
+/* vfs_lttng_fdopendir START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_fdopendir_enter,
+ TP_ARGS(
+ files_struct *, fsp
+ ),
+ TP_FIELDS(
+ ctf_string(filename, fsp->fsp_name->base_name)
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_fdopendir_exit,
+ TP_ARGS(
+ ),
+ TP_FIELDS(
+ )
+)
+/* vfs_lttng_fdopendir END*/
+
+/* vfs_lttng_readdir START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_readdir_enter,
+ TP_ARGS(
+
+ ),
+ TP_FIELDS(
+
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_readdir_exit,
+ TP_ARGS(
+ ),
+ TP_FIELDS(
+ )
+)
+/* vfs_lttng_readdir END*/
+
+/* vfs_lttng_seekdir START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_seekdir_enter,
+ TP_ARGS(
+ long, offset
+ ),
+ TP_FIELDS(
+ ctf_integer(off_t, offset, offset)
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_seekdir_exit,
+ TP_ARGS(
+ ),
+ TP_FIELDS(
+ )
+)
+/* vfs_lttng_seekdir END*/
+
+/* vfs_lttng_telldir START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_telldir_enter,
+ TP_ARGS(
+
+ ),
+ TP_FIELDS(
+
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_telldir_exit,
+ TP_ARGS(
+ long, result
+ ),
+ TP_FIELDS(
+ ctf_integer(long, retval, result)
+ )
+)
+/* vfs_lttng_telldir END*/
+
+/* vfs_lttng_mkdir START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_mkdir_enter,
+ TP_ARGS(
+ const struct smb_filename *, smb_fname,
+ mode_t, mode
+ ),
+ TP_FIELDS(
+ ctf_string(filename, smb_fname->base_name)
+ ctf_integer(mode_t, mode, mode)
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_mkdir_exit,
+ TP_ARGS(
+ int, result
+ ),
+ TP_FIELDS(
+ ctf_integer(int, retval, result)
+ )
+)
+/* vfs_lttng_mkdir END*/
+
+/* vfs_lttng_rmdir START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_rmdir_enter,
+ TP_ARGS(
+ const struct smb_filename *, smb_fname
+ ),
+ TP_FIELDS(
+ ctf_string(filename, smb_fname->base_name)
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_rmdir_exit,
+ TP_ARGS(
+ int, result
+ ),
+ TP_FIELDS(
+ ctf_integer(int, retval, result)
+ )
+)
+/* vfs_lttng_rmdir END*/
+
+/* vfs_lttng_closedir START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_closedir_enter,
+ TP_ARGS(
+
+ ),
+ TP_FIELDS(
+
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_closedir_exit,
+ TP_ARGS(
+ int, result
+ ),
+ TP_FIELDS(
+ ctf_integer(int, retval, result)
+ )
+)
+/* vfs_lttng_closedir END*/
+
+/* vfs_lttng_open START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_open_enter,
+ TP_ARGS(
+ struct smb_filename *, fname,
+ int, flags,
+ mode_t, mode
+ ),
+ TP_FIELDS(
+ ctf_string(filename, fname->base_name)
+ ctf_integer(int, flags, flags)
+ ctf_integer(mode_t, mode, mode)
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_open_exit,
+ TP_ARGS(
+ int, result
+ ),
+ TP_FIELDS(
+ ctf_integer(int, retval, result)
+ )
+)
+/* vfs_lttng_open END*/
+
+/* vfs_lttng_create_file START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_create_file_enter,
+ TP_ARGS(
+ struct smb_filename *, fname
+ ),
+ TP_FIELDS(
+ ctf_string(filename, fname->base_name)
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_create_file_exit,
+ TP_ARGS(
+ NTSTATUS, result
+ ),
+ TP_FIELDS(
+ ctf_integer(int, retval, result.v)
+ )
+)
+/* vfs_lttng_create_file END*/
+
+/* vfs_lttng_close START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_close_enter,
+ TP_ARGS(
+ files_struct *, fsp
+ ),
+ TP_FIELDS(
+ ctf_string(filename, fsp->fsp_name->base_name)
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_close_exit,
+ TP_ARGS(
+ int, result
+ ),
+ TP_FIELDS(
+ ctf_integer(int, retval, result)
+ )
+)
+/* vfs_lttng_close END*/
+
+
+/* vfs_lttng_pread START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_pread_enter,
+ TP_ARGS(
+ files_struct *, fsp,
+ size_t, n,
+ off_t, offset
+ ),
+ TP_FIELDS(
+ ctf_string(filename, fsp->fsp_name->base_name)
+ ctf_integer(size_t, n, n)
+ ctf_integer(off_t, offset, offset)
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_pread_exit,
+ TP_ARGS(
+ ssize_t, result
+ ),
+ TP_FIELDS(
+ ctf_integer(ssize_t, retval, result)
+ )
+)
+/* vfs_lttng_pread END*/
+
+
+/* vfs_lttng_pwrite START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_pwrite_enter,
+ TP_ARGS(
+ files_struct *, fsp,
+ size_t, n,
+ off_t, offset
+ ),
+ TP_FIELDS(
+ ctf_string(filename, fsp->fsp_name->base_name)
+ ctf_integer(size_t, n, n)
+ ctf_integer(off_t, offset, offset)
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_pwrite_exit,
+ TP_ARGS(
+ ssize_t, result
+ ),
+ TP_FIELDS(
+ ctf_integer(ssize_t, retval, result)
+ )
+)
+/* vfs_lttng_pwrite END*/
+
+/* vfs_lttng_lseek START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_lseek_enter,
+ TP_ARGS(
+ files_struct *, fsp,
+ off_t, offset
+ ),
+ TP_FIELDS(
+ ctf_string(filename, fsp->fsp_name->base_name)
+ ctf_integer(off_t, offset, offset)
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_lseek_exit,
+ TP_ARGS(
+ off_t, result
+ ),
+ TP_FIELDS(
+ ctf_integer(off_t, retval, result)
+ )
+)
+/* vfs_lttng_lseek END*/
+
+/* vfs_lttng_sendfile START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_sendfile_enter,
+ TP_ARGS(
+ int, tofd,
+ off_t, offset,
+ size_t, n
+ ),
+ TP_FIELDS(
+ ctf_integer(int, tofd, tofd)
+ ctf_integer(off_t, offset, offset)
+ ctf_integer(size_t, n, n)
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_sendfile_exit,
+ TP_ARGS(
+ ssize_t, result
+ ),
+ TP_FIELDS(
+ ctf_integer(ssize_t, retval, result)
+ )
+)
+/* vfs_lttng_sendfile END*/
+
+/* vfs_lttng_recvfile START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_recvfile_enter,
+ TP_ARGS(
+ off_t, offset,
+ size_t, n
+ ),
+ TP_FIELDS(
+ ctf_integer(off_t, offset, offset)
+ ctf_integer(size_t, n, n)
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_recvfile_exit,
+ TP_ARGS(
+ ssize_t, result
+ ),
+ TP_FIELDS(
+ ctf_integer(ssize_t, retval, result)
+ )
+)
+/* vfs_lttng_recvfile END*/
+
+/* vfs_lttng_rename START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_rename_enter,
+ TP_ARGS(
+
+ ),
+ TP_FIELDS(
+
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_rename_exit,
+ TP_ARGS(
+ int, result
+ ),
+ TP_FIELDS(
+ ctf_integer(int, retval, result)
+ )
+)
+/* vfs_lttng_rename END*/
+
+/* vfs_lttng_stat START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_stat_enter,
+ TP_ARGS(
+ struct smb_filename *, fname
+ ),
+ TP_FIELDS(
+ ctf_string(filename, fname->base_name)
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_stat_exit,
+ TP_ARGS(
+ int, result
+ ),
+ TP_FIELDS(
+ ctf_integer(int, retval, result)
+ )
+)
+/* vfs_lttng_stat END*/
+
+/* vfs_lttng_fstat START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_fstat_enter,
+ TP_ARGS(
+ files_struct *, fsp
+ ),
+ TP_FIELDS(
+ ctf_string(filename, fsp->fsp_name->base_name)
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_fstat_exit,
+ TP_ARGS(
+ int, result
+ ),
+ TP_FIELDS(
+ ctf_integer(int, retval, result)
+ )
+)
+/* vfs_lttng_fstat END*/
+
+/* vfs_lttng_lstat START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_lstat_enter,
+ TP_ARGS(
+
+ ),
+ TP_FIELDS(
+
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_lstat_exit,
+ TP_ARGS(
+ int, result
+ ),
+ TP_FIELDS(
+ ctf_integer(int, retval, result)
+ )
+)
+/* vfs_lttng_lstat END*/
+
+/* vfs_lttng_get_alloc_size START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_get_alloc_size_enter,
+ TP_ARGS(
+ ),
+ TP_FIELDS(
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_get_alloc_size_exit,
+ TP_ARGS(
+ uint64_t, result
+ ),
+ TP_FIELDS(
+ ctf_integer(uint64_t, retval, result)
+ )
+)
+/* vfs_lttng_get_alloc_size END*/
+
+/* vfs_lttng_unlink START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_unlink_enter,
+ TP_ARGS(
+
+ ),
+ TP_FIELDS(
+
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_unlink_exit,
+ TP_ARGS(
+ int, result
+ ),
+ TP_FIELDS(
+ ctf_integer(int, retval, result)
+ )
+)
+/* vfs_lttng_unlink END*/
+
+/* vfs_lttng_chmod START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_chmod_enter,
+ TP_ARGS(
+ const struct smb_filename *, smb_fname,
+ mode_t, mode
+ ),
+ TP_FIELDS(
+ ctf_string(filename, smb_fname->base_name)
+ ctf_integer(mode_t, mode, mode)
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_chmod_exit,
+ TP_ARGS(
+ int, result
+ ),
+ TP_FIELDS(
+ ctf_integer(int, retval, result)
+ )
+)
+/* vfs_lttng_chmod END*/
+
+/* vfs_lttng_fchmod START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_fchmod_enter,
+ TP_ARGS(
+ files_struct *, fsp,
+ mode_t, mode
+ ),
+ TP_FIELDS(
+ ctf_string(filename, fsp->fsp_name->base_name)
+ ctf_integer(mode_t, mode, mode)
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_fchmod_exit,
+ TP_ARGS(
+ int, result
+ ),
+ TP_FIELDS(
+ ctf_integer(int, retval, result)
+ )
+)
+/* vfs_lttng_fchmod END*/
+
+/* vfs_lttng_chown START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_chown_enter,
+ TP_ARGS(
+ const struct smb_filename *, smb_fname
+ ),
+ TP_FIELDS(
+ ctf_string(filename, smb_fname->base_name)
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_chown_exit,
+ TP_ARGS(
+ int, result
+ ),
+ TP_FIELDS(
+ ctf_integer(int, retval, result)
+ )
+)
+/* vfs_lttng_chown END*/
+
+/* vfs_lttng_fchown START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_fchown_enter,
+ TP_ARGS(
+ files_struct *, fsp
+ ),
+ TP_FIELDS(
+ ctf_string(filename, fsp->fsp_name->base_name)
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_fchown_exit,
+ TP_ARGS(
+ int, result
+ ),
+ TP_FIELDS(
+ ctf_integer(int, retval, result)
+ )
+)
+/* vfs_lttng_fchown END*/
+
+/* vfs_lttng_lchown START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_lchown_enter,
+ TP_ARGS(
+ const struct smb_filename *, smb_fname
+ ),
+ TP_FIELDS(
+ ctf_string(filename, smb_fname->base_name)
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_lchown_exit,
+ TP_ARGS(
+ int, result
+ ),
+ TP_FIELDS(
+ ctf_integer(int, retval, result)
+ )
+)
+/* vfs_lttng_lchown END*/
+
+/* vfs_lttng_chdir START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_chdir_enter,
+ TP_ARGS(
+ const struct smb_filename *, smb_fname
+ ),
+ TP_FIELDS(
+ ctf_string(filename, smb_fname->base_name)
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_chdir_exit,
+ TP_ARGS(
+ int, result
+ ),
+ TP_FIELDS(
+ ctf_integer(int, retval, result)
+ )
+)
+/* vfs_lttng_chdir END*/
+
+/* vfs_lttng_getwd START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_getwd_enter,
+ TP_ARGS(
+
+ ),
+ TP_FIELDS(
+
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_getwd_exit,
+ TP_ARGS(
+ ),
+ TP_FIELDS(
+ )
+)
+/* vfs_lttng_getwd END*/
+
+/* vfs_lttng_ntimes START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_ntimes_enter,
+ TP_ARGS(
+
+ ),
+ TP_FIELDS(
+
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_ntimes_exit,
+ TP_ARGS(
+ int, result
+ ),
+ TP_FIELDS(
+ ctf_integer(int, retval, result)
+ )
+)
+/* vfs_lttng_ntimes END*/
+
+/* vfs_lttng_ftruncate START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_ftruncate_enter,
+ TP_ARGS(
+ files_struct *, fsp
+ ),
+ TP_FIELDS(
+ ctf_string(filename, fsp->fsp_name->base_name)
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_ftruncate_exit,
+ TP_ARGS(
+ int, result
+ ),
+ TP_FIELDS(
+ ctf_integer(int, retval, result)
+ )
+)
+/* vfs_lttng_ftruncate END*/
+
+/* vfs_lttng_fallocate START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_fallocate_enter,
+ TP_ARGS(
+ files_struct *, fsp,
+ uint32_t, mode,
+ off_t, offset
+ ),
+ TP_FIELDS(
+ ctf_string(filename, fsp->fsp_name->base_name)
+ ctf_integer(mode_t, mode, mode)
+ ctf_integer(off_t, offset, offset)
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_fallocate_exit,
+ TP_ARGS(
+ int, result
+ ),
+ TP_FIELDS(
+ ctf_integer(int, retval, result)
+ )
+)
+/* vfs_lttng_fallocate END*/
+
+/* vfs_lttng_lock START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_lock_enter,
+ TP_ARGS(
+ files_struct *, fsp,
+ off_t, offset
+ ),
+ TP_FIELDS(
+ ctf_string(filename, fsp->fsp_name->base_name)
+ ctf_integer(off_t, offset, offset)
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_lock_exit,
+ TP_ARGS(
+ bool, result
+ ),
+ TP_FIELDS(
+ ctf_integer(bool, retval, result)
+ )
+)
+/* vfs_lttng_lock END*/
+
+/* vfs_lttng_kernel_flock START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_kernel_flock_enter,
+ TP_ARGS(
+ struct files_struct *, fsp
+ ),
+ TP_FIELDS(
+ ctf_string(filename, fsp->fsp_name->base_name)
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_kernel_flock_exit,
+ TP_ARGS(
+ int, result
+ ),
+ TP_FIELDS(
+ ctf_integer(int, retval, result)
+ )
+)
+/* vfs_lttng_kernel_flock END*/
+
+/* vfs_lttng_linux_setlease START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_linux_setlease_enter,
+ TP_ARGS(
+ files_struct *, fsp
+ ),
+ TP_FIELDS(
+ ctf_string(filename, fsp->fsp_name->base_name)
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_linux_setlease_exit,
+ TP_ARGS(
+ int, result
+ ),
+ TP_FIELDS(
+ ctf_integer(int, retval, result)
+ )
+)
+/* vfs_lttng_linux_setlease END*/
+
+/* vfs_lttng_getlock START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_getlock_enter,
+ TP_ARGS(
+ files_struct *, fsp
+ ),
+ TP_FIELDS(
+ ctf_string(filename, fsp->fsp_name->base_name)
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_getlock_exit,
+ TP_ARGS(
+ bool, result
+ ),
+ TP_FIELDS(
+ ctf_integer(bool, retval, result)
+ )
+)
+/* vfs_lttng_getlock END*/
+
+/* vfs_lttng_symlink START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_symlink_enter,
+ TP_ARGS(
+
+ ),
+ TP_FIELDS(
+
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_symlink_exit,
+ TP_ARGS(
+ int, result
+ ),
+ TP_FIELDS(
+ ctf_integer(int, retval, result)
+ )
+)
+/* vfs_lttng_symlink END*/
+
+/* vfs_lttng_readlink START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_readlink_enter,
+ TP_ARGS(
+ const struct smb_filename *, smb_fname
+ ),
+ TP_FIELDS(
+ ctf_string(filename, smb_fname->base_name)
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_readlink_exit,
+ TP_ARGS(
+ int, result
+ ),
+ TP_FIELDS(
+ ctf_integer(int, retval, result)
+ )
+)
+/* vfs_lttng_readlink END*/
+
+/* vfs_lttng_link START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_link_enter,
+ TP_ARGS(
+
+ ),
+ TP_FIELDS(
+
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_link_exit,
+ TP_ARGS(
+ int, result
+ ),
+ TP_FIELDS(
+ ctf_integer(int, retval, result)
+ )
+)
+/* vfs_lttng_link END*/
+
+/* vfs_lttng_mknod START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_mknod_enter,
+ TP_ARGS(
+ const struct smb_filename *, smb_fname,
+ mode_t, mode
+ ),
+ TP_FIELDS(
+ ctf_string(filename, smb_fname->base_name)
+ ctf_integer(mode_t, mode, mode)
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_mknod_exit,
+ TP_ARGS(
+ int, result
+ ),
+ TP_FIELDS(
+ ctf_integer(int, retval, result)
+ )
+)
+/* vfs_lttng_mknod END*/
+
+/* vfs_lttng_realpath START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_realpath_enter,
+ TP_ARGS(
+ const struct smb_filename *, smb_fname
+ ),
+ TP_FIELDS(
+ ctf_string(filename, smb_fname->base_name)
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_realpath_exit,
+ TP_ARGS(
+ ),
+ TP_FIELDS(
+ )
+)
+/* vfs_lttng_realpath END*/
+
+/* vfs_lttng_chflags START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_chflags_enter,
+ TP_ARGS(
+ const struct smb_filename *, smb_fname,
+ unsigned int, flags
+ ),
+ TP_FIELDS(
+ ctf_string(filename, smb_fname->base_name)
+ ctf_integer(int, flags, flags)
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_chflags_exit,
+ TP_ARGS(
+ int, result
+ ),
+ TP_FIELDS(
+ ctf_integer(int, retval, result)
+ )
+)
+/* vfs_lttng_chflags END*/
+
+/* vfs_lttng_file_id_create START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_file_id_create_enter,
+ TP_ARGS(
+
+ ),
+ TP_FIELDS(
+
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_file_id_create_exit,
+ TP_ARGS(
+ ),
+ TP_FIELDS(
+ )
+)
+/* vfs_lttng_file_id_create END*/
+
+/* vfs_lttng_offload_read_send START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_offload_read_send_enter,
+ TP_ARGS(
+ struct files_struct *, fsp,
+ off_t, offset
+ ),
+ TP_FIELDS(
+ ctf_string(filename, fsp->fsp_name->base_name)
+ ctf_integer(off_t, offset, offset)
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_offload_read_send_exit,
+ TP_ARGS(
+ ),
+ TP_FIELDS(
+ )
+)
+/* vfs_lttng_offload_read_send END*/
+
+/* vfs_lttng_offload_read_recv START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_offload_read_recv_enter,
+ TP_ARGS(
+
+ ),
+ TP_FIELDS(
+
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_offload_read_recv_exit,
+ TP_ARGS(
+ NTSTATUS, result
+ ),
+ TP_FIELDS(
+ ctf_integer(int, retval, result.v)
+ )
+)
+/* vfs_lttng_offload_read_recv END*/
+
+/* vfs_lttng_offload_write_send START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_offload_write_send_enter,
+ TP_ARGS(
+
+ ),
+ TP_FIELDS(
+
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_offload_write_send_exit,
+ TP_ARGS(
+ ),
+ TP_FIELDS(
+ )
+)
+/* vfs_lttng_offload_write_send END*/
+
+/* vfs_lttng_offload_write_recv START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_offload_write_recv_enter,
+ TP_ARGS(
+
+ ),
+ TP_FIELDS(
+
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_offload_write_recv_exit,
+ TP_ARGS(
+ NTSTATUS, result
+ ),
+ TP_FIELDS(
+ ctf_integer(int, retval, result.v)
+ )
+)
+/* vfs_lttng_offload_write_recv END*/
+
+/* vfs_lttng_get_compression START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_get_compression_enter,
+ TP_ARGS(
+ struct files_struct *, fsp
+ ),
+ TP_FIELDS(
+ ctf_string(filename, fsp->fsp_name->base_name)
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_get_compression_exit,
+ TP_ARGS(
+ NTSTATUS, result
+ ),
+ TP_FIELDS(
+ ctf_integer(int, retval, result.v)
+ )
+)
+/* vfs_lttng_get_compression END*/
+
+/* vfs_lttng_set_compression START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_set_compression_enter,
+ TP_ARGS(
+ struct files_struct *, fsp
+ ),
+ TP_FIELDS(
+ ctf_string(filename, fsp->fsp_name->base_name)
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_set_compression_exit,
+ TP_ARGS(
+ NTSTATUS, result
+ ),
+ TP_FIELDS(
+ ctf_integer(int, retval, result.v)
+ )
+)
+/* vfs_lttng_set_compression END*/
+
+/* vfs_lttng_snap_check_path START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_snap_check_path_enter,
+ TP_ARGS(
+
+ ),
+ TP_FIELDS(
+
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_snap_check_path_exit,
+ TP_ARGS(
+ NTSTATUS, result
+ ),
+ TP_FIELDS(
+ ctf_integer(int, retval, result.v)
+ )
+)
+/* vfs_lttng_snap_check_path END*/
+
+/* vfs_lttng_snap_create START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_snap_create_enter,
+ TP_ARGS(
+
+ ),
+ TP_FIELDS(
+
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_snap_create_exit,
+ TP_ARGS(
+ NTSTATUS, result
+ ),
+ TP_FIELDS(
+ ctf_integer(int, retval, result.v)
+ )
+)
+/* vfs_lttng_snap_create END*/
+
+/* vfs_lttng_snap_delete START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_snap_delete_enter,
+ TP_ARGS(
+
+ ),
+ TP_FIELDS(
+
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_snap_delete_exit,
+ TP_ARGS(
+ NTSTATUS, result
+ ),
+ TP_FIELDS(
+ ctf_integer(int, retval, result.v)
+ )
+)
+/* vfs_lttng_snap_delete END*/
+
+/* vfs_lttng_streaminfo START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_streaminfo_enter,
+ TP_ARGS(
+ struct files_struct *, fsp
+ ),
+ TP_FIELDS(
+ ctf_string(filename, fsp->fsp_name->base_name)
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_streaminfo_exit,
+ TP_ARGS(
+ NTSTATUS, result
+ ),
+ TP_FIELDS(
+ ctf_integer(int, retval, result.v)
+ )
+)
+/* vfs_lttng_streaminfo END*/
+
+/* vfs_lttng_get_real_filename START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_get_real_filename_enter,
+ TP_ARGS(
+ const char *, name
+ ),
+ TP_FIELDS(
+ ctf_string(name, name)
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_get_real_filename_exit,
+ TP_ARGS(
+ int, result
+ ),
+ TP_FIELDS(
+ ctf_integer(int, retval, result)
+ )
+)
+/* vfs_lttng_get_real_filename END*/
+
+/* vfs_lttng_connectpath START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_connectpath_enter,
+ TP_ARGS(
+ const struct smb_filename *, smb_fname
+ ),
+ TP_FIELDS(
+ ctf_string(filename, smb_fname->base_name)
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_connectpath_exit,
+ TP_ARGS(
+ ),
+ TP_FIELDS(
+ )
+)
+/* vfs_lttng_connectpath END*/
+
+/* vfs_lttng_brl_lock_windows START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_brl_lock_windows_enter,
+ TP_ARGS(
+
+ ),
+ TP_FIELDS(
+
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_brl_lock_windows_exit,
+ TP_ARGS(
+ NTSTATUS, result
+ ),
+ TP_FIELDS(
+ ctf_integer(int, retval, result.v)
+ )
+)
+/* vfs_lttng_brl_lock_windows END*/
+
+/* vfs_lttng_brl_unlock_windows START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_brl_unlock_windows_enter,
+ TP_ARGS(
+
+ ),
+ TP_FIELDS(
+
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_brl_unlock_windows_exit,
+ TP_ARGS(
+ bool, result
+ ),
+ TP_FIELDS(
+ ctf_integer(bool, retval, result)
+ )
+)
+/* vfs_lttng_brl_unlock_windows END*/
+
+/* vfs_lttng_brl_cancel_windows START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_brl_cancel_windows_enter,
+ TP_ARGS(
+
+ ),
+ TP_FIELDS(
+
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_brl_cancel_windows_exit,
+ TP_ARGS(
+ bool, result
+ ),
+ TP_FIELDS(
+ ctf_integer(bool, retval, result)
+ )
+)
+/* vfs_lttng_brl_cancel_windows END*/
+
+/* vfs_lttng_strict_lock_check START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_strict_lock_check_enter,
+ TP_ARGS(
+ struct files_struct *, fsp
+ ),
+ TP_FIELDS(
+ ctf_string(filename, fsp->fsp_name->base_name)
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_strict_lock_check_exit,
+ TP_ARGS(
+ bool, result
+ ),
+ TP_FIELDS(
+ ctf_integer(bool, retval, result)
+ )
+)
+/* vfs_lttng_strict_lock_check END*/
+
+/* vfs_lttng_translate_name START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_translate_name_enter,
+ TP_ARGS(
+ const char *, name
+ ),
+ TP_FIELDS(
+ ctf_string(name, name)
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_translate_name_exit,
+ TP_ARGS(
+ NTSTATUS, result
+ ),
+ TP_FIELDS(
+ ctf_integer(int, retval, result.v)
+ )
+)
+/* vfs_lttng_translate_name END*/
+
+/* vfs_lttng_fsctl START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_fsctl_enter,
+ TP_ARGS(
+ struct files_struct *, fsp
+ ),
+ TP_FIELDS(
+ ctf_string(filename, fsp->fsp_name->base_name)
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_fsctl_exit,
+ TP_ARGS(
+ NTSTATUS, result
+ ),
+ TP_FIELDS(
+ ctf_integer(int, retval, result.v)
+ )
+)
+/* vfs_lttng_fsctl END*/
+
+/* vfs_lttng_get_dos_attributes START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_get_dos_attributes_enter,
+ TP_ARGS(
+ struct smb_filename *, smb_fname
+ ),
+ TP_FIELDS(
+ ctf_string(filename, smb_fname->base_name)
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_get_dos_attributes_exit,
+ TP_ARGS(
+ NTSTATUS, result
+ ),
+ TP_FIELDS(
+ ctf_integer(int, retval, result.v)
+ )
+)
+/* vfs_lttng_get_dos_attributes END*/
+
+/* vfs_lttng_fget_dos_attributes START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_fget_dos_attributes_enter,
+ TP_ARGS(
+ struct files_struct *, fsp
+ ),
+ TP_FIELDS(
+ ctf_string(filename, fsp->fsp_name->base_name)
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_fget_dos_attributes_exit,
+ TP_ARGS(
+ NTSTATUS, result
+ ),
+ TP_FIELDS(
+ ctf_integer(int, retval, result.v)
+ )
+)
+/* vfs_lttng_fget_dos_attributes END*/
+
+/* vfs_lttng_set_dos_attributes START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_set_dos_attributes_enter,
+ TP_ARGS(
+ const struct smb_filename *, smb_fname
+ ),
+ TP_FIELDS(
+ ctf_string(filename, smb_fname->base_name)
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_set_dos_attributes_exit,
+ TP_ARGS(
+ NTSTATUS, result
+ ),
+ TP_FIELDS(
+ ctf_integer(int, retval, result.v)
+ )
+)
+/* vfs_lttng_set_dos_attributes END*/
+
+/* vfs_lttng_fset_dos_attributes START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_fset_dos_attributes_enter,
+ TP_ARGS(
+ struct files_struct *, fsp
+ ),
+ TP_FIELDS(
+ ctf_string(filename, fsp->fsp_name->base_name)
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_fset_dos_attributes_exit,
+ TP_ARGS(
+ NTSTATUS, result
+ ),
+ TP_FIELDS(
+ ctf_integer(int, retval, result.v)
+ )
+)
+/* vfs_lttng_fset_dos_attributes END*/
+
+/* vfs_lttng_fget_nt_acl START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_fget_nt_acl_enter,
+ TP_ARGS(
+ files_struct *, fsp
+ ),
+ TP_FIELDS(
+ ctf_string(filename, fsp->fsp_name->base_name)
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_fget_nt_acl_exit,
+ TP_ARGS(
+ NTSTATUS, result
+ ),
+ TP_FIELDS(
+ ctf_integer(int, retval, result.v)
+ )
+)
+/* vfs_lttng_fget_nt_acl END*/
+
+/* vfs_lttng_get_nt_acl START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_get_nt_acl_enter,
+ TP_ARGS(
+ const struct smb_filename *, smb_fname
+ ),
+ TP_FIELDS(
+ ctf_string(filename, smb_fname->base_name)
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_get_nt_acl_exit,
+ TP_ARGS(
+ NTSTATUS, result
+ ),
+ TP_FIELDS(
+ ctf_integer(int, retval, result.v)
+ )
+)
+/* vfs_lttng_get_nt_acl END*/
+
+/* vfs_lttng_fset_nt_acl START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_fset_nt_acl_enter,
+ TP_ARGS(
+ files_struct *, fsp
+ ),
+ TP_FIELDS(
+ ctf_string(filename, fsp->fsp_name->base_name)
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_fset_nt_acl_exit,
+ TP_ARGS(
+ NTSTATUS, result
+ ),
+ TP_FIELDS(
+ ctf_integer(int, retval, result.v)
+ )
+)
+/* vfs_lttng_fset_nt_acl END*/
+
+/* vfs_lttng_audit_file START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_audit_file_enter,
+ TP_ARGS(
+ struct smb_filename *, smb_fname
+ ),
+ TP_FIELDS(
+ ctf_string(filename, smb_fname->base_name)
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_audit_file_exit,
+ TP_ARGS(
+ NTSTATUS, result
+ ),
+ TP_FIELDS(
+ ctf_integer(int, retval, result.v)
+ )
+)
+/* vfs_lttng_audit_file END*/
+
+/* vfs_lttng_sys_acl_get_file START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_sys_acl_get_file_enter,
+ TP_ARGS(
+ const struct smb_filename *, smb_fname
+ ),
+ TP_FIELDS(
+ ctf_string(filename, smb_fname->base_name)
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_sys_acl_get_file_exit,
+ TP_ARGS(
+ SMB_ACL_T, result
+ ),
+ TP_FIELDS(
+ ctf_integer(SMB_ACL_T, retval, result)
+ )
+)
+/* vfs_lttng_sys_acl_get_file END*/
+
+/* vfs_lttng_sys_acl_get_fd START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_sys_acl_get_fd_enter,
+ TP_ARGS(
+ files_struct *, fsp
+ ),
+ TP_FIELDS(
+ ctf_string(filename, fsp->fsp_name->base_name)
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_sys_acl_get_fd_exit,
+ TP_ARGS(
+ SMB_ACL_T, result
+ ),
+ TP_FIELDS(
+ ctf_integer(SMB_ACL_T, retval, result)
+ )
+)
+/* vfs_lttng_sys_acl_get_fd END*/
+
+/* vfs_lttng_sys_acl_blob_get_file START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_sys_acl_blob_get_file_enter,
+ TP_ARGS(
+ const struct smb_filename *, smb_fname
+ ),
+ TP_FIELDS(
+ ctf_string(filename, smb_fname->base_name)
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_sys_acl_blob_get_file_exit,
+ TP_ARGS(
+ int, result
+ ),
+ TP_FIELDS(
+ ctf_integer(int, retval, result)
+ )
+)
+/* vfs_lttng_sys_acl_blob_get_file END*/
+
+/* vfs_lttng_sys_acl_blob_get_fd START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_sys_acl_blob_get_fd_enter,
+ TP_ARGS(
+ files_struct *, fsp
+ ),
+ TP_FIELDS(
+ ctf_string(filename, fsp->fsp_name->base_name)
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_sys_acl_blob_get_fd_exit,
+ TP_ARGS(
+ int, result
+ ),
+ TP_FIELDS(
+ ctf_integer(int, retval, result)
+ )
+)
+/* vfs_lttng_sys_acl_blob_get_fd END*/
+
+/* vfs_lttng_sys_acl_set_file START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_sys_acl_set_file_enter,
+ TP_ARGS(
+ const struct smb_filename *, smb_fname
+ ),
+ TP_FIELDS(
+ ctf_string(filename, smb_fname->base_name)
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_sys_acl_set_file_exit,
+ TP_ARGS(
+ int, result
+ ),
+ TP_FIELDS(
+ ctf_integer(int, retval, result)
+ )
+)
+/* vfs_lttng_sys_acl_set_file END*/
+
+/* vfs_lttng_sys_acl_set_fd START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_sys_acl_set_fd_enter,
+ TP_ARGS(
+ files_struct *, fsp
+ ),
+ TP_FIELDS(
+ ctf_string(filename, fsp->fsp_name->base_name)
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_sys_acl_set_fd_exit,
+ TP_ARGS(
+ int, result
+ ),
+ TP_FIELDS(
+ ctf_integer(int, retval, result)
+ )
+)
+/* vfs_lttng_sys_acl_set_fd END*/
+
+/* vfs_lttng_sys_acl_delete_def_file START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_sys_acl_delete_def_file_enter,
+ TP_ARGS(
+ const struct smb_filename *, smb_fname
+ ),
+ TP_FIELDS(
+ ctf_string(filename, smb_fname->base_name)
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_sys_acl_delete_def_file_exit,
+ TP_ARGS(
+ int, result
+ ),
+ TP_FIELDS(
+ ctf_integer(int, retval, result)
+ )
+)
+/* vfs_lttng_sys_acl_delete_def_file END*/
+
+/* vfs_lttng_getxattr START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_getxattr_enter,
+ TP_ARGS(
+ const struct smb_filename *, smb_fname,
+ const char *, name
+ ),
+ TP_FIELDS(
+ ctf_string(filename, smb_fname->base_name)
+ ctf_string(name, name)
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_getxattr_exit,
+ TP_ARGS(
+ ssize_t, result
+ ),
+ TP_FIELDS(
+ ctf_integer(ssize_t, retval, result)
+ )
+)
+/* vfs_lttng_getxattr END*/
+
+/* vfs_lttng_fgetxattr START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_fgetxattr_enter,
+ TP_ARGS(
+ struct files_struct *, fsp,
+ const char *, name
+ ),
+ TP_FIELDS(
+ ctf_string(filename, fsp->fsp_name->base_name)
+ ctf_string(name, name)
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_fgetxattr_exit,
+ TP_ARGS(
+ ssize_t, result
+ ),
+ TP_FIELDS(
+ ctf_integer(ssize_t, retval, result)
+ )
+)
+/* vfs_lttng_fgetxattr END*/
+
+/* vfs_lttng_listxattr START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_listxattr_enter,
+ TP_ARGS(
+ const struct smb_filename *, smb_fname
+ ),
+ TP_FIELDS(
+ ctf_string(filename, smb_fname->base_name)
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_listxattr_exit,
+ TP_ARGS(
+ ssize_t, result
+ ),
+ TP_FIELDS(
+ ctf_integer(ssize_t, retval, result)
+ )
+)
+/* vfs_lttng_listxattr END*/
+
+/* vfs_lttng_flistxattr START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_flistxattr_enter,
+ TP_ARGS(
+ struct files_struct *, fsp
+ ),
+ TP_FIELDS(
+ ctf_string(filename, fsp->fsp_name->base_name)
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_flistxattr_exit,
+ TP_ARGS(
+ ssize_t, result
+ ),
+ TP_FIELDS(
+ ctf_integer(ssize_t, retval, result)
+ )
+)
+/* vfs_lttng_flistxattr END*/
+
+/* vfs_lttng_removexattr START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_removexattr_enter,
+ TP_ARGS(
+ const struct smb_filename *, smb_fname,
+ const char *, name
+ ),
+ TP_FIELDS(
+ ctf_string(filename, smb_fname->base_name)
+ ctf_string(name, name)
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_removexattr_exit,
+ TP_ARGS(
+ int, result
+ ),
+ TP_FIELDS(
+ ctf_integer(int, retval, result)
+ )
+)
+/* vfs_lttng_removexattr END*/
+
+/* vfs_lttng_fremovexattr START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_fremovexattr_enter,
+ TP_ARGS(
+ struct files_struct *, fsp,
+ const char *, name
+ ),
+ TP_FIELDS(
+ ctf_string(filename, fsp->fsp_name->base_name)
+ ctf_string(name, name)
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_fremovexattr_exit,
+ TP_ARGS(
+ int, result
+ ),
+ TP_FIELDS(
+ ctf_integer(int, retval, result)
+ )
+)
+/* vfs_lttng_fremovexattr END*/
+
+/* vfs_lttng_setxattr START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_setxattr_enter,
+ TP_ARGS(
+ const struct smb_filename *, smb_fname,
+ const char *, name,
+ int, flags
+ ),
+ TP_FIELDS(
+ ctf_string(filename, smb_fname->base_name)
+ ctf_string(name, name)
+ ctf_integer(int, flags, flags)
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_setxattr_exit,
+ TP_ARGS(
+ int, result
+ ),
+ TP_FIELDS(
+ ctf_integer(int, retval, result)
+ )
+)
+/* vfs_lttng_setxattr END*/
+
+/* vfs_lttng_fsetxattr START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_fsetxattr_enter,
+ TP_ARGS(
+ struct files_struct *, fsp,
+ const char *, name,
+ int, flags
+ ),
+ TP_FIELDS(
+ ctf_string(filename, fsp->fsp_name->base_name)
+ ctf_string(name, name)
+ ctf_integer(int, flags, flags)
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_fsetxattr_exit,
+ TP_ARGS(
+ int, result
+ ),
+ TP_FIELDS(
+ ctf_integer(int, retval, result)
+ )
+)
+/* vfs_lttng_fsetxattr END*/
+
+/* vfs_lttng_aio_force START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_aio_force_enter,
+ TP_ARGS(
+ struct files_struct *, fsp
+ ),
+ TP_FIELDS(
+ ctf_string(filename, fsp->fsp_name->base_name)
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_aio_force_exit,
+ TP_ARGS(
+ bool, result
+ ),
+ TP_FIELDS(
+ ctf_integer(bool, retval, result)
+ )
+)
+/* vfs_lttng_aio_force END*/
+
+/* vfs_lttng_durable_cookie START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_durable_cookie_enter,
+ TP_ARGS(
+ struct files_struct *, fsp
+ ),
+ TP_FIELDS(
+ ctf_string(filename, fsp->fsp_name->base_name)
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_durable_cookie_exit,
+ TP_ARGS(
+ NTSTATUS, result
+ ),
+ TP_FIELDS(
+ ctf_integer(int, retval, result.v)
+ )
+)
+/* vfs_lttng_durable_cookie END*/
+
+/* vfs_lttng_durable_disconnect START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_durable_disconnect_enter,
+ TP_ARGS(
+ struct files_struct *, fsp
+ ),
+ TP_FIELDS(
+ ctf_string(filename, fsp->fsp_name->base_name)
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_durable_disconnect_exit,
+ TP_ARGS(
+ NTSTATUS, result
+ ),
+ TP_FIELDS(
+ ctf_integer(int, retval, result.v)
+ )
+)
+/* vfs_lttng_durable_disconnect END*/
+
+/* vfs_lttng_durable_reconnect START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_durable_reconnect_enter,
+ TP_ARGS(
+ struct files_struct * *, fsp
+ ),
+ TP_FIELDS(
+ ctf_string(filename, (*fsp)->fsp_name->base_name)
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_durable_reconnect_exit,
+ TP_ARGS(
+ NTSTATUS, result
+ ),
+ TP_FIELDS(
+ ctf_integer(int, retval, result.v)
+ )
+)
+/* vfs_lttng_durable_reconnect END*/
+
+/* vfs_lttng_readdir_attr START*/
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_readdir_attr_enter,
+ TP_ARGS(
+ const struct smb_filename *, fname
+ ),
+ TP_FIELDS(
+ ctf_string(filename, fname->base_name)
+ )
+)
+TRACEPOINT_EVENT(
+ vfs_lttng,
+ vfs_lttng_readdir_attr_exit,
+ TP_ARGS(
+ NTSTATUS, result
+ ),
+ TP_FIELDS(
+ ctf_integer(int, retval, result.v)
+ )
+)
+/* vfs_lttng_readdir_attr END*/
+
+#endif /* VFS_LTTNG_TP_H */
+#include <lttng/tracepoint-event.h>
+
diff --git a/source3/modules/wscript_build b/source3/modules/wscript_build
index 30347e0fc6d..ebe0da2430f 100644
--- a/source3/modules/wscript_build
+++ b/source3/modules/wscript_build
@@ -595,3 +595,12 @@ bld.SAMBA3_MODULE('vfs_delay_inject',
init_function='',
internal_module=bld.SAMBA3_IS_STATIC_MODULE('vfs_delay_inject'),
enabled=bld.SAMBA3_IS_ENABLED_MODULE('vfs_delay_inject'))
+
+bld.SAMBA3_MODULE('vfs_lttng',
+ subsystem='vfs',
+ source='vfs_lttng.c',
+ deps='lttng-ust',
+ init_function='',
+ internal_module=bld.SAMBA3_IS_STATIC_MODULE('vfs_lttng'),
+ enabled=bld.SAMBA3_IS_ENABLED_MODULE('vfs_lttng'))
+
diff --git a/source3/wscript b/source3/wscript
index e2d38ac211f..03cb0654739 100644
--- a/source3/wscript
+++ b/source3/wscript
@@ -1764,6 +1764,9 @@ main() {
if conf.CONFIG_SET('HAVE_DBUS'):
default_shared_modules.extend(TO_LIST('vfs_snapper'))
+ if conf.CONFIG_SET('HAVE_LTTNG_TRACEF'):
+ default_shared_modules.extend(TO_LIST('vfs_lttng'))
+
explicit_shared_modules = TO_LIST(Options.options.shared_modules, delimiter=',')
explicit_static_modules = TO_LIST(Options.options.static_modules, delimiter=',')
--
2.17.2
From 1444ef7f2ea2ae5e6ec34ab57dcb555acb49cbe5 Mon Sep 17 00:00:00 2001
From: Ralph Boehme <slow at samba.org>
Date: Mon, 18 Mar 2019 22:53:23 +0100
Subject: [PATCH 2/3] FIXUP: README.Coding cleanups, overall formatting cleanup
to better match Samba style
---
source3/modules/vfs_lttng.c | 1335 +++++++++++++++++++----------------
1 file changed, 739 insertions(+), 596 deletions(-)
diff --git a/source3/modules/vfs_lttng.c b/source3/modules/vfs_lttng.c
index 829bf664bad..1a852bca7ef 100644
--- a/source3/modules/vfs_lttng.c
+++ b/source3/modules/vfs_lttng.c
@@ -1,6 +1,6 @@
/*
- * Lttng VFS module for samba. Trace VFS functions using lttng userspace
+ Lttng VFS module for samba. Trace VFS functions using lttng userspace
tools
Copyright (C) Dongmao Zhang <deanraccoon at gmail.com>
@@ -25,9 +25,10 @@
* /etc/samba/smb.conf
*
* vfs objects = lttng
- *
+ *
* RUN smbd such as this:
- * LD_PRELOAD=/usr/lib64/liblttng-ust-fork.so.0 /usr/sbin/smbd --foreground --no-process-group
+ * # LD_PRELOAD=/usr/lib64/liblttng-ust-fork.so.0 \
+ * /usr/sbin/smbd --foreground --no-process-group
*
* lttng create
* lttng enable-event -u vfs_lttng:*
@@ -39,7 +40,6 @@
* lttng destroy
*
* Use babeltrace or some other tools(https://lttng.org) to checkout the result
- *
*/
#define TRACEPOINT_CREATE_PROBES
@@ -48,707 +48,740 @@
*/
#define TRACEPOINT_DEFINE
-
#include "includes.h"
#include "smbd/smbd.h"
#include "ntioctl.h"
#include "lib/util/tevent_unix.h"
#include "lib/util/tevent_ntstatus.h"
-
#include "vfs_lttng_tp.h"
-
-
static int vfs_lttng_connect(vfs_handle_struct *handle,
- const char *svc, const char *user)
-
+ const char *svc, const char *user)
{
int result;
- tracepoint(vfs_lttng, vfs_lttng_connect_enter );
+
+ tracepoint(vfs_lttng, vfs_lttng_connect_enter);
result = SMB_VFS_NEXT_CONNECT(handle, svc, user);
tracepoint(vfs_lttng, vfs_lttng_connect_exit, result);
+
return result;
}
-
static void vfs_lttng_disconnect(vfs_handle_struct *handle)
-
{
- tracepoint(vfs_lttng, vfs_lttng_disconnect_enter );
+ tracepoint(vfs_lttng, vfs_lttng_disconnect_enter);
SMB_VFS_NEXT_DISCONNECT(handle);
tracepoint(vfs_lttng, vfs_lttng_disconnect_exit);
}
-
static uint64_t vfs_lttng_disk_free(vfs_handle_struct *handle,
- const struct smb_filename *smb_fname,
- uint64_t *bsize,
- uint64_t *dfree,
- uint64_t *dsize)
-
+ const struct smb_filename *smb_fname,
+ uint64_t *bsize,
+ uint64_t *dfree,
+ uint64_t *dsize)
{
uint64_t result;
- tracepoint(vfs_lttng, vfs_lttng_disk_free_enter , smb_fname);
+
+ tracepoint(vfs_lttng, vfs_lttng_disk_free_enter, smb_fname);
result = SMB_VFS_NEXT_DISK_FREE(handle, smb_fname, bsize, dfree, dsize);
tracepoint(vfs_lttng, vfs_lttng_disk_free_exit, result);
+
return result;
}
-
static int vfs_lttng_get_quota(struct vfs_handle_struct *handle,
- const struct smb_filename *smb_fname,
- enum SMB_QUOTA_TYPE qtype,
- unid_t id,
- SMB_DISK_QUOTA *qt)
-
+ const struct smb_filename *smb_fname,
+ enum SMB_QUOTA_TYPE qtype,
+ unid_t id,
+ SMB_DISK_QUOTA *qt)
{
int result;
- tracepoint(vfs_lttng, vfs_lttng_get_quota_enter , smb_fname);
+
+ tracepoint(vfs_lttng, vfs_lttng_get_quota_enter, smb_fname);
result = SMB_VFS_NEXT_GET_QUOTA(handle, smb_fname, qtype, id, qt);
tracepoint(vfs_lttng, vfs_lttng_get_quota_exit, result);
+
return result;
}
-
static int vfs_lttng_set_quota(struct vfs_handle_struct *handle,
- enum SMB_QUOTA_TYPE qtype, unid_t id,
- SMB_DISK_QUOTA *qt)
-
+ enum SMB_QUOTA_TYPE qtype, unid_t id,
+ SMB_DISK_QUOTA *qt)
{
int result;
- tracepoint(vfs_lttng, vfs_lttng_set_quota_enter );
+
+ tracepoint(vfs_lttng, vfs_lttng_set_quota_enter);
result = SMB_VFS_NEXT_SET_QUOTA(handle, qtype, id, qt);
tracepoint(vfs_lttng, vfs_lttng_set_quota_exit, result);
+
return result;
}
-
-static int vfs_lttng_get_shadow_copy_data(struct vfs_handle_struct *handle,
- struct files_struct *fsp,
- struct shadow_copy_data *shadow_copy_data,
- bool labels)
-
+static int vfs_lttng_get_shadow_copy_data(
+ struct vfs_handle_struct *handle,
+ struct files_struct *fsp,
+ struct shadow_copy_data *shadow_copy_data,
+ bool labels)
{
int result;
- tracepoint(vfs_lttng, vfs_lttng_get_shadow_copy_data_enter , fsp);
- result = SMB_VFS_NEXT_GET_SHADOW_COPY_DATA(handle, fsp, shadow_copy_data, labels);
+
+ tracepoint(vfs_lttng, vfs_lttng_get_shadow_copy_data_enter, fsp);
+ result = SMB_VFS_NEXT_GET_SHADOW_COPY_DATA(handle,
+ fsp,
+ shadow_copy_data,
+ labels);
tracepoint(vfs_lttng, vfs_lttng_get_shadow_copy_data_exit, result);
+
return result;
}
-
static int vfs_lttng_statvfs(struct vfs_handle_struct *handle,
- const struct smb_filename *smb_fname,
- struct vfs_statvfs_struct *statbuf)
-
+ const struct smb_filename *smb_fname,
+ struct vfs_statvfs_struct *statbuf)
{
int result;
- tracepoint(vfs_lttng, vfs_lttng_statvfs_enter , smb_fname);
+
+ tracepoint(vfs_lttng, vfs_lttng_statvfs_enter, smb_fname);
result = SMB_VFS_NEXT_STATVFS(handle, smb_fname, statbuf);
tracepoint(vfs_lttng, vfs_lttng_statvfs_exit, result);
+
return result;
}
-
-static uint32_t vfs_lttng_fs_capabilities(struct vfs_handle_struct *handle,
- enum timestamp_set_resolution *p_ts_res)
-
+static uint32_t vfs_lttng_fs_capabilities(
+ struct vfs_handle_struct *handle,
+ enum timestamp_set_resolution *p_ts_res)
{
uint32_t result;
- tracepoint(vfs_lttng, vfs_lttng_fs_capabilities_enter );
+
+ tracepoint(vfs_lttng, vfs_lttng_fs_capabilities_enter);
result = SMB_VFS_NEXT_FS_CAPABILITIES(handle, p_ts_res);
tracepoint(vfs_lttng, vfs_lttng_fs_capabilities_exit, result);
+
return result;
}
-
static NTSTATUS vfs_lttng_get_dfs_referrals(
struct vfs_handle_struct *handle,
struct dfs_GetDFSReferral *r)
-
{
NTSTATUS result;
- tracepoint(vfs_lttng, vfs_lttng_get_dfs_referrals_enter );
+
+ tracepoint(vfs_lttng, vfs_lttng_get_dfs_referrals_enter);
result = SMB_VFS_NEXT_GET_DFS_REFERRALS(handle, r);
tracepoint(vfs_lttng, vfs_lttng_get_dfs_referrals_exit, result);
+
return result;
}
-
static DIR *vfs_lttng_opendir(vfs_handle_struct *handle,
- const struct smb_filename *smb_fname,
- const char *mask, uint32_t attr)
-
+ const struct smb_filename *smb_fname,
+ const char *mask,
+ uint32_t attr)
{
- DIR * result;
- tracepoint(vfs_lttng, vfs_lttng_opendir_enter , smb_fname);
+ DIR *result = NULL;
+
+ tracepoint(vfs_lttng, vfs_lttng_opendir_enter, smb_fname);
result = SMB_VFS_NEXT_OPENDIR(handle, smb_fname, mask, attr);
tracepoint(vfs_lttng, vfs_lttng_opendir_exit);
+
return result;
}
-
static DIR *vfs_lttng_fdopendir(vfs_handle_struct *handle,
- files_struct *fsp,
- const char *mask, uint32_t attr)
-
+ files_struct *fsp,
+ const char *mask,
+ uint32_t attr)
{
- DIR * result;
- tracepoint(vfs_lttng, vfs_lttng_fdopendir_enter , fsp);
+ DIR *result = NULL;
+
+ tracepoint(vfs_lttng, vfs_lttng_fdopendir_enter, fsp);
result = SMB_VFS_NEXT_FDOPENDIR(handle, fsp, mask, attr);
tracepoint(vfs_lttng, vfs_lttng_fdopendir_exit);
+
return result;
}
-
static struct dirent *vfs_lttng_readdir(vfs_handle_struct *handle,
- DIR *dirp,
- SMB_STRUCT_STAT *sbuf)
-
+ DIR *dirp,
+ SMB_STRUCT_STAT *sbuf)
{
- struct dirent * result;
- tracepoint(vfs_lttng, vfs_lttng_readdir_enter );
+ struct dirent *result = NULL;
+
+ tracepoint(vfs_lttng, vfs_lttng_readdir_enter);
result = SMB_VFS_NEXT_READDIR(handle, dirp, sbuf);
tracepoint(vfs_lttng, vfs_lttng_readdir_exit);
+
return result;
}
-
static void vfs_lttng_seekdir(vfs_handle_struct *handle,
- DIR *dirp, long offset)
-
+ DIR *dirp,
+ long offset)
{
- tracepoint(vfs_lttng, vfs_lttng_seekdir_enter , offset);
+ tracepoint(vfs_lttng, vfs_lttng_seekdir_enter, offset);
SMB_VFS_NEXT_SEEKDIR(handle, dirp, offset);
tracepoint(vfs_lttng, vfs_lttng_seekdir_exit);
}
-
static long vfs_lttng_telldir(vfs_handle_struct *handle,
- DIR *dirp)
-
+ DIR *dirp)
{
long result;
- tracepoint(vfs_lttng, vfs_lttng_telldir_enter );
+
+ tracepoint(vfs_lttng, vfs_lttng_telldir_enter);
result = SMB_VFS_NEXT_TELLDIR(handle, dirp);
tracepoint(vfs_lttng, vfs_lttng_telldir_exit, result);
+
return result;
}
-
static int vfs_lttng_mkdir(vfs_handle_struct *handle,
- const struct smb_filename *smb_fname,
- mode_t mode)
-
+ const struct smb_filename *smb_fname,
+ mode_t mode)
{
int result;
- tracepoint(vfs_lttng, vfs_lttng_mkdir_enter , smb_fname, mode);
+
+ tracepoint(vfs_lttng, vfs_lttng_mkdir_enter, smb_fname, mode);
result = SMB_VFS_NEXT_MKDIR(handle, smb_fname, mode);
tracepoint(vfs_lttng, vfs_lttng_mkdir_exit, result);
+
return result;
}
-
static int vfs_lttng_rmdir(vfs_handle_struct *handle,
- const struct smb_filename *smb_fname)
-
+ const struct smb_filename *smb_fname)
{
int result;
- tracepoint(vfs_lttng, vfs_lttng_rmdir_enter , smb_fname);
+
+ tracepoint(vfs_lttng, vfs_lttng_rmdir_enter, smb_fname);
result = SMB_VFS_NEXT_RMDIR(handle, smb_fname);
tracepoint(vfs_lttng, vfs_lttng_rmdir_exit, result);
+
return result;
}
-
static int vfs_lttng_closedir(vfs_handle_struct *handle,
- DIR *dirp)
-
+ DIR *dirp)
{
int result;
- tracepoint(vfs_lttng, vfs_lttng_closedir_enter );
+
+ tracepoint(vfs_lttng, vfs_lttng_closedir_enter);
result = SMB_VFS_NEXT_CLOSEDIR(handle, dirp);
tracepoint(vfs_lttng, vfs_lttng_closedir_exit, result);
+
return result;
}
-
-
static int vfs_lttng_open(vfs_handle_struct *handle,
- struct smb_filename *fname,
- files_struct *fsp,
- int flags, mode_t mode)
-
+ struct smb_filename *fname,
+ files_struct *fsp,
+ int flags, mode_t mode)
{
int result;
- tracepoint(vfs_lttng, vfs_lttng_open_enter , fname, flags, mode);
+
+ tracepoint(vfs_lttng, vfs_lttng_open_enter, fname, flags, mode);
result = SMB_VFS_NEXT_OPEN(handle, fname, fsp, flags, mode);
tracepoint(vfs_lttng, vfs_lttng_open_exit, result);
+
return result;
}
-
-static NTSTATUS vfs_lttng_create_file(vfs_handle_struct *handle,
- struct smb_request *req,
- uint16_t root_dir_fid,
- struct smb_filename *fname,
- uint32_t access_mask,
- uint32_t share_access,
- uint32_t create_disposition,
- uint32_t create_options,
- uint32_t file_attributes,
- uint32_t oplock_request,
- struct smb2_lease *lease,
- uint64_t allocation_size,
- uint32_t private_flags,
- struct security_descriptor *sd,
- struct ea_list *ea_list,
- files_struct **result_fsp,
- int *pinfo,
- const struct smb2_create_blobs *in_context_blobs,
- struct smb2_create_blobs *out_context_blobs)
-
+static NTSTATUS vfs_lttng_create_file(
+ vfs_handle_struct *handle,
+ struct smb_request *req,
+ uint16_t root_dir_fid,
+ struct smb_filename *fname,
+ uint32_t access_mask,
+ uint32_t share_access,
+ uint32_t create_disposition,
+ uint32_t create_options,
+ uint32_t file_attributes,
+ uint32_t oplock_request,
+ struct smb2_lease *lease,
+ uint64_t allocation_size,
+ uint32_t private_flags,
+ struct security_descriptor *sd,
+ struct ea_list *ea_list,
+ files_struct **result_fsp,
+ int *pinfo,
+ const struct smb2_create_blobs *in_context_blobs,
+ struct smb2_create_blobs *out_context_blobs)
{
NTSTATUS result;
- tracepoint(vfs_lttng, vfs_lttng_create_file_enter , fname);
- result = SMB_VFS_NEXT_CREATE_FILE(handle, req, root_dir_fid, fname, access_mask, share_access, create_disposition, create_options, file_attributes, oplock_request, lease, allocation_size, private_flags, sd, ea_list, result_fsp, pinfo, in_context_blobs, out_context_blobs);
+
+ tracepoint(vfs_lttng, vfs_lttng_create_file_enter, fname);
+ result = SMB_VFS_NEXT_CREATE_FILE(handle,
+ req,
+ root_dir_fid,
+ fname,
+ access_mask,
+ share_access,
+ create_disposition,
+ create_options,
+ file_attributes,
+ oplock_request,
+ lease,
+ allocation_size,
+ private_flags,
+ sd,
+ ea_list,
+ result_fsp,
+ pinfo,
+ in_context_blobs,
+ out_context_blobs);
tracepoint(vfs_lttng, vfs_lttng_create_file_exit, result);
+
return result;
}
static int vfs_lttng_close(vfs_handle_struct *handle, files_struct *fsp)
-
{
int result;
- tracepoint(vfs_lttng, vfs_lttng_close_enter , fsp);
+
+ tracepoint(vfs_lttng, vfs_lttng_close_enter, fsp);
result = SMB_VFS_NEXT_CLOSE(handle, fsp);
tracepoint(vfs_lttng, vfs_lttng_close_exit, result);
+
return result;
}
-
-
-
static ssize_t vfs_lttng_pread(vfs_handle_struct *handle,
- files_struct *fsp,
- void *data, size_t n, off_t offset)
-
+ files_struct *fsp,
+ void *data,
+ size_t n,
+ off_t offset)
{
ssize_t result;
- tracepoint(vfs_lttng, vfs_lttng_pread_enter , fsp, n, offset);
+
+ tracepoint(vfs_lttng, vfs_lttng_pread_enter, fsp, n, offset);
result = SMB_VFS_NEXT_PREAD(handle, fsp, data, n, offset);
tracepoint(vfs_lttng, vfs_lttng_pread_exit, result);
+
return result;
}
-
static ssize_t vfs_lttng_pwrite(vfs_handle_struct *handle,
- files_struct *fsp,
- const void *data, size_t n,
- off_t offset)
-
+ files_struct *fsp,
+ const void *data,
+ size_t n,
+ off_t offset)
{
ssize_t result;
- tracepoint(vfs_lttng, vfs_lttng_pwrite_enter , fsp, n, offset);
+
+ tracepoint(vfs_lttng, vfs_lttng_pwrite_enter, fsp, n, offset);
result = SMB_VFS_NEXT_PWRITE(handle, fsp, data, n, offset);
tracepoint(vfs_lttng, vfs_lttng_pwrite_exit, result);
+
return result;
}
-
static off_t vfs_lttng_lseek(vfs_handle_struct *handle,
- files_struct *fsp,
- off_t offset, int whence)
-
+ files_struct *fsp,
+ off_t offset,
+ int whence)
{
off_t result;
- tracepoint(vfs_lttng, vfs_lttng_lseek_enter , fsp, offset);
+
+ tracepoint(vfs_lttng, vfs_lttng_lseek_enter, fsp, offset);
result = SMB_VFS_NEXT_LSEEK(handle, fsp, offset, whence);
tracepoint(vfs_lttng, vfs_lttng_lseek_exit, result);
+
return result;
}
-
-static ssize_t vfs_lttng_sendfile(vfs_handle_struct *handle, int tofd,
- files_struct *fromfsp,
- const DATA_BLOB *hdr, off_t offset,
- size_t n)
-
+static ssize_t vfs_lttng_sendfile(vfs_handle_struct *handle,
+ int tofd,
+ files_struct *fromfsp,
+ const DATA_BLOB *hdr,
+ off_t offset,
+ size_t n)
{
ssize_t result;
- tracepoint(vfs_lttng, vfs_lttng_sendfile_enter , tofd, offset, n);
+
+ tracepoint(vfs_lttng, vfs_lttng_sendfile_enter, tofd, offset, n);
result = SMB_VFS_NEXT_SENDFILE(handle, tofd, fromfsp, hdr, offset, n);
tracepoint(vfs_lttng, vfs_lttng_sendfile_exit, result);
+
return result;
}
-
-static ssize_t vfs_lttng_recvfile(vfs_handle_struct *handle, int fromfd,
- files_struct *tofsp,
- off_t offset,
- size_t n)
-
+static ssize_t vfs_lttng_recvfile(vfs_handle_struct *handle,
+ int fromfd,
+ files_struct *tofsp,
+ off_t offset,
+ size_t n)
{
ssize_t result;
+
tracepoint(vfs_lttng, vfs_lttng_recvfile_enter , offset, n);
result = SMB_VFS_NEXT_RECVFILE(handle, fromfd, tofsp, offset, n);
tracepoint(vfs_lttng, vfs_lttng_recvfile_exit, result);
+
return result;
}
-
static int vfs_lttng_rename(vfs_handle_struct *handle,
- const struct smb_filename *oldname,
- const struct smb_filename *newname)
-
+ const struct smb_filename *oldname,
+ const struct smb_filename *newname)
{
int result;
- tracepoint(vfs_lttng, vfs_lttng_rename_enter );
+
+ tracepoint(vfs_lttng, vfs_lttng_rename_enter);
result = SMB_VFS_NEXT_RENAME(handle, oldname, newname);
tracepoint(vfs_lttng, vfs_lttng_rename_exit, result);
+
return result;
}
-
-
-
static int vfs_lttng_stat(vfs_handle_struct *handle,
- struct smb_filename *fname)
-
+ struct smb_filename *fname)
{
int result;
- tracepoint(vfs_lttng, vfs_lttng_stat_enter , fname);
+
+ tracepoint(vfs_lttng, vfs_lttng_stat_enter, fname);
result = SMB_VFS_NEXT_STAT(handle, fname);
tracepoint(vfs_lttng, vfs_lttng_stat_exit, result);
+
return result;
}
-static int vfs_lttng_fstat(vfs_handle_struct *handle, files_struct *fsp,
- SMB_STRUCT_STAT *sbuf)
-
+static int vfs_lttng_fstat(vfs_handle_struct *handle,
+ files_struct *fsp,
+ SMB_STRUCT_STAT *sbuf)
{
int result;
- tracepoint(vfs_lttng, vfs_lttng_fstat_enter , fsp);
+
+ tracepoint(vfs_lttng, vfs_lttng_fstat_enter, fsp);
result = SMB_VFS_NEXT_FSTAT(handle, fsp, sbuf);
tracepoint(vfs_lttng, vfs_lttng_fstat_exit, result);
+
return result;
}
-
static int vfs_lttng_lstat(vfs_handle_struct *handle,
- struct smb_filename *path)
-
+ struct smb_filename *path)
{
int result;
- tracepoint(vfs_lttng, vfs_lttng_lstat_enter );
+
+ tracepoint(vfs_lttng, vfs_lttng_lstat_enter);
result = SMB_VFS_NEXT_LSTAT(handle, path);
tracepoint(vfs_lttng, vfs_lttng_lstat_exit, result);
+
return result;
}
-
static uint64_t vfs_lttng_get_alloc_size(vfs_handle_struct *handle,
- files_struct *fsp,
- const SMB_STRUCT_STAT *sbuf)
-
+ files_struct *fsp,
+ const SMB_STRUCT_STAT *sbuf)
{
uint64_t result;
+
tracepoint(vfs_lttng, vfs_lttng_get_alloc_size_enter);
result = SMB_VFS_NEXT_GET_ALLOC_SIZE(handle, fsp, sbuf);
tracepoint(vfs_lttng, vfs_lttng_get_alloc_size_exit, result);
+
return result;
}
-
static int vfs_lttng_unlink(vfs_handle_struct *handle,
- const struct smb_filename *path)
-
+ const struct smb_filename *path)
{
int result;
- tracepoint(vfs_lttng, vfs_lttng_unlink_enter );
+
+ tracepoint(vfs_lttng, vfs_lttng_unlink_enter);
result = SMB_VFS_NEXT_UNLINK(handle, path);
tracepoint(vfs_lttng, vfs_lttng_unlink_exit, result);
+
return result;
}
-
static int vfs_lttng_chmod(vfs_handle_struct *handle,
- const struct smb_filename *smb_fname,
- mode_t mode)
-
+ const struct smb_filename *smb_fname,
+ mode_t mode)
{
int result;
- tracepoint(vfs_lttng, vfs_lttng_chmod_enter , smb_fname, mode);
+
+ tracepoint(vfs_lttng, vfs_lttng_chmod_enter, smb_fname, mode);
result = SMB_VFS_NEXT_CHMOD(handle, smb_fname, mode);
tracepoint(vfs_lttng, vfs_lttng_chmod_exit, result);
+
return result;
}
-
-static int vfs_lttng_fchmod(vfs_handle_struct *handle, files_struct *fsp,
- mode_t mode)
-
+static int vfs_lttng_fchmod(vfs_handle_struct *handle,
+ files_struct *fsp,
+ mode_t mode)
{
int result;
- tracepoint(vfs_lttng, vfs_lttng_fchmod_enter , fsp, mode);
+
+ tracepoint(vfs_lttng, vfs_lttng_fchmod_enter, fsp, mode);
result = SMB_VFS_NEXT_FCHMOD(handle, fsp, mode);
tracepoint(vfs_lttng, vfs_lttng_fchmod_exit, result);
+
return result;
}
-
static int vfs_lttng_chown(vfs_handle_struct *handle,
- const struct smb_filename *smb_fname,
- uid_t uid,
- gid_t gid)
-
+ const struct smb_filename *smb_fname,
+ uid_t uid,
+ gid_t gid)
{
int result;
- tracepoint(vfs_lttng, vfs_lttng_chown_enter , smb_fname);
+
+ tracepoint(vfs_lttng, vfs_lttng_chown_enter, smb_fname);
result = SMB_VFS_NEXT_CHOWN(handle, smb_fname, uid, gid);
tracepoint(vfs_lttng, vfs_lttng_chown_exit, result);
+
return result;
}
-
-static int vfs_lttng_fchown(vfs_handle_struct *handle, files_struct *fsp,
- uid_t uid, gid_t gid)
-
+static int vfs_lttng_fchown(vfs_handle_struct *handle,
+ files_struct *fsp,
+ uid_t uid, gid_t gid)
{
int result;
- tracepoint(vfs_lttng, vfs_lttng_fchown_enter , fsp);
+
+ tracepoint(vfs_lttng, vfs_lttng_fchown_enter, fsp);
result = SMB_VFS_NEXT_FCHOWN(handle, fsp, uid, gid);
tracepoint(vfs_lttng, vfs_lttng_fchown_exit, result);
+
return result;
}
-
static int vfs_lttng_lchown(vfs_handle_struct *handle,
- const struct smb_filename *smb_fname,
- uid_t uid,
- gid_t gid)
-
+ const struct smb_filename *smb_fname,
+ uid_t uid,
+ gid_t gid)
{
int result;
- tracepoint(vfs_lttng, vfs_lttng_lchown_enter , smb_fname);
+
+ tracepoint(vfs_lttng, vfs_lttng_lchown_enter, smb_fname);
result = SMB_VFS_NEXT_LCHOWN(handle, smb_fname, uid, gid);
tracepoint(vfs_lttng, vfs_lttng_lchown_exit, result);
+
return result;
}
-
static int vfs_lttng_chdir(vfs_handle_struct *handle,
- const struct smb_filename *smb_fname)
-
+ const struct smb_filename *smb_fname)
{
int result;
- tracepoint(vfs_lttng, vfs_lttng_chdir_enter , smb_fname);
+
+ tracepoint(vfs_lttng, vfs_lttng_chdir_enter, smb_fname);
result = SMB_VFS_NEXT_CHDIR(handle, smb_fname);
tracepoint(vfs_lttng, vfs_lttng_chdir_exit, result);
+
return result;
}
-
static struct smb_filename *vfs_lttng_getwd(vfs_handle_struct *handle,
- TALLOC_CTX *mem_ctx)
-
+ TALLOC_CTX *mem_ctx)
{
struct smb_filename * result;
- tracepoint(vfs_lttng, vfs_lttng_getwd_enter );
+
+ tracepoint(vfs_lttng, vfs_lttng_getwd_enter);
result = SMB_VFS_NEXT_GETWD(handle, mem_ctx);
tracepoint(vfs_lttng, vfs_lttng_getwd_exit);
+
return result;
}
-
static int vfs_lttng_ntimes(vfs_handle_struct *handle,
- const struct smb_filename *path,
- struct smb_file_time *ft)
-
+ const struct smb_filename *path,
+ struct smb_file_time *ft)
{
int result;
- tracepoint(vfs_lttng, vfs_lttng_ntimes_enter );
+
+ tracepoint(vfs_lttng, vfs_lttng_ntimes_enter);
result = SMB_VFS_NEXT_NTIMES(handle, path, ft);
tracepoint(vfs_lttng, vfs_lttng_ntimes_exit, result);
+
return result;
}
-
static int vfs_lttng_ftruncate(vfs_handle_struct *handle,
- files_struct *fsp,
- off_t len)
-
+ files_struct *fsp,
+ off_t len)
{
int result;
- tracepoint(vfs_lttng, vfs_lttng_ftruncate_enter , fsp);
+
+ tracepoint(vfs_lttng, vfs_lttng_ftruncate_enter, fsp);
result = SMB_VFS_NEXT_FTRUNCATE(handle, fsp, len);
tracepoint(vfs_lttng, vfs_lttng_ftruncate_exit, result);
+
return result;
}
-
static int vfs_lttng_fallocate(vfs_handle_struct *handle,
- files_struct *fsp,
- uint32_t mode,
- off_t offset,
- off_t len)
-
+ files_struct *fsp,
+ uint32_t mode,
+ off_t offset,
+ off_t len)
{
int result;
- tracepoint(vfs_lttng, vfs_lttng_fallocate_enter , fsp, mode, offset);
+
+ tracepoint(vfs_lttng, vfs_lttng_fallocate_enter, fsp, mode, offset);
result = SMB_VFS_NEXT_FALLOCATE(handle, fsp, mode, offset, len);
tracepoint(vfs_lttng, vfs_lttng_fallocate_exit, result);
+
return result;
}
-
-static bool vfs_lttng_lock(vfs_handle_struct *handle, files_struct *fsp,
- int op, off_t offset, off_t count,
- int type)
-
+static bool vfs_lttng_lock(vfs_handle_struct *handle,
+ files_struct *fsp,
+ int op,
+ off_t offset,
+ off_t count,
+ int type)
{
bool result;
- tracepoint(vfs_lttng, vfs_lttng_lock_enter , fsp, offset);
+
+ tracepoint(vfs_lttng, vfs_lttng_lock_enter, fsp, offset);
result = SMB_VFS_NEXT_LOCK(handle, fsp, op, offset, count, type);
tracepoint(vfs_lttng, vfs_lttng_lock_exit, result);
+
return result;
}
-
static int vfs_lttng_kernel_flock(struct vfs_handle_struct *handle,
- struct files_struct *fsp,
- uint32_t share_mode, uint32_t access_mask)
-
+ struct files_struct *fsp,
+ uint32_t share_mode,
+ uint32_t access_mask)
{
int result;
- tracepoint(vfs_lttng, vfs_lttng_kernel_flock_enter , fsp);
+
+ tracepoint(vfs_lttng, vfs_lttng_kernel_flock_enter, fsp);
result = SMB_VFS_NEXT_KERNEL_FLOCK(handle, fsp, share_mode, access_mask);
tracepoint(vfs_lttng, vfs_lttng_kernel_flock_exit, result);
+
return result;
}
-
static int vfs_lttng_linux_setlease(vfs_handle_struct *handle,
- files_struct *fsp,
- int leasetype)
-
+ files_struct *fsp,
+ int leasetype)
{
int result;
- tracepoint(vfs_lttng, vfs_lttng_linux_setlease_enter , fsp);
+
+ tracepoint(vfs_lttng, vfs_lttng_linux_setlease_enter, fsp);
result = SMB_VFS_NEXT_LINUX_SETLEASE(handle, fsp, leasetype);
tracepoint(vfs_lttng, vfs_lttng_linux_setlease_exit, result);
+
return result;
}
-
static bool vfs_lttng_getlock(vfs_handle_struct *handle,
- files_struct *fsp,
- off_t *poffset, off_t *pcount,
- int *ptype, pid_t *ppid)
-
+ files_struct *fsp,
+ off_t *poffset,
+ off_t *pcount,
+ int *ptype,
+ pid_t *ppid)
{
bool result;
- tracepoint(vfs_lttng, vfs_lttng_getlock_enter , fsp);
+
+ tracepoint(vfs_lttng, vfs_lttng_getlock_enter, fsp);
result = SMB_VFS_NEXT_GETLOCK(handle, fsp, poffset, pcount, ptype, ppid);
tracepoint(vfs_lttng, vfs_lttng_getlock_exit, result);
+
return result;
}
-
static int vfs_lttng_symlink(vfs_handle_struct *handle,
- const char *link_contents,
- const struct smb_filename *new_smb_fname)
-
+ const char *link_contents,
+ const struct smb_filename *new_smb_fname)
{
int result;
- tracepoint(vfs_lttng, vfs_lttng_symlink_enter );
+
+ tracepoint(vfs_lttng, vfs_lttng_symlink_enter);
result = SMB_VFS_NEXT_SYMLINK(handle, link_contents, new_smb_fname);
tracepoint(vfs_lttng, vfs_lttng_symlink_exit, result);
+
return result;
}
-
static int vfs_lttng_readlink(vfs_handle_struct *handle,
- const struct smb_filename *smb_fname,
- char *buf,
- size_t bufsiz)
-
+ const struct smb_filename *smb_fname,
+ char *buf,
+ size_t bufsiz)
{
int result;
- tracepoint(vfs_lttng, vfs_lttng_readlink_enter , smb_fname);
+
+ tracepoint(vfs_lttng, vfs_lttng_readlink_enter, smb_fname);
result = SMB_VFS_NEXT_READLINK(handle, smb_fname, buf, bufsiz);
tracepoint(vfs_lttng, vfs_lttng_readlink_exit, result);
+
return result;
}
-
static int vfs_lttng_link(vfs_handle_struct *handle,
- const struct smb_filename *old_smb_fname,
- const struct smb_filename *new_smb_fname)
-
+ const struct smb_filename *old_smb_fname,
+ const struct smb_filename *new_smb_fname)
{
int result;
- tracepoint(vfs_lttng, vfs_lttng_link_enter );
+
+ tracepoint(vfs_lttng, vfs_lttng_link_enter);
result = SMB_VFS_NEXT_LINK(handle, old_smb_fname, new_smb_fname);
tracepoint(vfs_lttng, vfs_lttng_link_exit, result);
+
return result;
}
-
static int vfs_lttng_mknod(vfs_handle_struct *handle,
- const struct smb_filename *smb_fname,
- mode_t mode,
- SMB_DEV_T dev)
-
+ const struct smb_filename *smb_fname,
+ mode_t mode,
+ SMB_DEV_T dev)
{
int result;
- tracepoint(vfs_lttng, vfs_lttng_mknod_enter , smb_fname, mode);
+
+ tracepoint(vfs_lttng, vfs_lttng_mknod_enter, smb_fname, mode);
result = SMB_VFS_NEXT_MKNOD(handle, smb_fname, mode, dev);
tracepoint(vfs_lttng, vfs_lttng_mknod_exit, result);
+
return result;
}
-
-static struct smb_filename *vfs_lttng_realpath(vfs_handle_struct *handle,
+static struct smb_filename *vfs_lttng_realpath(
+ vfs_handle_struct *handle,
TALLOC_CTX *ctx,
const struct smb_filename *smb_fname)
-
{
struct smb_filename * result;
- tracepoint(vfs_lttng, vfs_lttng_realpath_enter , smb_fname);
+
+ tracepoint(vfs_lttng, vfs_lttng_realpath_enter, smb_fname);
result = SMB_VFS_NEXT_REALPATH(handle, ctx, smb_fname);
tracepoint(vfs_lttng, vfs_lttng_realpath_exit);
+
return result;
}
-
static int vfs_lttng_chflags(vfs_handle_struct *handle,
- const struct smb_filename *smb_fname,
- unsigned int flags)
-
+ const struct smb_filename *smb_fname,
+ unsigned int flags)
{
int result;
- tracepoint(vfs_lttng, vfs_lttng_chflags_enter , smb_fname, flags);
+
+ tracepoint(vfs_lttng, vfs_lttng_chflags_enter, smb_fname, flags);
result = SMB_VFS_NEXT_CHFLAGS(handle, smb_fname, flags);
tracepoint(vfs_lttng, vfs_lttng_chflags_exit, result);
+
return result;
}
-
static struct file_id vfs_lttng_file_id_create(struct vfs_handle_struct *handle,
- const SMB_STRUCT_STAT *sbuf)
-
+ const SMB_STRUCT_STAT *sbuf)
{
struct file_id result;
- tracepoint(vfs_lttng, vfs_lttng_file_id_create_enter );
+
+ tracepoint(vfs_lttng, vfs_lttng_file_id_create_enter);
result = SMB_VFS_NEXT_FILE_ID_CREATE(handle, sbuf);
tracepoint(vfs_lttng, vfs_lttng_file_id_create_exit);
+
return result;
}
-
static struct tevent_req *vfs_lttng_offload_read_send(
TALLOC_CTX *mem_ctx,
struct tevent_context *ev,
@@ -758,249 +791,301 @@ static struct tevent_req *vfs_lttng_offload_read_send(
uint32_t ttl,
off_t offset,
size_t to_copy)
-
{
- struct tevent_req * result;
- tracepoint(vfs_lttng, vfs_lttng_offload_read_send_enter , fsp, offset);
- result = SMB_VFS_NEXT_OFFLOAD_READ_SEND(mem_ctx, ev, handle, fsp, fsctl, ttl, offset, to_copy);
+ struct tevent_req *req = NULL;
+
+ tracepoint(vfs_lttng, vfs_lttng_offload_read_send_enter, fsp, offset);
+ req = SMB_VFS_NEXT_OFFLOAD_READ_SEND(mem_ctx,
+ ev,
+ handle,
+ fsp,
+ fsctl,
+ ttl,
+ offset,
+ to_copy);
tracepoint(vfs_lttng, vfs_lttng_offload_read_send_exit);
- return result;
-}
+ return req;
+}
static NTSTATUS vfs_lttng_offload_read_recv(
struct tevent_req *req,
struct vfs_handle_struct *handle,
TALLOC_CTX *mem_ctx,
DATA_BLOB *_token_blob)
-
{
NTSTATUS result;
- tracepoint(vfs_lttng, vfs_lttng_offload_read_recv_enter );
- result = SMB_VFS_NEXT_OFFLOAD_READ_RECV(req, handle, mem_ctx, _token_blob);
+
+ tracepoint(vfs_lttng, vfs_lttng_offload_read_recv_enter);
+ result = SMB_VFS_NEXT_OFFLOAD_READ_RECV(req,
+ handle,
+ mem_ctx,
+ _token_blob);
tracepoint(vfs_lttng, vfs_lttng_offload_read_recv_exit, result);
+
return result;
}
-
-static struct tevent_req *vfs_lttng_offload_write_send(struct vfs_handle_struct *handle,
- TALLOC_CTX *mem_ctx,
- struct tevent_context *ev,
- uint32_t fsctl,
- DATA_BLOB *token,
- off_t transfer_offset,
- struct files_struct *dest_fsp,
- off_t dest_off,
- off_t num)
-
-{
- struct tevent_req * result;
- tracepoint(vfs_lttng, vfs_lttng_offload_write_send_enter );
- result = SMB_VFS_NEXT_OFFLOAD_WRITE_SEND(handle, mem_ctx, ev, fsctl, token, transfer_offset, dest_fsp, dest_off, num);
+static struct tevent_req *vfs_lttng_offload_write_send(
+ struct vfs_handle_struct *handle,
+ TALLOC_CTX *mem_ctx,
+ struct tevent_context *ev,
+ uint32_t fsctl,
+ DATA_BLOB *token,
+ off_t transfer_offset,
+ struct files_struct *dest_fsp,
+ off_t dest_off,
+ off_t num)
+{
+ struct tevent_req *req = NULL;
+
+ tracepoint(vfs_lttng, vfs_lttng_offload_write_send_enter);
+ req = SMB_VFS_NEXT_OFFLOAD_WRITE_SEND(handle,
+ mem_ctx,
+ ev,
+ fsctl,
+ token,
+ transfer_offset,
+ dest_fsp,
+ dest_off,
+ num);
tracepoint(vfs_lttng, vfs_lttng_offload_write_send_exit);
- return result;
-}
+ return req;
+}
static NTSTATUS vfs_lttng_offload_write_recv(struct vfs_handle_struct *handle,
- struct tevent_req *req,
- off_t *copied)
-
+ struct tevent_req *req,
+ off_t *copied)
{
NTSTATUS result;
- tracepoint(vfs_lttng, vfs_lttng_offload_write_recv_enter );
+
+ tracepoint(vfs_lttng, vfs_lttng_offload_write_recv_enter);
result = SMB_VFS_NEXT_OFFLOAD_WRITE_RECV(handle, req, copied);
tracepoint(vfs_lttng, vfs_lttng_offload_write_recv_exit, result);
+
return result;
}
-
static NTSTATUS vfs_lttng_get_compression(vfs_handle_struct *handle,
- TALLOC_CTX *mem_ctx,
- struct files_struct *fsp,
- struct smb_filename *smb_fname,
- uint16_t *_compression_fmt)
-
+ TALLOC_CTX *mem_ctx,
+ struct files_struct *fsp,
+ struct smb_filename *smb_fname,
+ uint16_t *_compression_fmt)
{
NTSTATUS result;
- tracepoint(vfs_lttng, vfs_lttng_get_compression_enter , fsp);
- result = SMB_VFS_NEXT_GET_COMPRESSION(handle, mem_ctx, fsp, smb_fname, _compression_fmt);
+
+ tracepoint(vfs_lttng, vfs_lttng_get_compression_enter, fsp);
+ result = SMB_VFS_NEXT_GET_COMPRESSION(handle,
+ mem_ctx,
+ fsp,
+ smb_fname,
+ _compression_fmt);
tracepoint(vfs_lttng, vfs_lttng_get_compression_exit, result);
+
return result;
}
-
static NTSTATUS vfs_lttng_set_compression(vfs_handle_struct *handle,
- TALLOC_CTX *mem_ctx,
- struct files_struct *fsp,
- uint16_t compression_fmt)
-
+ TALLOC_CTX *mem_ctx,
+ struct files_struct *fsp,
+ uint16_t compression_fmt)
{
NTSTATUS result;
- tracepoint(vfs_lttng, vfs_lttng_set_compression_enter , fsp);
- result = SMB_VFS_NEXT_SET_COMPRESSION(handle, mem_ctx, fsp, compression_fmt);
+
+ tracepoint(vfs_lttng, vfs_lttng_set_compression_enter, fsp);
+ result = SMB_VFS_NEXT_SET_COMPRESSION(handle,
+ mem_ctx,
+ fsp,
+ compression_fmt);
tracepoint(vfs_lttng, vfs_lttng_set_compression_exit, result);
+
return result;
}
-
static NTSTATUS vfs_lttng_snap_check_path(struct vfs_handle_struct *handle,
- TALLOC_CTX *mem_ctx,
- const char *service_path,
- char **base_volume)
-
+ TALLOC_CTX *mem_ctx,
+ const char *service_path,
+ char **base_volume)
{
NTSTATUS result;
- tracepoint(vfs_lttng, vfs_lttng_snap_check_path_enter );
- result = SMB_VFS_NEXT_SNAP_CHECK_PATH(handle, mem_ctx, service_path, base_volume);
+
+ tracepoint(vfs_lttng, vfs_lttng_snap_check_path_enter);
+ result = SMB_VFS_NEXT_SNAP_CHECK_PATH(handle,
+ mem_ctx,
+ service_path,
+ base_volume);
tracepoint(vfs_lttng, vfs_lttng_snap_check_path_exit, result);
+
return result;
}
-
static NTSTATUS vfs_lttng_snap_create(struct vfs_handle_struct *handle,
- TALLOC_CTX *mem_ctx,
- const char *base_volume,
- time_t *tstamp,
- bool rw,
- char **base_path,
- char **snap_path)
-
+ TALLOC_CTX *mem_ctx,
+ const char *base_volume,
+ time_t *tstamp,
+ bool rw,
+ char **base_path,
+ char **snap_path)
{
NTSTATUS result;
- tracepoint(vfs_lttng, vfs_lttng_snap_create_enter );
- result = SMB_VFS_NEXT_SNAP_CREATE(handle, mem_ctx, base_volume, tstamp, rw, base_path, snap_path);
+
+ tracepoint(vfs_lttng, vfs_lttng_snap_create_enter);
+ result = SMB_VFS_NEXT_SNAP_CREATE(handle,
+ mem_ctx,
+ base_volume,
+ tstamp,
+ rw,
+ base_path,
+ snap_path);
tracepoint(vfs_lttng, vfs_lttng_snap_create_exit, result);
+
return result;
}
-
static NTSTATUS vfs_lttng_snap_delete(struct vfs_handle_struct *handle,
- TALLOC_CTX *mem_ctx,
- char *base_path,
- char *snap_path)
-
+ TALLOC_CTX *mem_ctx,
+ char *base_path,
+ char *snap_path)
{
NTSTATUS result;
- tracepoint(vfs_lttng, vfs_lttng_snap_delete_enter );
+
+ tracepoint(vfs_lttng, vfs_lttng_snap_delete_enter);
result = SMB_VFS_NEXT_SNAP_DELETE(handle, mem_ctx, base_path, snap_path);
tracepoint(vfs_lttng, vfs_lttng_snap_delete_exit, result);
+
return result;
}
-
static NTSTATUS vfs_lttng_streaminfo(vfs_handle_struct *handle,
- struct files_struct *fsp,
- const struct smb_filename *smb_fname,
- TALLOC_CTX *mem_ctx,
- unsigned int *pnum_streams,
- struct stream_struct **pstreams)
-
+ struct files_struct *fsp,
+ const struct smb_filename *smb_fname,
+ TALLOC_CTX *mem_ctx,
+ unsigned int *pnum_streams,
+ struct stream_struct **pstreams)
{
NTSTATUS result;
- tracepoint(vfs_lttng, vfs_lttng_streaminfo_enter , fsp);
- result = SMB_VFS_NEXT_STREAMINFO(handle, fsp, smb_fname, mem_ctx, pnum_streams, pstreams);
+
+ tracepoint(vfs_lttng, vfs_lttng_streaminfo_enter, fsp);
+ result = SMB_VFS_NEXT_STREAMINFO(handle,
+ fsp,
+ smb_fname,
+ mem_ctx,
+ pnum_streams,
+ pstreams);
tracepoint(vfs_lttng, vfs_lttng_streaminfo_exit, result);
+
return result;
}
-
static int vfs_lttng_get_real_filename(struct vfs_handle_struct *handle,
- const char *path,
- const char *name,
- TALLOC_CTX *mem_ctx,
- char **found_name)
-
+ const char *path,
+ const char *name,
+ TALLOC_CTX *mem_ctx,
+ char **found_name)
{
int result;
- tracepoint(vfs_lttng, vfs_lttng_get_real_filename_enter , name);
- result = SMB_VFS_NEXT_GET_REAL_FILENAME(handle, path, name, mem_ctx, found_name);
+
+ tracepoint(vfs_lttng, vfs_lttng_get_real_filename_enter, name);
+ result = SMB_VFS_NEXT_GET_REAL_FILENAME(handle,
+ path,
+ name,
+ mem_ctx,
+ found_name);
tracepoint(vfs_lttng, vfs_lttng_get_real_filename_exit, result);
+
return result;
}
-
static const char *vfs_lttng_connectpath(vfs_handle_struct *handle,
- const struct smb_filename *smb_fname)
-
+ const struct smb_filename *smb_fname)
{
- const char * result;
- tracepoint(vfs_lttng, vfs_lttng_connectpath_enter , smb_fname);
+ const char *result = NULL;
+
+ tracepoint(vfs_lttng, vfs_lttng_connectpath_enter, smb_fname);
result = SMB_VFS_NEXT_CONNECTPATH(handle, smb_fname);
tracepoint(vfs_lttng, vfs_lttng_connectpath_exit);
+
return result;
}
static NTSTATUS vfs_lttng_brl_lock_windows(struct vfs_handle_struct *handle,
- struct byte_range_lock *br_lck,
- struct lock_struct *plock,
- bool blocking_lock)
-
+ struct byte_range_lock *br_lck,
+ struct lock_struct *plock,
+ bool blocking_lock)
{
NTSTATUS result;
- tracepoint(vfs_lttng, vfs_lttng_brl_lock_windows_enter );
- result = SMB_VFS_NEXT_BRL_LOCK_WINDOWS(handle, br_lck, plock, blocking_lock);
+
+ tracepoint(vfs_lttng, vfs_lttng_brl_lock_windows_enter);
+ result = SMB_VFS_NEXT_BRL_LOCK_WINDOWS(handle,
+ br_lck,
+ plock,
+ blocking_lock);
tracepoint(vfs_lttng, vfs_lttng_brl_lock_windows_exit, result);
+
return result;
}
-
static bool vfs_lttng_brl_unlock_windows(struct vfs_handle_struct *handle,
- struct messaging_context *msg_ctx,
- struct byte_range_lock *br_lck,
- const struct lock_struct *plock)
-
+ struct messaging_context *msg_ctx,
+ struct byte_range_lock *br_lck,
+ const struct lock_struct *plock)
{
bool result;
- tracepoint(vfs_lttng, vfs_lttng_brl_unlock_windows_enter );
+
+ tracepoint(vfs_lttng, vfs_lttng_brl_unlock_windows_enter);
result = SMB_VFS_NEXT_BRL_UNLOCK_WINDOWS(handle, msg_ctx, br_lck, plock);
tracepoint(vfs_lttng, vfs_lttng_brl_unlock_windows_exit, result);
+
return result;
}
-
static bool vfs_lttng_brl_cancel_windows(struct vfs_handle_struct *handle,
- struct byte_range_lock *br_lck,
- struct lock_struct *plock)
-
+ struct byte_range_lock *br_lck,
+ struct lock_struct *plock)
{
bool result;
- tracepoint(vfs_lttng, vfs_lttng_brl_cancel_windows_enter );
+
+ tracepoint(vfs_lttng, vfs_lttng_brl_cancel_windows_enter);
result = SMB_VFS_NEXT_BRL_CANCEL_WINDOWS(handle, br_lck, plock);
tracepoint(vfs_lttng, vfs_lttng_brl_cancel_windows_exit, result);
+
return result;
}
-
static bool vfs_lttng_strict_lock_check(struct vfs_handle_struct *handle,
- struct files_struct *fsp,
- struct lock_struct *plock)
-
+ struct files_struct *fsp,
+ struct lock_struct *plock)
{
bool result;
- tracepoint(vfs_lttng, vfs_lttng_strict_lock_check_enter , fsp);
+
+ tracepoint(vfs_lttng, vfs_lttng_strict_lock_check_enter, fsp);
result = SMB_VFS_NEXT_STRICT_LOCK_CHECK(handle, fsp, plock);
tracepoint(vfs_lttng, vfs_lttng_strict_lock_check_exit, result);
+
return result;
}
-
static NTSTATUS vfs_lttng_translate_name(struct vfs_handle_struct *handle,
- const char *name,
- enum vfs_translate_direction direction,
- TALLOC_CTX *mem_ctx,
- char **mapped_name)
-
+ const char *name,
+ enum vfs_translate_direction direction,
+ TALLOC_CTX *mem_ctx,
+ char **mapped_name)
{
NTSTATUS result;
- tracepoint(vfs_lttng, vfs_lttng_translate_name_enter , name);
- result = SMB_VFS_NEXT_TRANSLATE_NAME(handle, name, direction, mem_ctx, mapped_name);
+
+ tracepoint(vfs_lttng, vfs_lttng_translate_name_enter, name);
+ result = SMB_VFS_NEXT_TRANSLATE_NAME(handle,
+ name,
+ direction,
+ mem_ctx,
+ mapped_name);
tracepoint(vfs_lttng, vfs_lttng_translate_name_exit, result);
+
return result;
}
-
static NTSTATUS vfs_lttng_fsctl(struct vfs_handle_struct *handle,
struct files_struct *fsp,
TALLOC_CTX *ctx,
@@ -1011,402 +1096,458 @@ static NTSTATUS vfs_lttng_fsctl(struct vfs_handle_struct *handle,
uint8_t **_out_data,
uint32_t max_out_len,
uint32_t *out_len)
-
{
NTSTATUS result;
- tracepoint(vfs_lttng, vfs_lttng_fsctl_enter , fsp);
- result = SMB_VFS_NEXT_FSCTL(handle, fsp, ctx, function, req_flags, _in_data, in_len, _out_data, max_out_len, out_len);
+
+ tracepoint(vfs_lttng, vfs_lttng_fsctl_enter, fsp);
+ result = SMB_VFS_NEXT_FSCTL(handle,
+ fsp,
+ ctx,
+ function,
+ req_flags,
+ _in_data,
+ in_len,
+ _out_data,
+ max_out_len,
+ out_len);
tracepoint(vfs_lttng, vfs_lttng_fsctl_exit, result);
+
return result;
}
-
static NTSTATUS vfs_lttng_get_dos_attributes(struct vfs_handle_struct *handle,
- struct smb_filename *smb_fname,
- uint32_t *dosmode)
-
+ struct smb_filename *smb_fname,
+ uint32_t *dosmode)
{
NTSTATUS result;
- tracepoint(vfs_lttng, vfs_lttng_get_dos_attributes_enter , smb_fname);
+
+ tracepoint(vfs_lttng, vfs_lttng_get_dos_attributes_enter, smb_fname);
result = SMB_VFS_NEXT_GET_DOS_ATTRIBUTES(handle, smb_fname, dosmode);
tracepoint(vfs_lttng, vfs_lttng_get_dos_attributes_exit, result);
+
return result;
}
-
static NTSTATUS vfs_lttng_fget_dos_attributes(struct vfs_handle_struct *handle,
- struct files_struct *fsp,
- uint32_t *dosmode)
-
+ struct files_struct *fsp,
+ uint32_t *dosmode)
{
NTSTATUS result;
- tracepoint(vfs_lttng, vfs_lttng_fget_dos_attributes_enter , fsp);
+
+ tracepoint(vfs_lttng, vfs_lttng_fget_dos_attributes_enter, fsp);
result = SMB_VFS_NEXT_FGET_DOS_ATTRIBUTES(handle, fsp, dosmode);
tracepoint(vfs_lttng, vfs_lttng_fget_dos_attributes_exit, result);
+
return result;
}
-
-static NTSTATUS vfs_lttng_set_dos_attributes(struct vfs_handle_struct *handle,
- const struct smb_filename *smb_fname,
- uint32_t dosmode)
-
+static NTSTATUS vfs_lttng_set_dos_attributes(
+ struct vfs_handle_struct *handle,
+ const struct smb_filename *smb_fname,
+ uint32_t dosmode)
{
NTSTATUS result;
- tracepoint(vfs_lttng, vfs_lttng_set_dos_attributes_enter , smb_fname);
+
+ tracepoint(vfs_lttng, vfs_lttng_set_dos_attributes_enter, smb_fname);
result = SMB_VFS_NEXT_SET_DOS_ATTRIBUTES(handle, smb_fname, dosmode);
tracepoint(vfs_lttng, vfs_lttng_set_dos_attributes_exit, result);
+
return result;
}
-
static NTSTATUS vfs_lttng_fset_dos_attributes(struct vfs_handle_struct *handle,
- struct files_struct *fsp,
- uint32_t dosmode)
-
+ struct files_struct *fsp,
+ uint32_t dosmode)
{
NTSTATUS result;
- tracepoint(vfs_lttng, vfs_lttng_fset_dos_attributes_enter , fsp);
+
+ tracepoint(vfs_lttng, vfs_lttng_fset_dos_attributes_enter, fsp);
result = SMB_VFS_NEXT_FSET_DOS_ATTRIBUTES(handle, fsp, dosmode);
tracepoint(vfs_lttng, vfs_lttng_fset_dos_attributes_exit, result);
+
return result;
}
-
static NTSTATUS vfs_lttng_fget_nt_acl(vfs_handle_struct *handle,
- files_struct *fsp,
- uint32_t security_info,
- TALLOC_CTX *mem_ctx,
- struct security_descriptor **ppdesc)
-
+ files_struct *fsp,
+ uint32_t security_info,
+ TALLOC_CTX *mem_ctx,
+ struct security_descriptor **ppdesc)
{
NTSTATUS result;
- tracepoint(vfs_lttng, vfs_lttng_fget_nt_acl_enter , fsp);
- result = SMB_VFS_NEXT_FGET_NT_ACL(handle, fsp, security_info, mem_ctx, ppdesc);
+
+ tracepoint(vfs_lttng, vfs_lttng_fget_nt_acl_enter, fsp);
+ result = SMB_VFS_NEXT_FGET_NT_ACL(handle,
+ fsp,
+ security_info,
+ mem_ctx,
+ ppdesc);
tracepoint(vfs_lttng, vfs_lttng_fget_nt_acl_exit, result);
+
return result;
}
-
static NTSTATUS vfs_lttng_get_nt_acl(vfs_handle_struct *handle,
- const struct smb_filename *smb_fname,
- uint32_t security_info,
- TALLOC_CTX *mem_ctx,
- struct security_descriptor **ppdesc)
-
+ const struct smb_filename *smb_fname,
+ uint32_t security_info,
+ TALLOC_CTX *mem_ctx,
+ struct security_descriptor **ppdesc)
{
NTSTATUS result;
- tracepoint(vfs_lttng, vfs_lttng_get_nt_acl_enter , smb_fname);
- result = SMB_VFS_NEXT_GET_NT_ACL(handle, smb_fname, security_info, mem_ctx, ppdesc);
+
+ tracepoint(vfs_lttng, vfs_lttng_get_nt_acl_enter, smb_fname);
+ result = SMB_VFS_NEXT_GET_NT_ACL(handle,
+ smb_fname,
+ security_info,
+ mem_ctx,
+ ppdesc);
tracepoint(vfs_lttng, vfs_lttng_get_nt_acl_exit, result);
+
return result;
}
static NTSTATUS vfs_lttng_fset_nt_acl(vfs_handle_struct *handle,
- files_struct *fsp,
- uint32_t security_info_sent,
- const struct security_descriptor *psd)
-
+ files_struct *fsp,
+ uint32_t security_info_sent,
+ const struct security_descriptor *psd)
{
NTSTATUS result;
- tracepoint(vfs_lttng, vfs_lttng_fset_nt_acl_enter , fsp);
+
+ tracepoint(vfs_lttng, vfs_lttng_fset_nt_acl_enter, fsp);
result = SMB_VFS_NEXT_FSET_NT_ACL(handle, fsp, security_info_sent, psd);
tracepoint(vfs_lttng, vfs_lttng_fset_nt_acl_exit, result);
+
return result;
}
-
static NTSTATUS vfs_lttng_audit_file(struct vfs_handle_struct *handle,
- struct smb_filename *smb_fname,
- struct security_acl *sacl,
- uint32_t access_requested,
- uint32_t access_denied)
-
+ struct smb_filename *smb_fname,
+ struct security_acl *sacl,
+ uint32_t access_requested,
+ uint32_t access_denied)
{
NTSTATUS result;
- tracepoint(vfs_lttng, vfs_lttng_audit_file_enter , smb_fname);
- result = SMB_VFS_NEXT_AUDIT_FILE(handle, smb_fname, sacl, access_requested, access_denied);
+
+ tracepoint(vfs_lttng, vfs_lttng_audit_file_enter, smb_fname);
+ result = SMB_VFS_NEXT_AUDIT_FILE(handle,
+ smb_fname,
+ sacl,
+ access_requested,
+ access_denied);
tracepoint(vfs_lttng, vfs_lttng_audit_file_exit, result);
+
return result;
}
-
static SMB_ACL_T vfs_lttng_sys_acl_get_file(vfs_handle_struct *handle,
- const struct smb_filename *smb_fname,
- SMB_ACL_TYPE_T type,
- TALLOC_CTX *mem_ctx)
-
+ const struct smb_filename *smb_fname,
+ SMB_ACL_TYPE_T type,
+ TALLOC_CTX *mem_ctx)
{
SMB_ACL_T result;
- tracepoint(vfs_lttng, vfs_lttng_sys_acl_get_file_enter , smb_fname);
+
+ tracepoint(vfs_lttng, vfs_lttng_sys_acl_get_file_enter, smb_fname);
result = SMB_VFS_NEXT_SYS_ACL_GET_FILE(handle, smb_fname, type, mem_ctx);
tracepoint(vfs_lttng, vfs_lttng_sys_acl_get_file_exit, result);
+
return result;
}
-
static SMB_ACL_T vfs_lttng_sys_acl_get_fd(vfs_handle_struct *handle,
- files_struct *fsp,
- TALLOC_CTX *mem_ctx)
-
+ files_struct *fsp,
+ TALLOC_CTX *mem_ctx)
{
SMB_ACL_T result;
- tracepoint(vfs_lttng, vfs_lttng_sys_acl_get_fd_enter , fsp);
+
+ tracepoint(vfs_lttng, vfs_lttng_sys_acl_get_fd_enter, fsp);
result = SMB_VFS_NEXT_SYS_ACL_GET_FD(handle, fsp, mem_ctx);
tracepoint(vfs_lttng, vfs_lttng_sys_acl_get_fd_exit, result);
+
return result;
}
-
static int vfs_lttng_sys_acl_blob_get_file(vfs_handle_struct *handle,
- const struct smb_filename *smb_fname,
- TALLOC_CTX *mem_ctx,
- char **blob_description,
- DATA_BLOB *blob)
-
+ const struct smb_filename *smb_fname,
+ TALLOC_CTX *mem_ctx,
+ char **blob_description,
+ DATA_BLOB *blob)
{
int result;
- tracepoint(vfs_lttng, vfs_lttng_sys_acl_blob_get_file_enter , smb_fname);
- result = SMB_VFS_NEXT_SYS_ACL_BLOB_GET_FILE(handle, smb_fname, mem_ctx, blob_description, blob);
+
+ tracepoint(vfs_lttng, vfs_lttng_sys_acl_blob_get_file_enter, smb_fname);
+ result = SMB_VFS_NEXT_SYS_ACL_BLOB_GET_FILE(handle,
+ smb_fname,
+ mem_ctx,
+ blob_description,
+ blob);
tracepoint(vfs_lttng, vfs_lttng_sys_acl_blob_get_file_exit, result);
+
return result;
}
-
static int vfs_lttng_sys_acl_blob_get_fd(vfs_handle_struct *handle,
- files_struct *fsp,
- TALLOC_CTX *mem_ctx,
- char **blob_description,
- DATA_BLOB *blob)
-
+ files_struct *fsp,
+ TALLOC_CTX *mem_ctx,
+ char **blob_description,
+ DATA_BLOB *blob)
{
int result;
- tracepoint(vfs_lttng, vfs_lttng_sys_acl_blob_get_fd_enter , fsp);
- result = SMB_VFS_NEXT_SYS_ACL_BLOB_GET_FD(handle, fsp, mem_ctx, blob_description, blob);
+
+ tracepoint(vfs_lttng, vfs_lttng_sys_acl_blob_get_fd_enter, fsp);
+ result = SMB_VFS_NEXT_SYS_ACL_BLOB_GET_FD(handle,
+ fsp,
+ mem_ctx,
+ blob_description,
+ blob);
tracepoint(vfs_lttng, vfs_lttng_sys_acl_blob_get_fd_exit, result);
+
return result;
}
-
static int vfs_lttng_sys_acl_set_file(vfs_handle_struct *handle,
- const struct smb_filename *smb_fname,
- SMB_ACL_TYPE_T acltype,
- SMB_ACL_T theacl)
-
+ const struct smb_filename *smb_fname,
+ SMB_ACL_TYPE_T acltype,
+ SMB_ACL_T theacl)
{
int result;
- tracepoint(vfs_lttng, vfs_lttng_sys_acl_set_file_enter , smb_fname);
- result = SMB_VFS_NEXT_SYS_ACL_SET_FILE(handle, smb_fname, acltype, theacl);
+
+ tracepoint(vfs_lttng, vfs_lttng_sys_acl_set_file_enter, smb_fname);
+ result = SMB_VFS_NEXT_SYS_ACL_SET_FILE(handle,
+ smb_fname,
+ acltype,
+ theacl);
tracepoint(vfs_lttng, vfs_lttng_sys_acl_set_file_exit, result);
+
return result;
}
-
static int vfs_lttng_sys_acl_set_fd(vfs_handle_struct *handle,
- files_struct *fsp,
- SMB_ACL_T theacl)
-
+ files_struct *fsp,
+ SMB_ACL_T theacl)
{
int result;
- tracepoint(vfs_lttng, vfs_lttng_sys_acl_set_fd_enter , fsp);
+
+ tracepoint(vfs_lttng, vfs_lttng_sys_acl_set_fd_enter, fsp);
result = SMB_VFS_NEXT_SYS_ACL_SET_FD(handle, fsp, theacl);
tracepoint(vfs_lttng, vfs_lttng_sys_acl_set_fd_exit, result);
+
return result;
}
-
-static int vfs_lttng_sys_acl_delete_def_file(vfs_handle_struct *handle,
- const struct smb_filename *smb_fname)
-
+static int vfs_lttng_sys_acl_delete_def_file(
+ vfs_handle_struct *handle,
+ const struct smb_filename *smb_fname)
{
int result;
- tracepoint(vfs_lttng, vfs_lttng_sys_acl_delete_def_file_enter , smb_fname);
+
+ tracepoint(vfs_lttng, vfs_lttng_sys_acl_delete_def_file_enter, smb_fname);
result = SMB_VFS_NEXT_SYS_ACL_DELETE_DEF_FILE(handle, smb_fname);
tracepoint(vfs_lttng, vfs_lttng_sys_acl_delete_def_file_exit, result);
+
return result;
}
-
static ssize_t vfs_lttng_getxattr(struct vfs_handle_struct *handle,
- const struct smb_filename *smb_fname,
- const char *name,
- void *value,
- size_t size)
-
+ const struct smb_filename *smb_fname,
+ const char *name,
+ void *value,
+ size_t size)
{
ssize_t result;
- tracepoint(vfs_lttng, vfs_lttng_getxattr_enter , smb_fname, name);
+
+ tracepoint(vfs_lttng, vfs_lttng_getxattr_enter, smb_fname, name);
result = SMB_VFS_NEXT_GETXATTR(handle, smb_fname, name, value, size);
tracepoint(vfs_lttng, vfs_lttng_getxattr_exit, result);
+
return result;
}
-
static ssize_t vfs_lttng_fgetxattr(struct vfs_handle_struct *handle,
- struct files_struct *fsp,
- const char *name, void *value,
- size_t size)
-
+ struct files_struct *fsp,
+ const char *name,
+ void *value,
+ size_t size)
{
ssize_t result;
- tracepoint(vfs_lttng, vfs_lttng_fgetxattr_enter , fsp, name);
+
+ tracepoint(vfs_lttng, vfs_lttng_fgetxattr_enter, fsp, name);
result = SMB_VFS_NEXT_FGETXATTR(handle, fsp, name, value, size);
tracepoint(vfs_lttng, vfs_lttng_fgetxattr_exit, result);
+
return result;
}
-
static ssize_t vfs_lttng_listxattr(struct vfs_handle_struct *handle,
- const struct smb_filename *smb_fname,
- char *list,
- size_t size)
-
+ const struct smb_filename *smb_fname,
+ char *list,
+ size_t size)
{
ssize_t result;
- tracepoint(vfs_lttng, vfs_lttng_listxattr_enter , smb_fname);
+
+ tracepoint(vfs_lttng, vfs_lttng_listxattr_enter, smb_fname);
result = SMB_VFS_NEXT_LISTXATTR(handle, smb_fname, list, size);
tracepoint(vfs_lttng, vfs_lttng_listxattr_exit, result);
+
return result;
}
-
static ssize_t vfs_lttng_flistxattr(struct vfs_handle_struct *handle,
- struct files_struct *fsp, char *list,
- size_t size)
-
+ struct files_struct *fsp,
+ char *list,
+ size_t size)
{
ssize_t result;
- tracepoint(vfs_lttng, vfs_lttng_flistxattr_enter , fsp);
+
+ tracepoint(vfs_lttng, vfs_lttng_flistxattr_enter, fsp);
result = SMB_VFS_NEXT_FLISTXATTR(handle, fsp, list, size);
tracepoint(vfs_lttng, vfs_lttng_flistxattr_exit, result);
+
return result;
}
-
static int vfs_lttng_removexattr(struct vfs_handle_struct *handle,
- const struct smb_filename *smb_fname,
- const char *name)
-
+ const struct smb_filename *smb_fname,
+ const char *name)
{
int result;
- tracepoint(vfs_lttng, vfs_lttng_removexattr_enter , smb_fname, name);
+
+ tracepoint(vfs_lttng, vfs_lttng_removexattr_enter, smb_fname, name);
result = SMB_VFS_NEXT_REMOVEXATTR(handle, smb_fname, name);
tracepoint(vfs_lttng, vfs_lttng_removexattr_exit, result);
+
return result;
}
-
static int vfs_lttng_fremovexattr(struct vfs_handle_struct *handle,
- struct files_struct *fsp,
- const char *name)
-
+ struct files_struct *fsp,
+ const char *name)
{
int result;
- tracepoint(vfs_lttng, vfs_lttng_fremovexattr_enter , fsp, name);
+
+ tracepoint(vfs_lttng, vfs_lttng_fremovexattr_enter, fsp, name);
result = SMB_VFS_NEXT_FREMOVEXATTR(handle, fsp, name);
tracepoint(vfs_lttng, vfs_lttng_fremovexattr_exit, result);
+
return result;
}
-
static int vfs_lttng_setxattr(struct vfs_handle_struct *handle,
- const struct smb_filename *smb_fname,
- const char *name,
- const void *value,
- size_t size,
- int flags)
-
+ const struct smb_filename *smb_fname,
+ const char *name,
+ const void *value,
+ size_t size,
+ int flags)
{
int result;
- tracepoint(vfs_lttng, vfs_lttng_setxattr_enter , smb_fname, name, flags);
- result = SMB_VFS_NEXT_SETXATTR(handle, smb_fname, name, value, size, flags);
+
+ tracepoint(vfs_lttng, vfs_lttng_setxattr_enter, smb_fname, name, flags);
+ result = SMB_VFS_NEXT_SETXATTR(handle,
+ smb_fname,
+ name, value,
+ size,
+ flags);
tracepoint(vfs_lttng, vfs_lttng_setxattr_exit, result);
+
return result;
}
static int vfs_lttng_fsetxattr(struct vfs_handle_struct *handle,
- struct files_struct *fsp, const char *name,
- const void *value, size_t size, int flags)
-
+ struct files_struct *fsp,
+ const char *name,
+ const void *value,
+ size_t size,
+ int flags)
{
int result;
- tracepoint(vfs_lttng, vfs_lttng_fsetxattr_enter , fsp, name, flags);
+
+ tracepoint(vfs_lttng, vfs_lttng_fsetxattr_enter, fsp, name, flags);
result = SMB_VFS_NEXT_FSETXATTR(handle, fsp, name, value, size, flags);
tracepoint(vfs_lttng, vfs_lttng_fsetxattr_exit, result);
+
return result;
}
-
static bool vfs_lttng_aio_force(struct vfs_handle_struct *handle,
- struct files_struct *fsp)
-
+ struct files_struct *fsp)
{
bool result;
- tracepoint(vfs_lttng, vfs_lttng_aio_force_enter , fsp);
+
+ tracepoint(vfs_lttng, vfs_lttng_aio_force_enter, fsp);
result = SMB_VFS_NEXT_AIO_FORCE(handle, fsp);
tracepoint(vfs_lttng, vfs_lttng_aio_force_exit, result);
+
return result;
}
-
static NTSTATUS vfs_lttng_durable_cookie(struct vfs_handle_struct *handle,
- struct files_struct *fsp,
- TALLOC_CTX *mem_ctx,
- DATA_BLOB *cookie)
-
+ struct files_struct *fsp,
+ TALLOC_CTX *mem_ctx,
+ DATA_BLOB *cookie)
{
NTSTATUS result;
- tracepoint(vfs_lttng, vfs_lttng_durable_cookie_enter , fsp);
+
+ tracepoint(vfs_lttng, vfs_lttng_durable_cookie_enter, fsp);
result = SMB_VFS_NEXT_DURABLE_COOKIE(handle, fsp, mem_ctx, cookie);
tracepoint(vfs_lttng, vfs_lttng_durable_cookie_exit, result);
+
return result;
}
-
static NTSTATUS vfs_lttng_durable_disconnect(struct vfs_handle_struct *handle,
- struct files_struct *fsp,
- const DATA_BLOB old_cookie,
- TALLOC_CTX *mem_ctx,
- DATA_BLOB *new_cookie)
-
+ struct files_struct *fsp,
+ const DATA_BLOB old_cookie,
+ TALLOC_CTX *mem_ctx,
+ DATA_BLOB *new_cookie)
{
NTSTATUS result;
- tracepoint(vfs_lttng, vfs_lttng_durable_disconnect_enter , fsp);
- result = SMB_VFS_NEXT_DURABLE_DISCONNECT(handle, fsp, old_cookie, mem_ctx, new_cookie);
+
+ tracepoint(vfs_lttng, vfs_lttng_durable_disconnect_enter, fsp);
+ result = SMB_VFS_NEXT_DURABLE_DISCONNECT(handle,
+ fsp,
+ old_cookie,
+ mem_ctx,
+ new_cookie);
tracepoint(vfs_lttng, vfs_lttng_durable_disconnect_exit, result);
+
return result;
}
-
static NTSTATUS vfs_lttng_durable_reconnect(struct vfs_handle_struct *handle,
- struct smb_request *smb1req,
- struct smbXsrv_open *op,
- const DATA_BLOB old_cookie,
- TALLOC_CTX *mem_ctx,
- struct files_struct **fsp,
- DATA_BLOB *new_cookie)
-
+ struct smb_request *smb1req,
+ struct smbXsrv_open *op,
+ const DATA_BLOB old_cookie,
+ TALLOC_CTX *mem_ctx,
+ struct files_struct **fsp,
+ DATA_BLOB *new_cookie)
{
NTSTATUS result;
- tracepoint(vfs_lttng, vfs_lttng_durable_reconnect_enter , fsp);
- result = SMB_VFS_NEXT_DURABLE_RECONNECT(handle, smb1req, op, old_cookie, mem_ctx, fsp, new_cookie);
+
+ tracepoint(vfs_lttng, vfs_lttng_durable_reconnect_enter, fsp);
+ result = SMB_VFS_NEXT_DURABLE_RECONNECT(handle,
+ smb1req,
+ op,
+ old_cookie,
+ mem_ctx,
+ fsp,
+ new_cookie);
tracepoint(vfs_lttng, vfs_lttng_durable_reconnect_exit, result);
+
return result;
}
-
static NTSTATUS vfs_lttng_readdir_attr(struct vfs_handle_struct *handle,
- const struct smb_filename *fname,
- TALLOC_CTX *mem_ctx,
- struct readdir_attr_data **pattr_data)
-
+ const struct smb_filename *fname,
+ TALLOC_CTX *mem_ctx,
+ struct readdir_attr_data **pattr_data)
{
NTSTATUS result;
- tracepoint(vfs_lttng, vfs_lttng_readdir_attr_enter , fname);
+
+ tracepoint(vfs_lttng, vfs_lttng_readdir_attr_enter, fname);
result = SMB_VFS_NEXT_READDIR_ATTR(handle, fname, mem_ctx, pattr_data);
tracepoint(vfs_lttng, vfs_lttng_readdir_attr_exit, result);
+
return result;
}
@@ -1511,10 +1652,12 @@ static struct vfs_fn_pointers vfs_lttng_fns = {
.readdir_attr_fn = vfs_lttng_readdir_attr
};
-NTSTATUS vfs_lttng_init(TALLOC_CTX *);
+static_decl_vfs;
NTSTATUS vfs_lttng_init(TALLOC_CTX *ctx)
{
- return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "lttng",
- &vfs_lttng_fns);
+ smb_vfs_assert_all_fns(&vfs_lttng_fns, "lttng");
+
+ return smb_register_vfs(SMB_VFS_INTERFACE_VERSION,
+ "lttng",
+ &vfs_lttng_fns);
}
-
--
2.17.2
From d93984002d3b48545a05ef172df65dcd967c68f0 Mon Sep 17 00:00:00 2001
From: Dongmao Zhang <deanraccoon at gmail.com>
Date: Tue, 25 Dec 2018 11:23:41 +0800
Subject: [PATCH 3/3] Add man page for vfs_lttng module
Signed-off-by: Dongmao Zhang <deanraccoon at gmail.com>
---
docs-xml/manpages/vfs_lttng.8.xml | 123 ++++++++++++++++++++++++++++++
1 file changed, 123 insertions(+)
create mode 100644 docs-xml/manpages/vfs_lttng.8.xml
diff --git a/docs-xml/manpages/vfs_lttng.8.xml b/docs-xml/manpages/vfs_lttng.8.xml
new file mode 100644
index 00000000000..2f6f00aabfe
--- /dev/null
+++ b/docs-xml/manpages/vfs_lttng.8.xml
@@ -0,0 +1,123 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE refentry PUBLIC "-//Samba-Team//DTD DocBook V4.2-Based Variant V1.0//EN" "http://www.samba.org/samba/DTD/samba-doc">
+<refentry id="vfs_lttng.8">
+
+<refmeta>
+ <refentrytitle>vfs_lttng</refentrytitle>
+ <manvolnum>8</manvolnum>
+ <refmiscinfo class="source">Samba</refmiscinfo>
+ <refmiscinfo class="manual">System Administration tools</refmiscinfo>
+ <refmiscinfo class="version">&doc.version;</refmiscinfo>
+</refmeta>
+
+
+<refnamediv>
+ <refname>vfs_lttng</refname>
+ <refpurpose>samba module to enable LTTng tracing for samba</refpurpose>
+</refnamediv>
+
+<refsynopsisdiv>
+ <cmdsynopsis>
+ <command>vfs objects = lttng</command>
+ </cmdsynopsis>
+</refsynopsisdiv>
+
+<refsect1>
+ <title>DESCRIPTION</title>
+
+ <para>This VFS module is part of the
+ <citerefentry><refentrytitle>samba</refentrytitle>
+ <manvolnum>7</manvolnum></citerefentry> suite.</para>
+
+ <para>The LTTng VFS module enable tracepoint on every vfs functions
+ such as connect_fn, readdir_fn.
+ </para>
+
+ <para>It's kind of comparable with <command>strace -T</command> and
+ is helpful to reveal performance problems with the underlying file
+ and storage subsystems.</para>
+
+ <para>This module is stackable.</para>
+
+</refsect1>
+
+<refsect1>
+ <title>OPTIONS</title>
+ <variablelist>
+ <varlistentry>
+ <term>vfs objects = lttng</term>
+ <listitem>
+ <para>Enalbe lttng module </para>
+ </listitem>
+ </varlistentry>
+ </variablelist>
+</refsect1>
+
+<refsect1>
+ <title>EXAMPLE</title>
+
+ <para>Setup <command>vfs objects = lttng</command> in /etc/samba/smb.conf.
+ </para>
+
+ <para>
+ 1. Run smbd like this:
+ </para>
+ <para>
+ <command>LD_PRELOAD=/usr/lib64/liblttng-ust-fork.so.0 /usr/sbin/smbd --foreground --no-process-group</command>
+ </para>
+
+ <para>
+ 2. Start a new LTTng session:
+ </para>
+
+ <para>
+ <command>lttng create</command>
+ </para>
+
+ <para>
+ <command>lttng enable-event -u vfs_lttng:*</command>
+ </para>
+
+ <para>
+ <command>lttng start</command>
+ </para>
+
+ <para>
+ 3. Run some performance test. And then stop the LTTng test
+ </para>
+
+ <para>
+ <command> lttng stop </command>
+ </para>
+
+ <para>
+ <command> lttng destroy </command>
+ </para>
+
+ <para>
+ 4. Use babeltrace or some other tools(https://lttng.org) to checkout the result
+ </para>
+
+</refsect1>
+
+
+<refsect1>
+ <title>VERSION</title>
+ <para>This man page is part of version &doc.version; of the Samba suite.
+ </para>
+</refsect1>
+
+<refsect1>
+ <title>AUTHOR</title>
+
+ <para>The original Samba software and related utilities
+ were created by Andrew Tridgell. Samba is now developed
+ by the Samba Team as an Open Source project similar
+ to the way the Linux kernel is developed.</para>
+
+ <para>The LTTng VFS module was created with contributions from
+ Dongmao Zhang
+ </para>
+</refsect1>
+
+</refentry>
--
2.17.2
More information about the samba-technical
mailing list