Warn and return on fd overflow fdt

[lttng-modules.git] / src / lttng-statedump-impl.c

diff --git a/src/lttng-statedump-impl.c b/src/lttng-statedump-impl.c
index 95032f87a2db4f2cefa0a4bcf31a9b61c41ccb48..5ea790f59a1d26e2e889766a54a439f454203d83 100644 (file)
--- a/src/lttng-statedump-impl.c
+++ b/src/lttng-statedump-impl.c
@@ -36,13 +36,12 @@
 
 #include <lttng/events.h>
 #include <lttng/tracer.h>
 
 #include <lttng/events.h>
 #include <lttng/tracer.h>

+#include <lttng/events-internal.h>

 #include <wrapper/cpu.h>
 #include <wrapper/irqdesc.h>
 #include <wrapper/fdtable.h>
 #include <wrapper/cpu.h>
 #include <wrapper/irqdesc.h>
 #include <wrapper/fdtable.h>

-#include <wrapper/namespace.h>

 #include <wrapper/tracepoint.h>
 #include <wrapper/blkdev.h>
 #include <wrapper/tracepoint.h>
 #include <wrapper/blkdev.h>

-#include <wrapper/fdtable.h>

 #include <wrapper/sched.h>
 
 /* Define the tracepoints, but do not build the probes */
 #include <wrapper/sched.h>
 
 /* Define the tracepoints, but do not build the probes */


@@ -192,7 +191,8 @@ enum lttng_process_status {
 };
 
 
 };
 
 

-#if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(6,0,0))
+#if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(6,0,0) || \
+    LTTNG_RHEL_KERNEL_RANGE(5,14,0,163,0,0, 5,15,0,0,0,0))

 
 #define LTTNG_PART_STRUCT_TYPE struct block_device
 
 
 #define LTTNG_PART_STRUCT_TYPE struct block_device
 


@@ -386,6 +386,20 @@ void lttng_enumerate_device(struct lttng_kernel_session *session,
        }
 }
 
        }
 }
 

+#if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(6,9,0))
+static
+int lttng_enumerate_network_ip_interface(struct lttng_kernel_session *session)
+{
+       struct net_device *dev;
+
+       rtnl_lock();
+       for_each_netdev(&init_net, dev)
+               lttng_enumerate_device(session, dev);
+       rtnl_unlock();
+
+       return 0;
+}
+#else

 static
 int lttng_enumerate_network_ip_interface(struct lttng_kernel_session *session)
 {
 static
 int lttng_enumerate_network_ip_interface(struct lttng_kernel_session *session)
 {


@@ -398,6 +412,7 @@ int lttng_enumerate_network_ip_interface(struct lttng_kernel_session *session)
 
        return 0;
 }
 
        return 0;
 }

+#endif /* (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(6,9,0)) */

 #else /* CONFIG_INET */
 static inline
 int lttng_enumerate_network_ip_interface(struct lttng_kernel_session *session)
 #else /* CONFIG_INET */
 static inline
 int lttng_enumerate_network_ip_interface(struct lttng_kernel_session *session)


@@ -420,17 +435,22 @@ int lttng_dump_one_fd(const void *p, struct file *file, unsigned int fd)
         */
        flags &= ~FMODE_NONOTIFY;
        fdt = files_fdtable(ctx->files);
         */
        flags &= ~FMODE_NONOTIFY;
        fdt = files_fdtable(ctx->files);

+

        /*
        /*

-        * We need to check here again whether fd is within the fdt
-        * max_fds range, because we might be seeing a different
-        * files_fdtable() than iterate_fd(), assuming only RCU is
-        * protecting the read. In reality, iterate_fd() holds
-        * file_lock, which should ensure the fdt does not change while
-        * the lock is taken, but we are not aware whether this is
-        * guaranteed or not, so play safe.
+        * The fdt should only grow and iterate_fd() holds file_lock, which
+        * should ensure the fdt does not change while the lock is taken but be
+        * cautious and check anyway.

         */
         */

-       if (fd < fdt->max_fds && lttng_close_on_exec(fd, fdt))
+       if (WARN_ON_ONCE(fd >= fdt->max_fds))
+               return 0;
+
+       if (lttng_close_on_exec(fd, ctx->files))

                flags |= O_CLOEXEC;
                flags |= O_CLOEXEC;

+
+       /*
+        * If d_path() failed to get a full path for the file, use the dentry
+        * name instead to at least get a filename.
+        */

        if (IS_ERR(s)) {
                struct dentry *dentry = file->f_path.dentry;
 
        if (IS_ERR(s)) {
                struct dentry *dentry = file->f_path.dentry;
 


@@ -456,7 +476,7 @@ void lttng_enumerate_files(struct lttng_kernel_session *session,
 {
        struct lttng_fd_ctx ctx = { .page = tmp, .session = session, .files = files, };
 
 {
        struct lttng_fd_ctx ctx = { .page = tmp, .session = session, .files = files, };
 

-       lttng_iterate_fd(files, 0, lttng_dump_one_fd, &ctx);
+       iterate_fd(files, 0, lttng_dump_one_fd, &ctx);

 }
 
 #ifdef LTTNG_HAVE_STATEDUMP_CPU_TOPOLOGY
 }
 
 #ifdef LTTNG_HAVE_STATEDUMP_CPU_TOPOLOGY


@@ -599,24 +619,11 @@ void lttng_statedump_process_ns(struct lttng_kernel_session *session,
                 * paranoid behavior of
                 * trace_lttng_statedump_process_user_ns().
                 */
                 * paranoid behavior of
                 * trace_lttng_statedump_process_user_ns().
                 */

-               user_ns = user_ns ? user_ns->lttng_user_ns_parent : NULL;
+               user_ns = user_ns ? user_ns->parent : NULL;

        } while (user_ns);
 
        } while (user_ns);
 

-       /*
-        * Back and forth on locking strategy within Linux upstream for nsproxy.
-        * See Linux upstream commit 728dba3a39c66b3d8ac889ddbe38b5b1c264aec3
-        * "namespaces: Use task_lock and not rcu to protect nsproxy"
-        * for details.
-        */
-#if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(3,17,0) || \
-               LTTNG_UBUNTU_KERNEL_RANGE(3,13,11,36, 3,14,0,0) || \
-               LTTNG_UBUNTU_KERNEL_RANGE(3,16,1,11, 3,17,0,0) || \
-               LTTNG_RHEL_KERNEL_RANGE(3,10,0,229,13,0, 3,11,0,0,0,0))

        proxy = p->nsproxy;
        proxy = p->nsproxy;

-#else
-       rcu_read_lock();
-       proxy = task_nsproxy(p);
-#endif
+

        if (proxy) {
 #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,6,0))
                trace_lttng_statedump_process_cgroup_ns(session, p, proxy->cgroup_ns);
        if (proxy) {
 #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,6,0))
                trace_lttng_statedump_process_cgroup_ns(session, p, proxy->cgroup_ns);


@@ -632,14 +639,6 @@ void lttng_statedump_process_ns(struct lttng_kernel_session *session,
                trace_lttng_statedump_process_time_ns(session, p, proxy->time_ns);
 #endif
        }
                trace_lttng_statedump_process_time_ns(session, p, proxy->time_ns);
 #endif
        }

-#if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(3,17,0) || \
-               LTTNG_UBUNTU_KERNEL_RANGE(3,13,11,36, 3,14,0,0) || \
-               LTTNG_UBUNTU_KERNEL_RANGE(3,16,1,11, 3,17,0,0) || \
-               LTTNG_RHEL_KERNEL_RANGE(3,10,0,229,13,0, 3,11,0,0,0,0))
-       /* (nothing) */
-#else
-       rcu_read_unlock();
-#endif

 }
 
 static
 }
 
 static


@@ -806,13 +805,6 @@ EXPORT_SYMBOL_GPL(lttng_statedump_start);
 static
 int __init lttng_statedump_init(void)
 {
 static
 int __init lttng_statedump_init(void)
 {

-       /*
-        * Allow module to load even if the fixup cannot be done. This
-        * will allow seemless transition when the underlying issue fix
-        * is merged into the Linux kernel, and when tracepoint.c
-        * "tracepoint_module_notify" is turned into a static function.
-        */
-       (void) wrapper_lttng_fixup_sig(THIS_MODULE);

        return 0;
 }
 
        return 0;
 }