Kernel Debugging & Profiling
8 likes18,877 views
The document discusses various tools and techniques for kernel debugging, profiling, and testing in Linux. It covers topics like kernel debugging tools, crash dumping and analysis, kernel probes, tracing, profiling, and testing possibilities in Linux like the Linux Test Project and User Mode Linux.
1 of 14
![8© 2010-16 SysPlay Workshops <workshop@sysplay.in>
All Rights Reserved.
Miscellaneous Tools & Techniques
Early Init Debugs
CONFIG_SERIAL_EARLYCON
CONFIG_EARLY_PRINTK (direct on h/w)
Light & Sound
JTAG
Hardware Protocol Debug
Hardware Protocol Analyzers
Network Debugging
Driver level: ethtool [options] <dev i/f>
Packet level: tcpdump [options, e.g. -vv] -i <dev i/f>](https://image.slidesharecdn.com/debuggingnprofiling-100621152100-phpapp01/85/Kernel-Debugging-Profiling-8-320.jpg)
![10© 2010-16 SysPlay Workshops <workshop@sysplay.in>
All Rights Reserved.
Tracing
Single Process Tracing using strace
Traces the system calls made by an application
Command: strace [options] <application>
Excellent options to tune to get only desired output
Linux Trace Toolkit
Patch @ http://www.opersys.com/LTT
Core Module
Code using Trace Services
Daemon: tracedaemon
Utilities: tracereader, tracevisualizer
Function Tracer
CONFIG_FUNCTION_TRACER & co
/sys/kernel/debug/tracing](https://image.slidesharecdn.com/debuggingnprofiling-100621152100-phpapp01/85/Kernel-Debugging-Profiling-10-320.jpg)
Recommended
Linux device drivers 
Linux device drivers Emertxe Information Technologies Pvt Ltd This course gets you started with writing device drivers in Linux by providing real time hardware exposure. Equip you with real-time tools, debugging techniques and industry usage in a hands-on manner. Dedicated hardware by Emertxe's device driver learning kit. Special focus on character and USB device drivers.
Spi drivers
Spi driverspradeep_tewani Embitude's Linux SPI Drivers Training Slides. Contains the details of AM335X specific low level programming, SPI components such as SPI Master Driver, SPI Client Driver, Device Tree for SPI
System Calls
System CallsAnil Kumar Pugalia The document discusses system calls in Linux. It defines system calls as service points for user programs to request services from the kernel. It describes how system calls provide an abstracted hardware interface, ensure security and stability, and make process management easier. The document contrasts system calls with library functions, noting that system calls execute in kernel space with special privileges while library functions are ordinary user space functions. It also covers how system calls are implemented and executed via wrappers and describes tracing system calls using strace.
Arm device tree and linux device drivers
Arm device tree and linux device driversHoucheng Lin This document discusses how the Linux kernel supports different ARM boards using a common source code base. It describes how device tree is used to describe hardware in a board-agnostic way. The kernel initializes machine-specific code via the device tree and initializes drivers by matching compatible strings. This allows a single kernel binary to support multiple boards by abstracting low-level hardware details into the device tree rather than the kernel source. The document also contrasts the ARM approach to the x86 approach, where BIOS abstraction and standardized buses allow one kernel to support most x86 hardware.
ACPI Debugging from Linux Kernel
ACPI Debugging from Linux KernelSUSE Labs Taipei This document discusses debugging the ACPI subsystem in the Linux kernel. It provides an overview of the ACPI subsystem and components like ACPICA and the namespace. It describes how to enable ACPI debug logging via the acpi.debug_layer and acpi.debug_level kernel parameters. It also covers overriding ACPI definition blocks tables and tracing ACPI temperature as a debugging case study.
Yocto - Embedded Linux Distribution Maker
Yocto - Embedded Linux Distribution MakerSherif Mousa Yocto is an Embedded Linux distribution maker.
This presentation is a quick start guide for Yocto buildsystem to get familiar with the tool and how to start building your own custom Linux system for a specific hardware target.
Linux Initialization Process (1)
Linux Initialization Process (1)shimosawa The document provides an overview of the initialization phase of the Linux kernel. It discusses how the kernel enables paging to transition from physical to virtual memory addresses. It then describes the various initialization functions that are called by start_kernel to initialize kernel features and architecture-specific code. Some key initialization tasks discussed include creating an identity page table, clearing BSS, and reserving BIOS memory.
Embedded Linux on ARM
Embedded Linux on ARMEmertxe Information Technologies Pvt Ltd An unique module combining various previous modules you have learnt by combing Linux administration, Hardware knowledge, Linux as OS, C/Computer programming areas. This is a complete module on Embedded OS, as of now no books are written on this with such practical aspects. Here is a consolidated material to get real hands-on perspective about building custom Embedded Linux distribution in ARM.
I2c drivers
I2c driverspradeep_tewani Linux I2C Drivers Slide. Covers the complete details of I2C drivers in Linux including the components such as I2C client driver and I2C Adapter driver
Linux Ethernet device driver
Linux Ethernet device driver艾鍗科技 The document discusses Ethernet device drivers in Linux. It describes the driver architecture, Ethernet packet format, driver development process, and important data structures like net_device and sk_buff. It provides examples of initializing a driver, probing hardware, uploading/downloading data using callbacks, interrupt handling, and buffer management. The key steps are registering the driver, allocating network devices, setting callbacks, and using sk_buff objects to transfer packets between layers.
Linux Kernel Booting Process (1) - For NLKB
Linux Kernel Booting Process (1) - For NLKBshimosawa Describes the bootstrapping part in Linux and some related technologies.
This is the part one of the slides, and the succeeding slides will contain the errata for this slide.
Introduction to yocto
Introduction to yoctoAlex Gonzalez This document provides an overview and agenda for a presentation on Yocto, an open source project for embedded Linux development. It discusses Yocto components, layers, recipes, classes, and the build system. It also outlines how Yocto can be used by both system developers and application developers.
Bootloaders
BootloadersAnil Kumar Pugalia This document discusses bootloaders, specifically the Universal Boot Loader (U-Boot). It provides an overview of bootloader concepts, U-Boot specifics, the U-Boot initialization sequence, how U-Boot passes arguments to the kernel, hands-on with U-Boot commands, the U-Boot source code structure, configuring and compiling U-Boot for a board, and porting U-Boot to support a new board.
Linux PCI device driver
Linux PCI device driver艾鍗科技 it's just a part of...
See more http://www.ittraining.com.tw/ittraining/index.php/course/embedded/embeddedlinux
Embedded Linux Kernel - Build your custom kernel
Embedded Linux Kernel - Build your custom kernelEmertxe Information Technologies Pvt Ltd Build your own Embedded Linux Kernel by understanding it source code organization, compilation ecosystem and compiling it for a custom target.
Block Drivers
Block DriversAnil Kumar Pugalia The document discusses block drivers in Linux. It covers the need for the block layer, decoding block devices, writing a block driver, driver registration, block device operations, and request queues. Key aspects covered include registering a block device driver, implementing required functions like open and close, managing request queues and processing I/O requests to read from and write to the device. An example RAM disk driver is presented to demonstrate writing a basic block driver.
Yocto Project introduction
Yocto Project introductionYi-Hsiu Hsu The document provides an introduction to the Yocto Project, including what it is, its main components, and workflow. It describes the Yocto Project as being comprised of Poky (the build system), tools, and upstreams. Poky contains BitBake (the build engine) and metadata (task configurations and definitions). It outlines the main components, including sub-projects, and compares the Yocto Project to OpenEmbedded. Finally, it summarizes the Yocto Project workflow, which involves configuring the build using recipes and layers then building packages, images, and cross-development toolchains.
Platform Drivers
Platform DriversSysPlay eLearning Academy for You This document discusses platform device drivers in Linux. It describes the components of platform device drivers, including platform drivers and platform devices. It explains how to register a platform driver, register a platform device, bind a driver to a device, specify platform resources and data. It also discusses using device tree bindings with platform drivers and summarizes the key topics covered.
Linux Internals - Kernel/Core
Linux Internals - Kernel/CoreShay Cohen The document provides an overview of the Linux kernel architecture and processes. It discusses key kernel concepts like the monolithic kernel design, system calls, loadable modules, virtual memory, and preemptive multitasking. It also covers kernel functions, layers, and context switching between processes. The CPU scheduler, multi-threading, inter-process communication techniques, and tunable kernel parameters are summarized as well.
I2C Drivers
I2C DriversSysPlay eLearning Academy for You The document discusses Inter-Integrated Circuit (I2C) drivers in Linux. It covers I2C protocol basics like start/stop conditions and transactions. It then describes the I2C subsystem in Linux including I2C adapter, client and core drivers. It also discusses registering I2C devices without and with device tree, and provides examples of I2C client drivers.
Linux Initialization Process (2)
Linux Initialization Process (2)shimosawa The document provides an overview of the initialization process in the Linux kernel from start_kernel to rest_init. It lists the functions called during this process organized by category including functions for initialization of multiprocessor support (SMP), memory management (MM), scheduling, timers, interrupts, and architecture specific setup. The setup_arch section focuses on x86 architecture specific initialization functions such as reserving memory regions, parsing boot parameters, initializing memory mapping and MTRRs.
Toolchain
ToolchainAnil Kumar Pugalia The document discusses toolchains and cross toolchains. It defines a toolchain as a collection of tools including a C compiler, C libraries, and binary utilities. A cross toolchain is a toolchain configured to compile code for a platform other than the one on which the toolchain is running. The document outlines steps for building a cross toolchain, including obtaining kernel headers, building binary utilities, compilers, and libraries. It also discusses automated build tools like Crosstool and testing the generated cross toolchain.
U boot-boot-flow
U boot-boot-flowBabuSubashChandar Chandra Mohan My talk on U-Boot boot sequence in terms of the various function calls from POR to booting the operating system.
Linux Network Stack
Linux Network StackAdrien Mahieux - The document discusses Linux network stack monitoring and configuration. It begins with definitions of key concepts like RSS, RPS, RFS, LRO, GRO, DCA, XDP and BPF.
- It then provides an overview of how the network stack works from the hardware interrupts and driver level up through routing, TCP/IP and to the socket level.
- Monitoring tools like ethtool, ftrace and /proc/interrupts are described for viewing hardware statistics, software stack traces and interrupt information.
Embedded Linux BSP Training (Intro)
Embedded Linux BSP Training (Intro)RuggedBoardGroup Have a quick overview of most of the embedded linux components and their details. How ti build Embedded Linux Hardware & Software, and developing Embedded Products
Bootloaders (U-Boot) 
Bootloaders (U-Boot) Omkar Rane This document discusses bootloaders for embedded systems. It defines a bootloader as the first code executed after a system powers on or resets that is responsible for loading the operating system kernel. The document then describes the tasks of a bootloader like initializing hardware, loading binaries from storage, and providing a shell. It outlines the booting process differences between desktops and embedded systems. Finally, it focuses on the universal bootloader U-Boot, describing its directory structure, configuration, building process, and commands.
Qnx os 
Qnx os Student QNX is a real-time operating system developed by QNX Software Systems. It is based on the Neutrino microkernel. QNX is used in industrial, network, telecommunications, medical, and automotive devices where predictable and reliable performance is critical. Some key applications of QNX include power grids, emergency response systems, vehicle infotainment systems, traffic control, and industrial automation.
Introduction Linux Device Drivers
Introduction Linux Device DriversNEEVEE Technologies This document provides an overview of Linux device drivers. It discusses what a device driver is, the Linux driver architecture, different driver classes like character and block drivers, kernel modules, driver initialization and cleanup functions, compiling and loading modules, module parameters, differences between modules and applications, and key concepts like major/minor numbers and file operations.
References
ReferencesAnil Kumar Pugalia This document provides references and resources for learning about embedded Linux, Linux drivers, Linux internals, general Linux topics, debuggers and profilers. It lists books, documentation, slides, manuals and websites that contain useful information. It also provides contact information for the workshop organizer.
gcc and friends
gcc and friendsAnil Kumar Pugalia The document discusses the GNU C Compiler (gcc) which is an open source compiler for C and C++. It describes what gcc is, its internals including different stages like preprocessing, compilation and linking. It also covers how to use gcc via various flags, standard paths for headers and libraries, default compiler defines, and related tools like the assembler, linker and archiver.
More Related Content
What's hot (20)
I2c drivers
I2c driverspradeep_tewani Linux I2C Drivers Slide. Covers the complete details of I2C drivers in Linux including the components such as I2C client driver and I2C Adapter driver
Linux Ethernet device driver
Linux Ethernet device driver艾鍗科技 The document discusses Ethernet device drivers in Linux. It describes the driver architecture, Ethernet packet format, driver development process, and important data structures like net_device and sk_buff. It provides examples of initializing a driver, probing hardware, uploading/downloading data using callbacks, interrupt handling, and buffer management. The key steps are registering the driver, allocating network devices, setting callbacks, and using sk_buff objects to transfer packets between layers.
Linux Kernel Booting Process (1) - For NLKB
Linux Kernel Booting Process (1) - For NLKBshimosawa Describes the bootstrapping part in Linux and some related technologies.
This is the part one of the slides, and the succeeding slides will contain the errata for this slide.
Introduction to yocto
Introduction to yoctoAlex Gonzalez This document provides an overview and agenda for a presentation on Yocto, an open source project for embedded Linux development. It discusses Yocto components, layers, recipes, classes, and the build system. It also outlines how Yocto can be used by both system developers and application developers.
Bootloaders
BootloadersAnil Kumar Pugalia This document discusses bootloaders, specifically the Universal Boot Loader (U-Boot). It provides an overview of bootloader concepts, U-Boot specifics, the U-Boot initialization sequence, how U-Boot passes arguments to the kernel, hands-on with U-Boot commands, the U-Boot source code structure, configuring and compiling U-Boot for a board, and porting U-Boot to support a new board.
Linux PCI device driver
Linux PCI device driver艾鍗科技 it's just a part of...
See more http://www.ittraining.com.tw/ittraining/index.php/course/embedded/embeddedlinux
Embedded Linux Kernel - Build your custom kernel
Embedded Linux Kernel - Build your custom kernelEmertxe Information Technologies Pvt Ltd Build your own Embedded Linux Kernel by understanding it source code organization, compilation ecosystem and compiling it for a custom target.
Block Drivers
Block DriversAnil Kumar Pugalia The document discusses block drivers in Linux. It covers the need for the block layer, decoding block devices, writing a block driver, driver registration, block device operations, and request queues. Key aspects covered include registering a block device driver, implementing required functions like open and close, managing request queues and processing I/O requests to read from and write to the device. An example RAM disk driver is presented to demonstrate writing a basic block driver.
Yocto Project introduction
Yocto Project introductionYi-Hsiu Hsu The document provides an introduction to the Yocto Project, including what it is, its main components, and workflow. It describes the Yocto Project as being comprised of Poky (the build system), tools, and upstreams. Poky contains BitBake (the build engine) and metadata (task configurations and definitions). It outlines the main components, including sub-projects, and compares the Yocto Project to OpenEmbedded. Finally, it summarizes the Yocto Project workflow, which involves configuring the build using recipes and layers then building packages, images, and cross-development toolchains.
Platform Drivers
Platform DriversSysPlay eLearning Academy for You This document discusses platform device drivers in Linux. It describes the components of platform device drivers, including platform drivers and platform devices. It explains how to register a platform driver, register a platform device, bind a driver to a device, specify platform resources and data. It also discusses using device tree bindings with platform drivers and summarizes the key topics covered.
Linux Internals - Kernel/Core
Linux Internals - Kernel/CoreShay Cohen The document provides an overview of the Linux kernel architecture and processes. It discusses key kernel concepts like the monolithic kernel design, system calls, loadable modules, virtual memory, and preemptive multitasking. It also covers kernel functions, layers, and context switching between processes. The CPU scheduler, multi-threading, inter-process communication techniques, and tunable kernel parameters are summarized as well.
I2C Drivers
I2C DriversSysPlay eLearning Academy for You The document discusses Inter-Integrated Circuit (I2C) drivers in Linux. It covers I2C protocol basics like start/stop conditions and transactions. It then describes the I2C subsystem in Linux including I2C adapter, client and core drivers. It also discusses registering I2C devices without and with device tree, and provides examples of I2C client drivers.
Linux Initialization Process (2)
Linux Initialization Process (2)shimosawa The document provides an overview of the initialization process in the Linux kernel from start_kernel to rest_init. It lists the functions called during this process organized by category including functions for initialization of multiprocessor support (SMP), memory management (MM), scheduling, timers, interrupts, and architecture specific setup. The setup_arch section focuses on x86 architecture specific initialization functions such as reserving memory regions, parsing boot parameters, initializing memory mapping and MTRRs.
Toolchain
ToolchainAnil Kumar Pugalia The document discusses toolchains and cross toolchains. It defines a toolchain as a collection of tools including a C compiler, C libraries, and binary utilities. A cross toolchain is a toolchain configured to compile code for a platform other than the one on which the toolchain is running. The document outlines steps for building a cross toolchain, including obtaining kernel headers, building binary utilities, compilers, and libraries. It also discusses automated build tools like Crosstool and testing the generated cross toolchain.
U boot-boot-flow
U boot-boot-flowBabuSubashChandar Chandra Mohan My talk on U-Boot boot sequence in terms of the various function calls from POR to booting the operating system.
Linux Network Stack
Linux Network StackAdrien Mahieux - The document discusses Linux network stack monitoring and configuration. It begins with definitions of key concepts like RSS, RPS, RFS, LRO, GRO, DCA, XDP and BPF.
- It then provides an overview of how the network stack works from the hardware interrupts and driver level up through routing, TCP/IP and to the socket level.
- Monitoring tools like ethtool, ftrace and /proc/interrupts are described for viewing hardware statistics, software stack traces and interrupt information.
Embedded Linux BSP Training (Intro)
Embedded Linux BSP Training (Intro)RuggedBoardGroup Have a quick overview of most of the embedded linux components and their details. How ti build Embedded Linux Hardware & Software, and developing Embedded Products
Bootloaders (U-Boot)
Bootloaders (U-Boot) Omkar Rane This document discusses bootloaders for embedded systems. It defines a bootloader as the first code executed after a system powers on or resets that is responsible for loading the operating system kernel. The document then describes the tasks of a bootloader like initializing hardware, loading binaries from storage, and providing a shell. It outlines the booting process differences between desktops and embedded systems. Finally, it focuses on the universal bootloader U-Boot, describing its directory structure, configuration, building process, and commands.
Qnx os
Qnx os Student QNX is a real-time operating system developed by QNX Software Systems. It is based on the Neutrino microkernel. QNX is used in industrial, network, telecommunications, medical, and automotive devices where predictable and reliable performance is critical. Some key applications of QNX include power grids, emergency response systems, vehicle infotainment systems, traffic control, and industrial automation.
Introduction Linux Device Drivers
Introduction Linux Device DriversNEEVEE Technologies This document provides an overview of Linux device drivers. It discusses what a device driver is, the Linux driver architecture, different driver classes like character and block drivers, kernel modules, driver initialization and cleanup functions, compiling and loading modules, module parameters, differences between modules and applications, and key concepts like major/minor numbers and file operations.
Viewers also liked (16)
References
ReferencesAnil Kumar Pugalia This document provides references and resources for learning about embedded Linux, Linux drivers, Linux internals, general Linux topics, debuggers and profilers. It lists books, documentation, slides, manuals and websites that contain useful information. It also provides contact information for the workshop organizer.
gcc and friends
gcc and friendsAnil Kumar Pugalia The document discusses the GNU C Compiler (gcc) which is an open source compiler for C and C++. It describes what gcc is, its internals including different stages like preprocessing, compilation and linking. It also covers how to use gcc via various flags, standard paths for headers and libraries, default compiler defines, and related tools like the assembler, linker and archiver.
Embedded C
Embedded CAnil Kumar Pugalia This document discusses an embedded C workshop that will cover topics such as pointers, hardware programming, compiler optimizations, register programming techniques, and bit operations. The workshop will de-jargonify pointers using 7 rules and cover arrays, static versus dynamic allocation, and 2D arrays. It will also explain embedded C specifics like cross-compilation, architecture options, and bare-metal programming without libraries or frameworks.
Introduction to Linux Drivers
Introduction to Linux DriversAnil Kumar Pugalia This document provides an introduction to Linux drivers. It discusses the ecosystem of Linux drivers, types of Linux drivers, driver layering, related commands and configurations. It also guides the reader in creating their first Linux driver, covering basics like the module constructor, destructor, printk function and building the driver module.
Network Drivers
Network DriversAnil Kumar Pugalia The document discusses Linux network drivers and provides information about:
- The Linux network subsystem and protocol stack, typically using TCP/IP.
- Network interface card (NIC) drivers which provide a uniform interface for the network layer to access physical network cards.
- Key data structures like struct sk_buff and struct net_device that network drivers interact with for packet handling and device operations.
- Functions for network device registration, open/close, interrupt handling, and flow control.
- Examples of simple network drivers and how to write one for a Realtek NIC.
File System Modules
File System ModulesAnil Kumar Pugalia The document discusses file systems at three levels - hardware, kernel, and user space. It explains that a file system organizes data on storage devices (hardware level), provides drivers to access the data (kernel level), and presents a unified view to users through the root file system (/). It also summarizes key points about why file systems are needed, the relationships between partitions, file systems, and the root file system, and how to write a basic file system module that interacts with the virtual file system (VFS) in the kernel.
Serial Drivers
Serial DriversSysPlay eLearning Academy for You The document discusses Linux serial drivers. It describes the UART protocol which converts parallel CPU data to serial data. It outlines the TTY driver subsystem and how the TTY driver interfaces with UART drivers, line disciplines and user processes. It also details the key data structures and APIs used by UART and TTY drivers, including the uart_driver, uart_port and uart_ops structures used by UART drivers and tty_driver used by TTY drivers.
PCI Drivers
PCI DriversAnil Kumar Pugalia This document discusses the Peripheral Component Interconnect (PCI) driver subsystem in Linux. It covers PCI architecture basics, the kernel PCI subsystem, registering PCI drivers, probing PCI devices, accessing PCI configuration and I/O spaces, handling DMA, and provides code examples and APIs for writing PCI device drivers.
Interrupts
InterruptsAnil Kumar Pugalia The document discusses interrupts in Linux systems. It defines interrupts as interventions that allow devices to get the CPU's attention when there is a mismatch between device and CPU speeds. It describes how interrupts work through interrupt lines, an interrupt controller, and registered interrupt handlers. It covers interrupt request numbers, programming interfaces for requesting and freeing interrupts, the responsibilities of interrupt handlers, and additional features like message signaled interrupts and soft interrupts, which are used to break up interrupt handling work.
SPI Drivers
SPI DriversSysPlay eLearning Academy for You The document discusses the Serial Peripheral Interface (SPI) driver framework in Linux. It describes the SPI protocol and components of the SPI framework, including the SPI master driver, SPI device driver, and SPI client drivers. It explains how the SPI core layer implements SPI bus transactions and how SPI client drivers interface with SPI devices to perform operations like reading and writing.
USB Drivers
USB DriversAnil Kumar Pugalia The document discusses USB drivers and provides an overview of USB host and gadget subsystems in Linux. It describes USB host and gadget device driver types, registration processes, data structures used, and key functions for interacting with USB controllers, the USB core, and endpoints. The document outlines views of the USB host and gadget subsystems and how drivers interface with lower-level USB controller drivers and higher-level user applications through the USB core.
BeagleBone Black Bootloaders
BeagleBone Black BootloadersSysPlay eLearning Academy for You The document discusses the bootloaders for the BeagleBone Black system. It describes the memory organization and booting process, including the roles of the X-Loader and U-Boot bootloaders. The X-Loader is described as the first stage bootloader that is derived from U-Boot and runs in internal SRAM. It loads the second stage U-Boot bootloader. U-Boot is then described as the universal bootloader that can be ported to different boards with minimal changes and is responsible for loading the Linux kernel from external DDR memory.
Linux Porting
Linux PortingAnil Kumar Pugalia The document discusses Linux porting and Linux support packages (LSPs). It covers the basics of Linux porting, including the 5 W's of porting and 5 M's of an operating system. It describes the architecture and components of LSPs, including placement in the kernel tree and design/layout rules. It also discusses the connections between LSPs and board bringup.
BeagleBoard-xM Bootloaders
BeagleBoard-xM BootloadersSysPlay eLearning Academy for You The document discusses the bootloaders for the BeagleBoard-xM. It describes the boot sequence which starts from the internal ROM and proceeds through the X-Loader and then U-Boot bootloaders. The X-Loader is the first stage bootloader that runs in internal SRAM and loads the second stage U-Boot bootloader. It then provides details on the workings and board support packages of both X-Loader and U-Boot.
Character Drivers
Character DriversAnil Kumar Pugalia This document discusses character drivers in Linux. It covers the basics of character drivers including what they represent ("character" refers to devices that transfer data as a stream of bytes), major and minor numbers which identify devices, registering and unregistering drivers, implementing file operations like read and write, and using the Linux device model to dynamically create and manage devices with udev. The document provides code examples and explains key concepts like the file structures and I/O control interfaces that device drivers use to interface with the kernel and userspace.
File Systems
File SystemsAnil Kumar Pugalia The document discusses file systems for embedded systems. It explains that an embedded system needs a root file system to store operating system data and optional user data. The root file system can be built by creating directories, adding binaries like BusyBox, and libraries. Root file systems can be transferred via initramfs, NFS, or read-only filesystem images like squashfs. Different filesystem types can be used depending on storage needs and characteristics.
Similar to Kernel Debugging & Profiling (20)
Kernel Debugging & Profiling
Kernel Debugging & ProfilingAnil Kumar Pugalia The document discusses various tools and techniques for kernel debugging, profiling, and testing in Linux. It covers topics like kernel debugging using printk and syslog, querying kernel state via /proc and sysfs, crash dumping and analysis, tools like kprobes, kernel tracing with LTT and perf, profiling with oprofile and gcov, and testing frameworks like LTP and User Mode Linux.
Linux User Space Debugging & Profiling
Linux User Space Debugging & ProfilingAnil Kumar Pugalia The document discusses various debugging and profiling techniques for C programs, focusing on the use of the gdb debugger to debug programs by setting breakpoints, examining data and stack frames, and the use of profiling tools like gprof and gcov to analyze program performance and code coverage.
Solaris Kernel Debugging V1.0
Solaris Kernel Debugging V1.0Jarod Wang This document provides an overview of kernel debugging on Solaris systems using the modular debugger Mdb and dynamic tracing framework DTrace. It discusses debugging live kernels with Mdb, analyzing system crash dumps with Mdb, and using DTrace to monitor the kernel at runtime by enabling probes published by different providers. The document outlines the key tools, techniques, and challenges involved in kernel debugging and crash analysis on Solaris.
Linux Kernel Debugging
Linux Kernel DebuggingGlobalLogic Ukraine The presentation deals with the set of tools and features that can be used by Linux kernel developers for kernel debugging. Also, static analysis of kernel patches was addressed during speech. Special attention was given to access tools, tracing tools, and interactive debugging tools, namely: DebugFS, ftrace, and GDB.
This presentation by Aleksandr Bulyshchenko (Software Engineer, Consultant, GlobalLogic Kharkiv) was delivered at GlobalLogic Kharkiv Embedded TechTalk #1 on March 13, 2018.
Sysdig
Sysdiggnosek Sysdig is a new dynamic tracer for Linux, inspired by strace, dtrace, and tcpdump. Very useful as a super fast strace replacement and systemwide performance/security/etc. diagnostics.
Performance Analysis Tools for Linux Kernel
Performance Analysis Tools for Linux Kernellcplcp1 Perf is a collection of Linux kernel tools for performance monitoring and profiling. It provides sampling and profiling of the system to analyze performance bottlenecks. Perf supports hardware events from the CPU performance counters, software events from the kernel, and tracepoint events from the kernel and loaded modules. It offers tools like perf record to sample events and store them, perf report to analyze stored samples, and perf trace to trace system events in real-time.
Debug generic process
Debug generic processVipin Varghese This document discusses various Linux debugging tools including:
1. SIMD, cache monitoring, firmware checks, NUMA memory, interrupts using tools like lstopo, ethtool, lspci, and lshw.
2. Using GDB for debugging with features like breakpoints, disassembly, and core file generation.
3. Tools like strace, ltrace, nm, objdump, and readelf for system call tracing, library call tracing, symbol tables, and object file analysis.
4. Techniques like LD_PRELOAD, ulimit, and perf for custom debugging and performance analysis.
Project ACRN system debug
Project ACRN system debugProject ACRN This document provides an overview of debugging tools and capabilities for the ACRN hypervisor. It discusses the ACRN hypervisor log (hvlog) and trace tools, as well as logging and debugging options for the Service OS (SOS Linux) including kernel logs, user space loggers, and gdb. Debugging options for User OSs (UOSs) are also covered, which depend on the specific UOS. Finally, some miscellaneous debugging tools are mentioned like platform tracing and JTAG tools.
Mobile Hacking using Linux Drivers
Mobile Hacking using Linux DriversAnil Kumar Pugalia The document discusses mobile hacking through Linux drivers. It outlines the objectives of usual Linux kernel hacking techniques and tools for reverse engineering. It describes the hacking architecture with the user space providing an interface and the kernel space providing functionality. It then discusses various aspects of kernel space such as process management, memory management, and the kernel driver ecosystem.
Introduction to Linux
Introduction to LinuxAnil Kumar Pugalia The document provides an introduction to Linux, including an overview of operating systems and open source software. It discusses the fundamentals of Linux, including the kernel subsystems, OS services, and applications. It also covers Linux usage basics such as root and system directories, shell and file commands, user management, permissions, and input/output redirection. The goal is to introduce students to the key concepts of Linux and prepare them to use Linux systems.
Linux Internals Part - 3
Linux Internals Part - 3SysPlay eLearning Academy for You The document discusses debugging programs in Linux using the GNU debugger (GDB). It covers how to compile programs with debugging symbols, launch GDB, set breakpoints, examine variables and memory, step through code, and use other GDB commands like backtrace. Debugging strategies like narrowing down issues are also presented. The document also briefly covers building statically linked modules, makefiles, and inter-process communication mechanisms like pipes, FIFOs, shared memory, and semaphores.
Introduction to Linux
Introduction to LinuxAnil Kumar Pugalia This document provides an introduction to Linux, including definitions of open source software and its advantages. It discusses the Linux system overview consisting of the kernel, OS services, and applications. It also covers Linux usage basics such as directories, shells, files, users, permissions, and input/output redirection. The document is intended to explain what topics will be covered in an introduction to Linux workshop.
Linux Kernel Overview
Linux Kernel OverviewAnil Kumar Pugalia The document provides an overview of the Linux kernel, including its architecture, startup process, functionality, configuration, and compilation. It discusses the differences between micro and monolithic kernels. It also explains the Linux kernel architecture with user space and kernel space separated by a system call interface. Key aspects covered include process management, memory management, device management, and the kernel build system.
ELC-E Linux Awareness
ELC-E Linux AwarenessPeter Griffin This document discusses improving debugging of the Linux kernel using the open source debugger GDB. It begins with an overview of existing ways to debug the kernel using GDB, including via KGDB, Qemu, and JTAG probes like OpenOCD. It then discusses the concept of adding "Linux awareness" to GDB, which would allow it to better understand kernel concepts like threads and modules. Finally, it outlines three approaches to implementing this awareness: via a GDB scripting extension, in the GDB stub, or with a C extension to GDB. The overall goal is to make GDB a more full-featured and useful tool for kernel debugging.
Forensic artifacts in modern linux systems
Forensic artifacts in modern linux systemsGol D Roger This document provides an overview of a workshop on forensic artifacts in modern Linux systems. It will cover topics such as partitions and filesystems, boot loaders, the Linux file system layout, systemd configuration for services and scheduled tasks, installed software and packages, log files and the systemd journal. The workshop format will involve both presentations and demonstrations of analyzing disk images and artifacts. It is aimed at forensic investigators and showing what can be discovered from compromised, criminal, or seized Linux systems.
Linux kernel debugging
Linux kernel debugginglibfetion This document discusses Linux kernel debugging. It provides an overview of debugging techniques including collecting system information, handling failures, and using printk(), KGDB, and debuggers. Key points covered are the components of a debugger, how KGDB can be used with gdb to debug interactively, analyzing crash data, and some debugging tricks and print functions.
LAS16-403: GDB Linux Kernel Awareness
LAS16-403: GDB Linux Kernel AwarenessLinaro LAS16-403: GDB Linux Kernel Awareness
Speakers: Peter Griffin
Date: September 29, 2016
★ Session Description ★
The presentation will look at the ways in which GDB can be enhanced when debugging the Linux kernel to give it better knowledge of the underlying operating system to enable a better debugging experience. It will also provide a status of the current work being undertaken in this area by the ST landing team, a demo and potential future work.
★ Resources ★
Etherpad: pad.linaro.org/p/las16-403
Presentations & Videos: http://connect.linaro.org/resource/las16/las16-403/
★ Event Details ★
Linaro Connect Las Vegas 2016 – #LAS16
September 26-30, 2016
http://www.linaro.org
http://connect.linaro.org
LAS16-403 - GDB Linux Kernel Awareness 
LAS16-403 - GDB Linux Kernel Awareness Peter Griffin The document discusses extending the GNU Debugger (GDB) to provide better Linux kernel debugging capabilities by adding "Linux awareness" features, including providing information about running tasks, loaded modules, and OS helper commands, and it describes the work by the ST Landing Team and Linaro Toolchain Working Group to upstream these extensions from the ST Linux Kernel Debugger (LKD) plugin into GDB.
Linux kernel bug hunting
Linux kernel bug huntingAndrea Righi Debugging is an essential part of the Linux kernel development, but without the proper knowledge it can be quite challenging. In this talk, we will cover some techniques that will help you to study how the kernel works “under the hood”. We will see how to crash the kernel in many spectacular ways, how to analyze the crashes and how to hunt down new bugs, fix them and become a better kernel developer.
More from Anil Kumar Pugalia (20)
File System Modules
File System ModulesAnil Kumar Pugalia The document discusses various aspects of file systems, including:
- It defines file systems as having three levels - the physical storage organization, kernel-level drivers, and the user-level view.
- It describes the three types of file systems - hardware/storage, kernel-level, and user-level file systems. It also discusses how they relate and the role of the mount function.
- It provides examples of designing a simple file system layout and implementing it using data structures like inodes and block pointers.
Processes
ProcessesAnil Kumar Pugalia This document discusses processes in Linux operating systems. It covers the basics of what a process is, why processes are needed to achieve multi-processing, and how processes are scheduled and managed in Linux. Key topics covered include the process life cycle and state transitions, process control blocks (PCBs), process creation using fork and exec system calls, and process termination and waiting. The document also discusses process-related system calls like wait, waitpid, and techniques for avoiding orphan processes and zombies.
Embedded Software Design
Embedded Software DesignAnil Kumar Pugalia This document discusses various aspects of embedded software design including functionality design and programming, designing for fault tolerance, hardware-aware design and programming, designing and programming for performance, and designing for maintainability. Some key points discussed are top-down functional design, designing for uninterrupted execution and crash recovery, programming for hardware specifics, optimizing for performance through techniques like reducing system calls and buffer caching, and including debugging logs and remote update mechanisms to improve maintainability.
Playing with R L C Circuits
Playing with R L C CircuitsAnil Kumar Pugalia The document discusses building a function generator and oscilloscope to experiment with RLC circuits. It explains RLC basics like impedance and phase shifts. The RC circuit is analyzed in detail, showing the voltage and current relationships. Predictions are made for different RC combinations. Code for generating sine waves with a microcontroller is provided. Finally, frequency filters using RC circuits are discussed.
Audio Drivers
Audio DriversAnil Kumar Pugalia The document discusses Linux audio drivers. It introduces the Linux audio subsystem, including the ALSA sound core in kernel space and its interfaces for user space applications. It describes the vertical components like the sound core and horizontal components like audio codec and controller drivers. It also covers porting an audio driver, which may involve changing pin assignments for standard codecs or implementing new codec drivers.
Video Drivers
Video DriversAnil Kumar Pugalia The document discusses Linux video drivers and frameworks. It describes the original frame buffer and console interfaces. It then summarizes the Video For Linux v2 (v4l2) framework, which defines structures like the "Video Device" and mechanisms for video buffer and control management. The v4l2 framework aims to provide a complete and integrated solution for working with video and audio devices.
Shell Scripting
Shell ScriptingAnil Kumar Pugalia This document outlines the topics to be covered in a shell scripting workshop, including shells and shell scripting, Bash commands and scripting, Linux commands, file permissions, input/output redirection, regular expressions, automation, and testing. It provides an overview of shells like Bash, Bourne shell, and C shell. It also describes various Linux directories and files, file commands, user commands, and help commands.
Functional Programming with LISP
Functional Programming with LISPAnil Kumar Pugalia This document provides an introduction to the Lisp programming language. It discusses Lisp's origins and design, current implementations, why it was conceived, its core data structures and operations, control structures, recursion features, input/output functions, and loading/compiling files. Examples are provided to demonstrate various language concepts like recursion, set operations, and functional programming with lists.
Power of vi
Power of viAnil Kumar Pugalia The document discusses the text editor vi. It describes vi's origins as one of the earliest line editors and its improvements in vim. It outlines vi's modes and operations like cut, delete, replace. The document encourages readers to use vimtutor to learn vi's commands and patterns. It also mentions vi's ability to perform complex tasks like programming through recording.
"make" system
"make" systemAnil Kumar Pugalia This document discusses the make tool and its usage. Make is used to automatically execute commands based on file dependencies in order to rebuild programs and packages. It is configured using makefiles which specify rules and dependencies between targets. Makefiles allow rebuilding portions of a program automatically when source files change. Examples are provided to demonstrate basic makefile rules and usage of make for compiling C programs.
Hardware Design for Software Hackers
Hardware Design for Software HackersAnil Kumar Pugalia Hacking should be both with hardware & software, not just anyone. But why? This was the presentation used to answer it.
RPM Building
RPM BuildingAnil Kumar Pugalia The document discusses RPM building including setting up a build system, writing RPM spec files, building RPM packages, and testing RPMs. It covers creating directories for sources, binaries, and building; writing spec files with sections for package preparation, compilation, installation, and more; and using rpmbuild and rpmlint to build and test RPMs.
Linux Network Management
Linux Network ManagementAnil Kumar Pugalia This document discusses Linux network management and socket programming. It covers topics like the network stack and sockets, addressing at different layers, socket programming APIs, client-server concepts and examples. Some key points covered include the seven layer OSI model, TCP and UDP sockets, functions for socket creation, connection establishment, data sending and receiving, and closing sockets. Non-blocking I/O and system calls like select and poll are also discussed.
System Calls
System CallsAnil Kumar Pugalia This document discusses system calls in Linux. It defines system calls as service points for user programs to request services from the kernel. There are about 300 system calls in Linux, listed in /usr/include/asm/unistd.h. A system call executes in kernel space unlike a library function, and involves packaging arguments, transferring control to the kernel via a trap, and returning control back with a return value. The strace command can be used to trace system calls made by a program. Hands-on examples are provided to demonstrate system calls versus library functions.
Timers
TimersAnil Kumar Pugalia This document discusses different types of timers that can be used in user space processes, including trivial timers based on the SIGALRM signal and interval timers based on signals like SIGVTALRM. Interval timers can be set using system calls like setitimer and allow triggering timers periodically at microsecond resolution. More advanced POSIX timer functions like timer_settime are also introduced that provide more flexibility in creating additional interval timers using other signals.
Threads
ThreadsAnil Kumar Pugalia This document discusses threads and threading in Linux. It begins with an overview of threads, their similarities and differences to processes, and how they are implemented in Linux using the Native POSIX Threads Library (NPTL). It then covers key pthreads APIs for thread management, including thread creation, termination, joining threads, attributes, cancellation, and thread-specific data. The document provides code examples to demonstrate the use of various pthreads functions.
Synchronization
SynchronizationAnil Kumar Pugalia This document discusses thread synchronization and concurrency in multithreaded programs. It covers various synchronization mechanisms like mutexes, condition variables, read/write locks, spin locks, barriers and semaphores. It also discusses issues like priority inversion, deadlocks, and their solutions. Finally, it talks about inter-thread communication techniques and provides examples to demonstrate the use of these synchronization primitives and communication methods.
Processes
ProcessesAnil Kumar Pugalia The document discusses processes in Linux operating systems. It defines what a process is, including that a process includes the program code, variables, stack, heap, registers, and other OS resources needed by the program. It describes why processes are needed to achieve multi-processing and timesharing. It discusses process states, scheduling, and preemption in Linux. It provides examples of commands to view and manage processes like ps and top. It also covers process creation using fork(), exec(), and programming processes in Linux.
Signals
SignalsAnil Kumar Pugalia Signals provide an asynchronous communication mechanism between processes in Linux. They are specified by numbers and can be sent and handled via functions like kill, signal, and sigaction. Common signals originate from the kernel on illegal operations or from other processes. Signal handlers are registered to handle signals and should perform minimal work. Upon exit, processes return an exit code indicating normal or abnormal termination.
Linux Memory Management
Linux Memory ManagementAnil Kumar Pugalia Linux uses memory management to partition memory between kernel and application spaces, organize memory using virtual addresses, and swap memory between primary and secondary storage. It divides memory using paging into equal-sized pages, creates virtual address spaces, and uses an MMU to translate between virtual and physical addresses. This allows processes to run independently with their own logical view of memory while the physical memory is shared.
Recently uploaded (20)
Offshore IT Support: Balancing In-House and Offshore Help Desk Technicians
Offshore IT Support: Balancing In-House and Offshore Help Desk Techniciansjohn823664 In today's always-on digital environment, businesses must deliver seamless IT support across time zones, devices, and departments. This SlideShare explores how companies can strategically combine in-house expertise with offshore talent to build a high-performing, cost-efficient help desk operation.
From the benefits and challenges of offshore support to practical models for integrating global teams, this presentation offers insights, real-world examples, and key metrics for success. Whether you're scaling a startup or optimizing enterprise support, discover how to balance cost, quality, and responsiveness with a hybrid IT support strategy.
Perfect for IT managers, operations leads, and business owners considering global help desk solutions.
Master tester AI toolbox - Kari Kakkonen at Testaus ja AI 2025 Professio
Master tester AI toolbox - Kari Kakkonen at Testaus ja AI 2025 ProfessioKari Kakkonen My slides at Professio Testaus ja AI 2025 seminar in Espoo, Finland.
Deck in English, even though I talked in Finnish this time, in addition to chairing the event.
I discuss the different motivations for testing to use AI tools to help in testing, and give several examples in each categories, some open source, some commercial.
UiPath Community Zurich: Release Management and Build Pipelines
UiPath Community Zurich: Release Management and Build PipelinesUiPathCommunity Ensuring robust, reliable, and repeatable delivery processes is more critical than ever - it's a success factor for your automations and for automation programmes as a whole. In this session, we’ll dive into modern best practices for release management and explore how tools like the UiPathCLI can streamline your CI/CD pipelines. Whether you’re just starting with automation or scaling enterprise-grade deployments, our event promises to deliver helpful insights to you. This topic is relevant for both on-premise and cloud users - as well as for automation developers and software testers alike.
📕 Agenda:
- Best Practices for Release Management
- What it is and why it matters
- UiPath Build Pipelines Deep Dive
- Exploring CI/CD workflows, the UiPathCLI and showcasing scenarios for both on-premise and cloud
- Discussion, Q&A
👨🏫 Speakers
Roman Tobler, CEO@ Routinuum
Johans Brink, CTO@ MvR Digital Workforce
We look forward to bringing best practices and showcasing build pipelines to you - and to having interesting discussions on this important topic!
If you have any questions or inputs prior to the event, don't hesitate to reach out to us.
This event streamed live on May 27, 16:00 pm CET.
Check out all our upcoming UiPath Community sessions at:
👉 https://community.uipath.com/events/
Join UiPath Community Zurich chapter:
👉 https://community.uipath.com/zurich/
Marko.js - Unsung Hero of Scalable Web Frameworks (DevDays 2025)
Marko.js - Unsung Hero of Scalable Web Frameworks (DevDays 2025)Eugene Fidelin Marko.js is an open-source JavaScript framework created by eBay back in 2014. It offers super-efficient server-side rendering, making it ideal for big e-commerce sites and other multi-page apps where speed and SEO really matter. After over 10 years of development, Marko has some standout features that make it an interesting choice. In this talk, I’ll dive into these unique features and showcase some of Marko's innovative solutions. You might not use Marko.js at your company, but there’s still a lot you can learn from it to bring to your next project.
A Comprehensive Guide on Integrating Monoova Payment Gateway
A Comprehensive Guide on Integrating Monoova Payment Gatewaydanielle hunter Monoova is a merchant-centric platform with integrations for payments, marketing, loyalty programs, and customer insights.
New Ways to Reduce Database Costs with ScyllaDB
New Ways to Reduce Database Costs with ScyllaDBScyllaDB How ScyllaDB’s latest capabilities can reduce your infrastructure costs
ScyllaDB has been obsessed with price-performance from day 1. Our core database is architected with low-level engineering optimizations that squeeze every ounce of power from the underlying infrastructure. And we just completed a multi-year effort to introduce a set of new capabilities for additional savings.
Join this webinar to learn about these new capabilities: the underlying challenges we wanted to address, the workloads that will benefit most from each, and how to get started. We’ll cover ways to:
- Avoid overprovisioning with “just-in-time” scaling
- Safely operate at up to ~90% storage utilization
- Cut network costs with new compression strategies and file-based streaming
We’ll also highlight a “hidden gem” capability that lets you safely balance multiple workloads in a single cluster. To conclude, we will share the efficiency-focused capabilities on our short-term and long-term roadmaps.
Fully Open-Source Private Clouds: Freedom, Security, and Control
Fully Open-Source Private Clouds: Freedom, Security, and ControlShapeBlue In this presentation, Swen Brüseke introduced proIO's strategy for 100% open-source driven private clouds. proIO leverage the proven technologies of CloudStack and LINBIT, complemented by professional maintenance contracts, to provide you with a secure, flexible, and high-performance IT infrastructure. He highlighted the advantages of private clouds compared to public cloud offerings and explain why CloudStack is in many cases a superior solution to Proxmox.
--
The CloudStack European User Group 2025 took place on May 8th in Vienna, Austria. The event once again brought together open-source cloud professionals, contributors, developers, and users for a day of deep technical insights, knowledge sharing, and community connection.
Content and eLearning Standards: Finding the Best Fit for Your-Training
Content and eLearning Standards: Finding the Best Fit for Your-TrainingRustici Software Tammy Rutherford, Managing Director of Rustici Software, walks through the pros and cons of different standards to better understand which standard is best for your content and chosen technologies.
Cyber Security Legal Framework in Nepal.pptx
Cyber Security Legal Framework in Nepal.pptxGhimire B.R. The presentation is about the review of existing legal framework on Cyber Security in Nepal. The strength and weakness highlights of the major acts and policies so far. Further it highlights the needs of data protection act .
TrustArc Webinar: Mastering Privacy Contracting
TrustArc Webinar: Mastering Privacy ContractingTrustArc As data privacy regulations become more pervasive across the globe and organizations increasingly handle and transfer (including across borders) meaningful volumes of personal and confidential information, the need for robust contracts to be in place is more important than ever.
This webinar will provide a deep dive into privacy contracting, covering essential terms and concepts, negotiation strategies, and key practices for managing data privacy risks.
Whether you're in legal, privacy, security, compliance, GRC, procurement, or otherwise, this session will include actionable insights and practical strategies to help you enhance your agreements, reduce risk, and enable your business to move fast while protecting itself.
This webinar will review key aspects and considerations in privacy contracting, including:
- Data processing addenda, cross-border transfer terms including EU Model Clauses/Standard Contractual Clauses, etc.
- Certain legally-required provisions (as well as how to ensure compliance with those provisions)
- Negotiation tactics and common issues
- Recent lessons from recent regulatory actions and disputes
Multistream in SIP and NoSIP @ OpenSIPS Summit 2025
Multistream in SIP and NoSIP @ OpenSIPS Summit 2025Lorenzo Miniero Slides for my "Multistream support in the Janus SIP and NoSIP plugins" presentation at the OpenSIPS Summit 2025 event.
They describe my efforts refactoring the Janus SIP and NoSIP plugins to allow for the gatewaying of an arbitrary number of audio/video streams per call (thus breaking the current 1-audio/1-video limitation), plus some additional considerations on what this could mean when dealing with application protocols negotiated via SIP as well.
Contributing to WordPress With & Without Code.pptx
Contributing to WordPress With & Without Code.pptxPatrick Lumumba Contributing to WordPress: Making an Impact on the Test Team—With or Without Coding Skills
WordPress survives on collaboration, and the Test Team plays a very important role in ensuring the CMS is stable, user-friendly, and accessible to everyone.
This talk aims to deconstruct the myth that one has to be a developer to contribute to WordPress. In this session, I will share with the audience how to get involved with the WordPress Team, whether a coder or not.
We’ll explore practical ways to contribute, from testing new features, and patches, to reporting bugs. By the end of this talk, the audience will have the tools and confidence to make a meaningful impact on WordPress—no matter the skill set.
Dr Jimmy Schwarzkopf presentation on the SUMMIT 2025 A
Dr Jimmy Schwarzkopf presentation on the SUMMIT 2025 ADr. Jimmy Schwarzkopf Introduction and Background:
Study Overview and Methodology: The study analyzes the IT market in Israel, covering over 160 markets and 760 companies/products/services. It includes vendor rankings, IT budgets, and trends from 2025-2029. Vendors participate in detailed briefings and surveys.
Vendor Listings: The presentation lists numerous vendors across various pages, detailing their names and services. These vendors are ranked based on their participation and market presence.
Market Insights and Trends: Key insights include IT market forecasts, economic factors affecting IT budgets, and the impact of AI on enterprise IT. The study highlights the importance of AI integration and the concept of creative destruction.
Agentic AI and Future Predictions: Agentic AI is expected to transform human-agent collaboration, with AI systems understanding context and orchestrating complex processes. Future predictions include AI's role in shopping and enterprise IT.
Agentic AI - The New Era of Intelligence
Agentic AI - The New Era of IntelligenceMuzammil Shah This presentation is specifically designed to introduce final-year university students to the foundational principles of Agentic Artificial Intelligence (AI). It aims to provide a clear understanding of how Agentic AI systems function, their key components, and the underlying technologies that empower them. By exploring real-world applications and emerging trends, the session will equip students with essential knowledge to engage with this rapidly evolving area of AI, preparing them for further study or professional work in the field.
Maxx nft market place new generation nft marketing place
Maxx nft market place new generation nft marketing placeusersalmanrazdelhi PREFACE OF MAXXNFT
MaxxNFT: Powering the Future of Digital Ownership
MaxxNFT is a cutting-edge Web3 platform designed to revolutionize how
digital assets are owned, traded, and valued. Positioned at the forefront of the
NFT movement, MaxxNFT views NFTs not just as collectibles, but as the next
generation of internet equity—unique, verifiable digital assets that unlock new
possibilities for creators, investors, and everyday users alike.
Through strategic integrations with OKT Chain and OKX Web3, MaxxNFT
enables seamless cross-chain NFT trading, improved liquidity, and enhanced
user accessibility. These collaborations make it easier than ever to participate
in the NFT ecosystem while expanding the platform’s global reach.
With a focus on innovation, user rewards, and inclusive financial growth,
MaxxNFT offers multiple income streams—from referral bonuses to liquidity
incentives—creating a vibrant community-driven economy. Whether you
'
re
minting your first NFT or building a digital asset portfolio, MaxxNFT empowers
you to participate in the future of decentralized value exchange.
https://maxxnft.xyz/
Cyber security cyber security cyber security cyber security cyber security cy...
Cyber security cyber security cyber security cyber security cyber security cy...pranavbodhak Cyber security
Protecting Your Sensitive Data with Microsoft Purview - IRMS 2025
Protecting Your Sensitive Data with Microsoft Purview - IRMS 2025Nikki Chapple Session | Protecting Your Sensitive Data with Microsoft Purview: Practical Information Protection and DLP Strategies
Presenter | Nikki Chapple (MVP| Principal Cloud Architect CloudWay) & Ryan John Murphy (Microsoft)
Event | IRMS Conference 2025
Format | Birmingham UK
Date | 18-20 May 2025
In this closing keynote session from the IRMS Conference 2025, Nikki Chapple and Ryan John Murphy deliver a compelling and practical guide to data protection, compliance, and information governance using Microsoft Purview. As organizations generate over 2 billion pieces of content daily in Microsoft 365, the need for robust data classification, sensitivity labeling, and Data Loss Prevention (DLP) has never been more urgent.
This session addresses the growing challenge of managing unstructured data, with 73% of sensitive content remaining undiscovered and unclassified. Using a mountaineering metaphor, the speakers introduce the “Secure by Default” blueprint—a four-phase maturity model designed to help organizations scale their data security journey with confidence, clarity, and control.
🔐 Key Topics and Microsoft 365 Security Features Covered:
Microsoft Purview Information Protection and DLP
Sensitivity labels, auto-labeling, and adaptive protection
Data discovery, classification, and content labeling
DLP for both labeled and unlabeled content
SharePoint Advanced Management for workspace governance
Microsoft 365 compliance center best practices
Real-world case study: reducing 42 sensitivity labels to 4 parent labels
Empowering users through training, change management, and adoption strategies
🧭 The Secure by Default Path – Microsoft Purview Maturity Model:
Foundational – Apply default sensitivity labels at content creation; train users to manage exceptions; implement DLP for labeled content.
Managed – Focus on crown jewel data; use client-side auto-labeling; apply DLP to unlabeled content; enable adaptive protection.
Optimized – Auto-label historical content; simulate and test policies; use advanced classifiers to identify sensitive data at scale.
Strategic – Conduct operational reviews; identify new labeling scenarios; implement workspace governance using SharePoint Advanced Management.
🎒 Top Takeaways for Information Management Professionals:
Start secure. Stay protected. Expand with purpose.
Simplify your sensitivity label taxonomy for better adoption.
Train your users—they are your first line of defense.
Don’t wait for perfection—start small and iterate fast.
Align your data protection strategy with business goals and regulatory requirements.
💡 Who Should Watch This Presentation?
This session is ideal for compliance officers, IT administrators, records managers, data protection officers (DPOs), security architects, and Microsoft 365 governance leads. Whether you're in the public sector, financial services, healthcare, or education.
🔗 Read the blog: https://nikkichapple.com/irms-conference-2025/
Agentic AI Explained: The Next Frontier of Autonomous Intelligence & Generati...
Agentic AI Explained: The Next Frontier of Autonomous Intelligence & Generati...Aaryan Kansari Agentic AI Explained: The Next Frontier of Autonomous Intelligence & Generative AI
Discover Agentic AI, the revolutionary step beyond reactive generative AI. Learn how these autonomous systems can reason, plan, execute, and adapt to achieve human-defined goals, acting as digital co-workers. Explore its promise, key frameworks like LangChain and AutoGen, and the challenges in designing reliable and safe AI agents for future workflows.
Sticky Note Bullets:
Definition: Next stage beyond ChatGPT-like systems, offering true autonomy.
Core Function: Can "reason, plan, execute and adapt" independently.
Distinction: Proactive (sets own actions for goals) vs. Reactive (responds to prompts).
Promise: Acts as "digital co-workers," handling grunt work like research, drafting, bug fixing.
Industry Outlook: Seen as a game-changer; Deloitte predicts 50% of companies using GenAI will have agentic AI pilots by 2027.
Key Frameworks: LangChain, Microsoft's AutoGen, LangGraph, CrewAI.
Development Focus: Learning to think in workflows and goals, not just model outputs.
Challenges: Ensuring reliability, safety; agents can still hallucinate or go astray.
Best Practices: Start small, iterate, add memory, keep humans in the loop for final decisions.
Use Cases: Limited only by imagination (e.g., drafting business plans, complex simulations).
STKI Israel Market Study 2025 final v1 version
STKI Israel Market Study 2025 final v1 versionDr. Jimmy Schwarzkopf nnual (33 years) study of the Israeli Enterprise / public IT market. Covering sections on Israeli Economy, IT trends 2026-28, several surveys (AI, CDOs, OCIO, CTO, staffing cyber, operations and infra) plus rankings of 760 vendors on 160 markets (market sizes and trends) and comparison of products according to support and market penetration.
Kernel Debugging & Profiling
- 1. © 2010-16 SysPlay Workshops <[email protected]> All Rights Reserved. Kernel Debugging & Profiling
- 2. 2© 2010-16 SysPlay Workshops <[email protected]> All Rights Reserved. What to Expect? Kernel Debugging Tools & Techniques Kernel Profiling Tools & Mechanism Kernel Testing Ways
- 3. 3© 2010-16 SysPlay Workshops <[email protected]> All Rights Reserved. Debugging by Printing printk & dmesg int klogctl(int cmd, char *bufp, int len); syslogd #include <syslog.h> void openlog(char *ident, int option, int facility); void syslog ( int priority, char *format, …); void closelog( void ); ident – typically short program name option - LOG_CONS, LOG_PERROR, LOG_PID, … facility - LOG_AUTHPRIV, LOG_CRON, LOG_DAEMON, LOG_USER, ... priority - LOG_EMERG, LOG_ALERT, LOG_CRIT, LOG_ERR, LOG_WARNING, LOG_NOTICE, LOG_INFO, LOG_DEBUG klogd – bridge between kernel ring buffer and syslogd
- 4. 4© 2010-16 SysPlay Workshops <[email protected]> All Rights Reserved. Debugging by Querying Through Kernel Windows /proc Process related stuff General system information: cpuinfo, meminfo, … Drivers related info: devices, iomem, interrupts, ... /sys (Utilities: sysfsutils, sysdiag) Buses, Classes, Devices, ... Using ioctl Through specific drivers Using custom commands
- 5. 5© 2010-16 SysPlay Workshops <[email protected]> All Rights Reserved. Crash Dumping & Analysis Oops Analysis CONFIG_BUG, CONFIG_KALLSYMS Call Trace cat /proc/kallsyms objdump -d | -S <obj | exe> Crash Dumping (using 2 kernel images – could be same) System Kernel: CONFIG_KEXEC, CONFIG_DEBUG_INFO Dump-capture Kernel: CONFIG_CRASH_DUMP, CONFIG_PROC_VMCORE, Other Architecture specific CONFIG_s Boot System Kernel with crashkernel=size@offset, or crashkernel=range:size Overlay Dump-capture Kernel using kexec After Crash (Simulated using SysRq+c, Or real) System reboots w/ Dump-capture Kernel Collect the dump using kdump, Or simply cp /proc/vmcore <dump file> Analyse using <gdb | crash> vmlinux <dump file>
- 6. 6© 2010-16 SysPlay Workshops <[email protected]> All Rights Reserved. Kernel Hacking Related Options CONFIG_DEBUG_INFO (gcc -g) CONFIG_DEBUG_FS CONFIG_DYNAMIC_DEBUG CONFIG_DEBUG_STACKOVERFLOW CONFIG_LOCKUP_DETECTOR CONFIG_DEBUG_SPINLOCK, CONFIG_DEBUG_MUTEXES, ... CONFIG_MAGIC_SYSRQ CONFIG_EARLY_PRINTK CONFIG_DEBUG_SLAB, CONFIG_DEBUG_VM, ... CONFIG_DEBUG_STACK_USAGE CONFIG_PANIC_ON_OOPS CONFIG_PANIC_ON_OOPS_VALUE
- 7. 7© 2010-16 SysPlay Workshops <[email protected]> All Rights Reserved. Kernel Debuggers Kernel Debugger (Frontend): kdb CONFIG_DEBUG_INFO, CONFIG_MAGIC_SYSRQ CONFIG_KGDB, CONFIG_KGDB_KDB, CONFIG_KGDB_SERIAL_CONSOLE Basic Operations over Serial Console Remote Debugging using kgdb (Kernel Debug Server) Remote connection & debug through gdb vmlinux gdb <kernel src>/vmlinux /proc/kcore Only to gather current kernel debug information
- 8. 8© 2010-16 SysPlay Workshops <[email protected]> All Rights Reserved. Miscellaneous Tools & Techniques Early Init Debugs CONFIG_SERIAL_EARLYCON CONFIG_EARLY_PRINTK (direct on h/w) Light & Sound JTAG Hardware Protocol Debug Hardware Protocol Analyzers Network Debugging Driver level: ethtool [options] <dev i/f> Packet level: tcpdump [options, e.g. -vv] -i <dev i/f>
- 9. 9© 2010-16 SysPlay Workshops <[email protected]> All Rights Reserved. Kernel Probes kprobes → CONFIG_KPROBES jprobes → Specialized Kprobes For probing function entry points kretprobes → Return Kprobes For probing function exit points
- 10. 10© 2010-16 SysPlay Workshops <[email protected]> All Rights Reserved. Tracing Single Process Tracing using strace Traces the system calls made by an application Command: strace [options] <application> Excellent options to tune to get only desired output Linux Trace Toolkit Patch @ http://www.opersys.com/LTT Core Module Code using Trace Services Daemon: tracedaemon Utilities: tracereader, tracevisualizer Function Tracer CONFIG_FUNCTION_TRACER & co /sys/kernel/debug/tracing
- 11. 11© 2010-16 SysPlay Workshops <[email protected]> All Rights Reserved. Profiling & Code Coverage System Profiling From /proc using LTTng Kernel Profiling: Oprofile CONFIG_PROFILING, CONFIG_OPROFILE, CONFIG_APIC Daemon: oprofiled Utilities: opcontrol, opreport, op_help, ... Kernel Performance Profiling using perf CONFIG_PERF_EVENTS & co stat, list, top, record, report, ... Kernel Code Coverage: CONFIG_GCOV_KERNEL, CONFIG_GCOV_PROFILE_ALL
- 12. 12© 2010-16 SysPlay Workshops <[email protected]> All Rights Reserved. Testing Possibilities Linux Test Project (LTP) Hosted @ http://ltp.sourceforge.net Suite of around 3000 tests Exercises various parts of the Kernel Mostly automated, except net & storage ones Command: runltp -p -l logfile User Mode Linux (UML) Hosted @ http://user-mode-linux.sourceforge.net A Kernel Instance as a User Mode Process Kernel Debugging without “oops”ing Good for testing & experimenting with unstable kernels
- 13. 13© 2010-16 SysPlay Workshops <[email protected]> All Rights Reserved. What all have we learnt? Kernel Debugging Tools & Techniques Debugging by Printing & Querying Crash Dumping & Analysis Kernel Hacking Options Kernel Debuggers Miscellaneous Tools & Techniques Kernel Probes Tracing Kernel Profiling Tools & Mechanism Kernel Testing Ways
- 14. 14© 2010-16 SysPlay Workshops <[email protected]> All Rights Reserved. Any Queries?