This article explains why Linux imposes resource limits, shows how to inspect user‑level limits with ulimit, demonstrates practical experiments to increase file‑descriptor and stack limits via /etc/security/limits.conf, and outlines system‑wide constraints and tools like prlimit for robust server programming.
This article explains how infrared remote controls work, details the NEC protocol timing and encoding, and walks through the Linux kernel driver implementation—including GPIO‑IR receiver code, NEC decoder logic, device‑tree configuration, and key‑event reporting—providing a complete technical guide for developers.
This step‑by‑step guide shows how to install Ruby, add the Scout_Realtime gem, start its daemon, configure firewall access, view real‑time metrics in a web browser, and manage logs, stopping or uninstalling the tool on Linux servers.
This article provides a comprehensive tutorial on installing UCloud's free USDP version for private big‑data deployments, covering environment preparation, minimum node specifications, resource download, configuration files, one‑click initialization scripts, server startup, web UI access, license acquisition, and optional manual setup procedures.
This guide walks you through practical steps to secure a Linux server, covering SSH configuration changes, disabling ping replies, managing users and groups, protecting critical files, creating new accounts, and safely granting root privileges.
This comprehensive guide walks you through selecting a secure Linux distribution, configuring kernel and sysctl parameters, applying boot‑time hardening, managing network and firewall rules, restricting root access, enabling MAC policies, sandboxing applications, and employing advanced memory and entropy techniques to dramatically improve system privacy and resilience against attacks.
This guide walks you through installing the GeoIP2 dependencies, adding the ngx_http_geoip2 module to NGINX, upgrading NGINX, downloading the latest GeoIP2 database, configuring NGINX to block non‑Chinese IPs, and verifying the setup with test requests.
This guide explains how to use the Linux date command together with mkdir or touch to automatically generate directories or files whose names reflect the current date or time, providing handy shortcuts for log management and other automation tasks.
This guide explains how to automate Linux tasks by configuring boot‑time services with chkconfig and rc.local, using the at command for one‑off jobs, and setting up recurring jobs with crontab, complete with syntax, examples, and practical shell script integration.
This article explains the Linux PM QoS framework, detailing its background, system‑ and device‑level constraints, core data structures, key API functions, and a practical example of limiting CPU‑DMA latency for power‑efficient device operation.
This article explains why Docker containers often stop right after starting, covering the role of PID 1, daemon‑off mode, Linux process management concepts like zombie and orphan processes, and how Docker’s containerd‑shim and runC interact to keep containers alive.
vmalloc allocates virtual memory by mapping non‑contiguous physical pages into a contiguous virtual address range, using vmap_area and vm_struct structures, and follows a three‑step process of finding a hole, allocating pages, and establishing the mappings, with details on its data structures and region layout.
This guide introduces a free PowerShell wrapper for rsync that enables seamless file synchronization between Windows and Linux machines, detailing script features, system requirements, download links, and usage examples for both directions of transfer.
The article outlines why high‑load Go services need performance tuning and presents a systematic workflow—preparation, analysis with Linux tools and Go’s pprof/trace, targeted optimizations such as goroutine pooling, Redis MSET, efficient JSON handling and slice resizing—demonstrating how these changes boost throughput, lower latency, and stabilize memory usage while offering broader Go‑specific best‑practice recommendations.
This article provides a deep, step‑by‑step analysis of how Linux 3.10 processes a send() call—from user‑space socket handling through TCP, IP routing, queueing, driver DMA mapping, and both hard and soft interrupt handling—answering why CPU time appears in sy/si, why NET_RX softirqs dominate, and what memory copies occur during transmission.
This article introduces the Linux `time` command, explains its basic usage and output fields (real, user, sys), distinguishes between shell built‑in and GNU versions, demonstrates advanced options such as custom formatting, file output, and shows how to interpret the metrics for performance analysis.
This guide explains what Base64 encoding is, why it’s needed for transmitting binary data as text, and provides step‑by‑step command‑line examples for encoding and decoding strings, files, and user input with practical Bash scripts.
A practical guide warns developers to breathe, verify servers, back up data, and follow strict habits when using risky commands like rm -rf, chmod, dd, and MySQL to prevent catastrophic data loss in production environments.
This comprehensive guide explains how to dramatically improve Linux security and privacy by selecting hardened distributions, configuring kernel and boot parameters, applying sysctl tweaks, disabling unnecessary services, using MAC frameworks, sandboxing applications, hardening memory allocation, and following best‑practice system administration steps.
This guide explains what Linux Load Average represents, how to read each field of the top command output—including CPU, memory, and process details—and offers practical tips for diagnosing server performance issues using additional tools like vmstat and iostat.
This article compiles a comprehensive set of Linux shell commands for server health checks—from file cleanup and process inspection to network, disk, and memory monitoring—followed by a handy collection of regular expressions for common validation tasks.
Learn how to effectively use the Linux time command—including its basic output, the meaning of real, user, and sys values, differences between shell built‑ins and GNU time, and advanced options like -p, -v, -o, -f—to accurately measure program performance and diagnose bottlenecks.
A tech roundup reveals a former actor turned PhD, exposes a massive Amazon paid‑review fraud, extends Linux 5.10 LTS support to 2026, details Edge’s false Firefox block, showcases Google’s new Chrome media controls, and announces China’s 62‑qubit programmable quantum prototype.
This guide walks through checking the current kernel version, adding the ELRepo repository, listing and installing newer kernels on CentOS 7, configuring GRUB to boot the new kernel, and then provides a parallel step‑by‑step process for upgrading the kernel on Ubuntu 16.04, including troubleshooting dependency issues.
This tutorial walks through Linux library management, demonstrating how to build and inspect static (.a) and shared (.so) libraries, configure runtime search paths with LD_LIBRARY_PATH, customize linker behavior, and handle multi‑architecture library locations using practical command‑line examples.
This article provides a detailed tutorial on the Linux find command, covering how to locate files by name, type, size, time, and permissions, combine conditions, execute actions, and compare it with the locate utility, offering practical examples for system administrators.
This guide explains how to relocate Docker's storage directory to a larger disk on a CentOS system, covering disk addition, partitioning, formatting, mounting, copying data, updating the Docker daemon configuration, and verifying container operation after migration.
This guide walks you through safely stopping, removing, and reinstalling GitLab CE on a Linux server, covering dependency installation, configuration tweaks, port management, firewall settings, and essential GitLab commands for daily administration.
This guide walks you through installing AutoKey on Linux, configuring its UI, creating typo‑fix phrases, setting window filters, assigning hotkeys, and writing Python scripts to automate repetitive typing tasks, helping you streamline your workflow and reduce keystroke effort.
This article explains how Linux stores file metadata in inodes, demonstrates the differences between hard and soft links through practical experiments, and provides a detailed walkthrough of the inode structure and its associated VFS operation functions.
This guide introduces the most important Linux terminal commands—pwd, ls, cd, mkdir, man, touch, nano, and rm—explaining their usage, syntax, and practical tips so developers can navigate, manage files, and work confidently in a shell environment.
This guide provides a comprehensive, step‑by‑step walkthrough of the Linux performance monitoring tools top, free, and vmstat, covering command syntax, useful options, real‑world examples, output interpretation, and practical tips for effective system tuning and troubleshooting.
This article explains what the Linux Load Average metric means, how the three numbers are calculated, and walks through each line of the top command output—including CPU, memory, swap, and process details—to help you diagnose server load issues effectively.
This guide explains why adhering to the Linux kernel coding style matters, introduces automatic tools such as checkpatch.pl, Lindent, and astyle for fixing style violations, and details the core conventions for indentation, line length, brace placement, naming, comments, macros, and other critical aspects of kernel C code.
Tencent's TDSQL team introduces a groundbreaking theory that precisely classifies an infinite number of transaction‑related data anomalies, explains the underlying conflict‑ring model, and provides a Linux‑based open‑source tool with step‑by‑step instructions for practical anomaly detection.
This article explains how to package a Spring Boot application using Maven's assembly plugin, configure environment-specific profiles, and deploy the resulting zip with a custom shell script that supports start, stop, restart, and unzip operations on Linux.
This article provides a comprehensive introduction to the ELK stack—including component descriptions, architectural diagrams, reasons for adoption, and step‑by‑step installation and configuration of Filebeat, Logstash, Elasticsearch, and Kibana on Linux, with optional Kafka integration for advanced pipelines.
This guide walks you through Linux account security, user file inspection, login tracking, privilege checks, process analysis, startup script review, cron job auditing, file searching, and log examination, providing practical commands and tips to uncover and mitigate potential intrusions.
This guide walks through preparing three Linux servers, installing JDK 1.8, configuring Hadoop core, HDFS, MapReduce, and YARN XML files, setting Java environment variables, formatting HDFS, and starting all services to access the Hadoop web UI.
This article explains the common causes of network packet loss on Linux, walks through the packet transmission process, outlines a layer‑by‑layer troubleshooting framework, and provides concrete commands, configuration tweaks, and hardware checks to identify and resolve loss at the NIC, driver, kernel, IP, TCP, UDP, and application layers.
After a week-long delay, Linus Torvalds announced the official release of Linux kernel 5.12, highlighting support for Intel Xe GPU variable refresh rates, C language link‑time optimization (LTO), kernel fencing (KFENCE), and overclock profiles for AMD Radeon RX 6000 series, while noting it’s a modest update ahead of the larger 5.13.
This guide explains how the Linux shell stores command history, how to view, search, repeat, and manage entries, and shows practical techniques—including timestamps, size limits, custom file names, and disabling history—to improve productivity and auditability.
This article explains how Linux shells store command history in .bash_history, shows basic and advanced usage of the history command—including listing, searching, repeating, timestamping, and configuring history size—and provides practical tricks for auditing, backup, and even disabling history for security purposes.
This article presents fifteen practical Linux command‑line techniques—including quick file truncation, large file generation, secure disk wiping, system‑disk creation, process runtime inspection, real‑time log monitoring, timestamp conversion, execution timing, ASCII lookup, handling garbled filenames, retrieving public IP, batch downloading, and command‑history shortcuts—to help users automate tasks and improve efficiency.
Through a playful narrative, the article explains how Linux processes interact with the kernel, why blocking I/O is inefficient, and how the epoll system call and its associated mechanisms like soft interrupts and the scheduler dramatically improve network concurrency and performance.
This article introduces essential Linux monitoring utilities—including top, vmstat, pidstat, iostat, netstat, sar, and tcpdump—explaining their output fields, typical usage scenarios, and how to interpret CPU, memory, disk, and network performance metrics for effective system troubleshooting and optimization.
This article explains how to configure Linux network interfaces, interpret configuration files, set up DNS and hosts, understand routing (static and dynamic), examine IP and MAC header structures, apply CIDR subnetting, differentiate private and public addresses, and choose common virtual networking methods such as bridge, NAT, and host‑only.
This guide explains how to install the sar (System Activity Reporter) tool on Ubuntu, describes its syntax and options, and provides detailed examples for monitoring CPU, memory, I/O, and network metrics, plus an overview of the ksar graphical front‑end.
Samsung announced its Home of Galaxy Upcycling program to transform old Galaxy phones into IoT sensors, while Chengdu released a new talent shortage list highlighting emerging tech roles; meanwhile Ubuntu 21.04 debuted with Wayland and AD integration, and Microsoft unveiled preview support for Linux GUI apps in WSL.
A controversial university paper on covertly injecting vulnerabilities into open‑source software sparked a chain of malicious Linux kernel patches, provoked a fierce response from maintainer Greg Kroah‑Hartman, and forced the University of Minnesota to suspend the research amid heated community debate.
This guide lists essential Linux commands for retrieving comprehensive hardware information—including CPU, memory, disk, network interfaces, PCI, USB, SCSI, and BIOS details—along with example outputs and explanations for each category on an Ubuntu 16.04 system.
This guide walks through the complete process of installing RocketMQ 4.8.0, configuring a two‑master‑two‑slave asynchronous high‑availability cluster across two Linux servers, setting up the web console, and troubleshooting common pitfalls such as missing JDK, memory limits, firewall rules, and network address issues.
The Linux Thermal Framework provides a three‑layer architecture—userspace sysfs interfaces, kernel core components, and hardware sensors—to define thermal zones and cooling devices, employing governors such as bang‑bang, step‑wise, low‑limits, user‑space, and power‑allocator to balance performance, power consumption, and device temperature, especially on mobile platforms.
This guide explains what Jenkins is, outlines its main features, and provides step‑by‑step instructions for installing Jenkins on Linux via three methods—yum package, Tomcat container, and Docker—including all required commands, configuration files, and how to retrieve the initial admin password.
Linux’s Virtual File System (VFS) acts as a glue layer between user space and various file systems, providing a unified interface and object model—including superblocks, inodes, file and dentry objects—and employs caching mechanisms like dcache to efficiently manage directory entries.
This article explains NUMA architecture, how its memory allocation policies can cause swap‑related performance issues for MySQL, provides step‑by‑step methods to disable NUMA at BIOS, kernel or MySQL levels, and discusses the innodb_numa_interleave parameter and best‑practice recommendations.
This guide walks through common Linux emergency scenarios—such as mining malware, ransomware, and backdoors—detailing a step‑by‑step workflow and providing essential command‑line tools for process, user, network, and file investigation on CentOS 6 and Windows Server 2008 systems.
This article explains the origin and necessity of load balancing, compares DNS, hardware, and software approaches, details the Linux Virtual Server (LVS) architecture, its netfilter foundation, and the DR, NAT, and Tunnel operating modes with their advantages, disadvantages, and typical use cases.
This guide walks through the versatile Linux find command, showing how to locate files and directories by name, type, size, timestamps, permissions, and more, while demonstrating practical examples such as pattern matching, case‑insensitive searches, depth limiting, and executing actions on results.
CPUFetch is a cross‑platform command‑line utility that reports CPU architecture, model, microarchitecture, nanometer technology, frequency, core/thread count, AVX/FMA support, cache sizes, and peak performance, and this guide explains how to compile, install, run, and uninstall it on Ubuntu (and other OSes).
This guide walks through a step‑by‑step experiment that shows how to recover MySQL files from a Linux virtual machine that cannot boot, by mounting its disk on a new VM, activating LVM volumes, copying configuration and data files, and restarting the database.
This article explains how to efficiently use the Linux history command, covering its underlying mechanism, basic usage, repeat execution, searching, interactive search, timestamp display, history size control, file name changes, disabling history, and a useful security tip, helping administrators improve productivity and auditability.
This article demonstrates how to recover MySQL data from a crashed Linux virtual machine by mounting its disk on a new VM, activating LVM logical volumes, copying configuration and data files, and restarting MySQL, illustrating a practical data rescue workflow.
This article presents fifteen practical Linux command-line techniques—from quickly emptying files and generating large test files to securely erasing disks, monitoring logs, converting timestamps, measuring execution time, handling garbled filenames, retrieving public IPs, batch downloading, and mastering history shortcuts—designed to dramatically improve everyday productivity.
When a server suddenly generated 800 MB of outbound traffic and SSH became unresponsive, the author traced the issue to a hidden backdoor, blocked the malicious IP, identified compromised binaries, removed malicious processes and startup scripts, and outlined preventive security measures.
This article explains MongoDB's document-oriented data model, shows how to create an admin user, configure the mongod service on Linux, and provides detailed command‑line examples for backing up and restoring databases and collections using mongodump, mongorestore, mongoexport, and mongoimport.
This tutorial explains how to install and use the curl and wget command‑line tools on Ubuntu (and other Linux distributions) to download single or multiple files, rename them, handle FTP sources, and pause or resume transfers efficiently.
This article reports a high‑severity WeChat PC zero‑day, a Chinese engineer’s M1‑chip memory and storage upgrade, Slackware 15.0 Beta release, Google Project Zero’s extended disclosure windows, and the debut of the world’s first officially certified semi‑cyborg, highlighting major tech security and innovation news.
This guide reviews the most popular Linux distributions of 2021, highlighting each distro’s strengths, target users, and key features to help readers select the best fit for desktop, development, gaming, security, server, and Raspberry Pi use cases.
This article demystifies the Linux I/O stack by tracing a single‑byte read through system calls, VFS, page cache, filesystem layers, block management and I/O scheduling, revealing when real disk I/O occurs and how much data is actually transferred.
This article explains the concepts of user space and kernel space, shows how traditional file‑to‑socket transfers involve multiple data copies with read/write system calls, and demonstrates how the Linux sendfile system call implements zero‑copy to reduce copies and system calls for high‑performance servers.
This article introduces the Linux filesystem hierarchy, explains typical directories, provides solutions for MobaTextEditor garbled text, and offers a concise guide to Vim modes, settings, search/replace commands, and useful shell scripts for system administrators.
After a week-long series of experiments measuring TCP connections in various states—including ESTABLISH, client‑to‑server, server‑to‑client, and non‑ESTABLISH scenarios—the author quantifies per‑connection memory usage and shows how modern kernels reclaim buffers and reduce overhead, especially for TIME_WAIT.
This article explains how the Linux kill -9 command can cause data loss and service instability, demonstrates safer alternatives such as kill -15 and Spring Boot's built‑in shutdown mechanisms, and provides code examples for implementing graceful termination, custom shutdown hooks, and pre‑destroy data backup in Java backend services.
This article explains how a seemingly simple read‑of‑one‑byte in user code triggers a complex Linux I/O stack involving the I/O engine, system calls, VFS, page cache, file system implementations, generic block layer and I/O scheduler, and clarifies when actual disk I/O occurs and its granularity.
This article explains the purpose and structure of key Linux user and group configuration files—including /etc/passwd, /etc/shadow, /etc/login.defs, /etc/group, and /etc/gshadow—detailing each field, default settings, and how they interrelate to manage accounts and permissions securely.
This comprehensive guide introduces awk as a powerful Linux text‑analysis tool, explains its underlying record‑field model, demonstrates practical one‑liners and scripts for reporting, filtering, formatting, file splitting, and shows advanced features like built‑in variables, conditionals, arrays, and string functions.
This guide explains how to configure Linux environment variables using various methods such as export, editing ~/.bashrc, ~/.bash_profile, /etc/bashrc, /etc/profile, and /etc/environment, and details the loading sequence and practical tips for effective management.
This guide details the investigation of Mellanox CX‑5 NIC support for OVS flow‑table acceleration, outlines required software versions, explains VT‑d and SR‑IOV technologies, provides step‑by‑step host configuration, OVS setup, test procedures, performance results in VXLAN and VLAN environments, and explores the feasibility and scripts for VF hot‑migration.
This guide compares curl and wget, highlighting their overlapping features and key differences—curl excels at customizable web requests while wget shines in recursive and FTP downloads—plus provides practical command examples for downloading, renaming, resuming, rate‑limiting, viewing headers, and mirroring sites.
This article shares a personal deep-dive into using Linux for daily development, communication, and multimedia, compares it with Windows, showcases Android app support via xDroid, and highlights Linux's elegance, efficiency, speed, low resource usage, and open-source freedom.
This guide outlines critical precautions and best‑practice tips for executing risky Linux commands—such as rm, chmod, cat, dd, tar, and MySQL—by verifying environments, backing up data, using safe aliases, and avoiding common pitfalls that can cause catastrophic data loss.
This guide walks through essential Linux server monitoring tools—top, vmstat, pidstat, iostat, netstat, sar, and tcpdump—explaining their output fields, what each metric reveals about CPU, memory, disk I/O, and network performance, and how to use them for effective troubleshooting and capacity planning.
This guide explains how to use the ps and grep commands to identify zombie processes on Linux, interpret the output fields, and terminate them safely by sending signals to the appropriate parent or child processes, with example commands and verification steps.
Replit engineers discovered that slow Docker container shutdown on preemptible VMs caused REPL sessions to hang for up to a minute, and by bypassing Docker’s kill process and directly terminating container PIDs they reduced error rates from 3% to under 0.5% and cut 99th‑percentile startup time from two minutes to fifteen seconds.
This article explores three real‑world cases of TCP anomalies that affect database connectivity—ineffective RST packets, unexpected port exhaustion despite tcp_tw_reuse, and ghost connections caused by a full accept queue—explaining the underlying Linux kernel mechanics and offering practical mitigation strategies.
This article investigates why MySQL encounters out‑of‑memory errors during sysbench stress testing with high concurrency, examines system memory metrics, explains Linux vm.overcommit_memory settings, and provides a practical solution to prevent OOM by adjusting kernel parameters.
This guide explains how to use Linux command‑line utilities such as free, vmstat, top, sar, iostat, iotop, netstat, and jstack to identify memory, CPU, network, and disk performance bottlenecks, and provides practical commands for monitoring and troubleshooting each resource.
This guide compares three popular Linux terminal emulators—Xfce Terminal, rxvt‑unicode, and Konsole—explaining their key features, customization options, and why choosing the right terminal can boost productivity and improve the command‑line experience.
This tutorial shows Linux users how to add Git functionality to the Nautilus file manager using RabbitVCS, covering installation, repository initialization, common Git actions, and pushing changes to GitHub directly from the GUI.
This guide explains how to secure Linux accounts, examine critical system files, use command‑line tools to monitor logins, detect suspicious activity, analyze logs, and investigate potential intrusions, providing practical steps for administrators to harden and audit their servers.
This article explains why the Linux cp command can duplicate a seemingly 100 GB file in less than a second by revealing how sparse files work, the role of inodes and block allocation, the different cp --sparse modes, and the underlying filesystem mechanisms such as fiemap, extent copying, and hole punching.
Learn step-by-step how to compare two Linux directories, using the diff command with options like -q and -r to list unique files, and visualize results with the graphical Meld tool, including installation instructions for various distributions and screenshots of the comparison workflow.
This guide shows how to create and run a Bash script that gathers active TTYs using the w, awk, and tail commands and then force‑kills those sessions with pkill, plus a variant for terminating a single user's sessions.
This article introduces four widely used Linux monitoring utilities—iotop, htop, IPTraf, and Monit—explaining their core features and how they help quickly diagnose system performance and network issues for effective operations management.
This article provides a comprehensive overview of essential Linux commands for navigating directories, viewing and manipulating files, managing permissions, compressing archives, and controlling system processes, offering practical examples and syntax for each operation.
This guide introduces four essential Linux monitoring utilities—iotop, htop, IPTraf, and Monit—explaining their key features, how they differ from similar commands, and why they are valuable for quickly diagnosing I/O, CPU, memory, network, and service issues on servers.
This article explains the Linux I/O stack, the flow of data from user‑space buffers through libc buffers, page cache, and kernel buffers to the physical disk, covering functions like fwrite, fflush, fsync, O_DIRECT, scheduling algorithms, consistency issues, and performance considerations.
This article provides a comprehensive introduction to the Bash shell, covering its purpose, user prompts, shebang syntax, execution methods, basic commands like echo and printf, variable handling, environment variables, arithmetic operations, and conditional statements for writing effective shell scripts.
This article provides a deep technical walkthrough of libuv’s Linux implementation, covering epoll‑based I/O handling, level‑ and edge‑triggered events, the event‑loop architecture, timer management with a min‑heap, thread‑pool integration, and the mechanisms that drive asynchronous callbacks in Node.js.
