ORA-27125 Unable to Create Shared Memory Segment - System Resource Guide

ORA-27125: Unable to Create Shared Memory Segment

Error Overview

Error Text: ORA-27125: unable to create shared memory segment

This critical system-level error prevents Oracle database startup by blocking shared memory allocation. ORA-27125 occurs when the Oracle instance cannot create the required shared memory segments due to operating system limitations, configuration issues, or resource constraints.

Understanding Shared Memory in Oracle

Memory Architecture

Oracle Memory Structure
├── System Global Area (SGA)
│   ├── Database Buffer Cache
│   ├── Shared Pool
│   ├── Redo Log Buffer
│   └── Large Pool
├── Program Global Area (PGA)
└── Operating System Shared Memory
    ├── /dev/shm (Linux)
    ├── SHMMAX/SHMALL (System V)
    └── Memory-mapped files

Shared Memory Requirements

• SGA Size - Configured memory for database instance
• Operating System Limits - Kernel parameters for shared memory
• File System Space - Available space in /dev/shm or similar
• Process Limits - Per-process memory allocation limits

Common Causes

1. Insufficient /dev/shm Space (Linux)

• /dev/shm filesystem too small for SGA
• Other processes consuming shared memory
• Temporary files in /dev/shm
• Multiple Oracle instances competing for space

2. Operating System Limits

• SHMMAX parameter smaller than required SGA size
• SHMALL parameter limiting total shared memory
• Process memory limits (ulimits)
• System-wide memory constraints

3. Configuration Issues

• SGA_TARGET or MEMORY_TARGET too large
• Automatic Memory Management misconfiguration
• Hugepages configuration conflicts
• SELinux or security restrictions

4. Resource Competition

• Multiple Oracle instances on same server
• Other applications using shared memory
• System memory pressure
• Virtual memory exhaustion

Diagnostic Steps

1. Check Current Memory Configuration

-- Check Oracle memory parameters
SELECT name, value, description
FROM v$parameter
WHERE name IN (
  'sga_target', 'memory_target', 'memory_max_target',
  'pga_aggregate_target', 'shared_pool_size',
  'db_cache_size', 'java_pool_size', 'large_pool_size'
)
ORDER BY name;

-- Check actual SGA allocation
SELECT
  name,
  ROUND(value/1024/1024, 2) as size_mb,
  ROUND(value/1024/1024/1024, 2) as size_gb
FROM v$sga
ORDER BY value DESC;

-- Memory allocation summary
SELECT
  ROUND(SUM(value)/1024/1024/1024, 2) as total_sga_gb
FROM v$sga;

2. Check Operating System Limits (Linux)

# Check /dev/shm filesystem
df -h /dev/shm
mount | grep shm

# Check system shared memory limits
ipcs -lm

# Check current shared memory usage
ipcs -m

# Check kernel parameters
sysctl -a | grep shm
cat /proc/sys/kernel/shmmax
cat /proc/sys/kernel/shmall
cat /proc/sys/kernel/shmmni

# Check process limits
ulimit -a

# Check available memory
free -h
cat /proc/meminfo | grep -E "(MemTotal|MemFree|MemAvailable)"

3. Check System Resources

# Check memory pressure
vmstat 1 5
sar -r 1 5

# Check for memory-intensive processes
ps aux --sort=-%mem | head -20

# Check for Oracle processes already running
ps -ef | grep oracle
ps -ef | grep smon

# Check system logs for memory-related errors
dmesg | grep -i memory
journalctl -u oracle-* | grep -i memory

4. Analyze Error Details

# Check Oracle alert log for specific error details
tail -n 100 $ORACLE_BASE/diag/rdbms/$ORACLE_SID/$ORACLE_SID/trace/alert_$ORACLE_SID.log

# Look for specific error patterns:
# - Cannot create shared memory segment
# - SHMGET failed
# - Not enough space
# - Permission denied

# Check trace files for additional details
ls -la $ORACLE_BASE/diag/rdbms/$ORACLE_SID/$ORACLE_SID/trace/*.trc

Immediate Solutions

Solution 1: Increase /dev/shm Size (Linux)

Resize /dev/shm Temporarily

# Check current size
df -h /dev/shm

# Calculate required size (SGA + overhead)
# Recommended: (SGA_SIZE * 1.2) + 1GB for overhead

# Resize /dev/shm (requires root)
sudo mount -o remount,size=16G /dev/shm

# Verify new size
df -h /dev/shm

Make /dev/shm Resize Permanent

# Edit /etc/fstab (requires root)
sudo vi /etc/fstab

# Add or modify the line:
tmpfs /dev/shm tmpfs defaults,size=16G 0 0

# Or modify existing line:
# tmpfs /dev/shm tmpfs defaults,nodev,nosuid,noexec,size=16G 0 0

# Test the configuration
sudo mount -o remount /dev/shm
df -h /dev/shm

Solution 2: Adjust Kernel Shared Memory Parameters

Check and Set SHMMAX

# Check current SHMMAX (maximum shared memory segment size)
cat /proc/sys/kernel/shmmax

# Calculate required SHMMAX (should be >= SGA size)
# For SGA of 12GB: 12 * 1024 * 1024 * 1024 = 12884901888

# Set SHMMAX temporarily
sudo sysctl -w kernel.shmmax=12884901888

# Verify setting
cat /proc/sys/kernel/shmmax

Check and Set SHMALL

# Check current SHMALL (total shared memory pages)
cat /proc/sys/kernel/shmall

# Get page size
getconf PAGE_SIZE

# Calculate required SHMALL
# SHMALL = (Total shared memory needed) / PAGE_SIZE
# For 16GB total: 16 * 1024^3 / 4096 = 4194304

# Set SHMALL temporarily
sudo sysctl -w kernel.shmall=4194304

# Verify setting
cat /proc/sys/kernel/shmall

Make Kernel Parameters Permanent

# Edit sysctl configuration
sudo vi /etc/sysctl.conf

# Add these lines:
kernel.shmmax = 12884901888
kernel.shmall = 4194304
kernel.shmmni = 4096

# Apply the configuration
sudo sysctl -p

# Verify all settings
sysctl -a | grep shm

Solution 3: Reduce Oracle Memory Configuration

Lower SGA_TARGET

-- Connect as SYSDBA to adjust memory parameters
CONNECT / AS SYSDBA

-- Check current memory settings
SHOW PARAMETER memory_target;
SHOW PARAMETER sga_target;

-- Reduce memory allocation (adjust based on available system memory)
-- Example: Reduce from 12GB to 8GB
ALTER SYSTEM SET sga_target = 8G SCOPE = SPFILE;
ALTER SYSTEM SET memory_target = 10G SCOPE = SPFILE;

-- Alternative: Disable automatic memory management
ALTER SYSTEM SET memory_target = 0 SCOPE = SPFILE;
ALTER SYSTEM SET sga_target = 8G SCOPE = SPFILE;
ALTER SYSTEM SET pga_aggregate_target = 2G SCOPE = SPFILE;

-- Restart database for changes to take effect
SHUTDOWN IMMEDIATE;
STARTUP;

Manual Memory Component Sizing

-- Disable automatic memory management and set individual components
ALTER SYSTEM SET memory_target = 0 SCOPE = SPFILE;
ALTER SYSTEM SET sga_target = 0 SCOPE = SPFILE;

-- Set individual SGA components
ALTER SYSTEM SET shared_pool_size = 1G SCOPE = SPFILE;
ALTER SYSTEM SET db_cache_size = 4G SCOPE = SPFILE;
ALTER SYSTEM SET large_pool_size = 512M SCOPE = SPFILE;
ALTER SYSTEM SET java_pool_size = 256M SCOPE = SPFILE;
ALTER SYSTEM SET log_buffer = 64M SCOPE = SPFILE;

-- Set PGA
ALTER SYSTEM SET pga_aggregate_target = 2G SCOPE = SPFILE;

-- Restart database
SHUTDOWN IMMEDIATE;
STARTUP;

Long-Term Solutions

1. System Configuration Optimization

Configure Hugepages (Linux)

# Calculate required hugepages
# Hugepage size (usually 2MB)
grep Hugepagesize /proc/meminfo

# Calculate pages needed: SGA_SIZE / Hugepage_size
# For 8GB SGA with 2MB hugepages: 8192MB / 2MB = 4096 pages

# Set hugepages temporarily
sudo sysctl -w vm.nr_hugepages=4096

# Check hugepage allocation
cat /proc/meminfo | grep -i huge

# Make permanent
sudo vi /etc/sysctl.conf
# Add: vm.nr_hugepages = 4096

# Configure Oracle to use hugepages
ALTER SYSTEM SET use_large_pages = TRUE SCOPE = SPFILE;

Memory Overcommit Configuration

# Check current overcommit settings
cat /proc/sys/vm/overcommit_memory
cat /proc/sys/vm/overcommit_ratio

# Set conservative overcommit (recommended for Oracle)
sudo sysctl -w vm.overcommit_memory=2
sudo sysctl -w vm.overcommit_ratio=80

# Make permanent
sudo vi /etc/sysctl.conf
# Add:
# vm.overcommit_memory = 2
# vm.overcommit_ratio = 80

2. Container and Cloud Environments

Docker Configuration

# Dockerfile for Oracle container
FROM oracle/database:19.3.0-ee

# Configure shared memory
RUN echo "tmpfs /dev/shm tmpfs defaults,size=8G 0 0" >> /etc/fstab

# Set kernel parameters
RUN echo "kernel.shmmax = 8589934592" >> /etc/sysctl.conf
RUN echo "kernel.shmall = 2097152" >> /etc/sysctl.conf

# Run container with increased shared memory
docker run -d \
  --name oracle-db \
  --shm-size=8g \
  -e ORACLE_SID=ORCL \
  -e ORACLE_PDB=PDB1 \
  -e ORACLE_PWD=YourPassword \
  oracle/database:19.3.0-ee

# Kubernetes deployment with shared memory
apiVersion: v1
kind: Pod
spec:
  containers:
  - name: oracle
    image: oracle/database:19.3.0-ee
    resources:
      requests:
        memory: "12Gi"
      limits:
        memory: "16Gi"
    volumeMounts:
    - name: dshm
      mountPath: /dev/shm
  volumes:
  - name: dshm
    emptyDir:
      medium: Memory
      sizeLimit: 8Gi

Cloud Instance Optimization

# AWS EC2 instance configuration
# Ensure sufficient memory for instance type
# r5.2xlarge: 64GB RAM (good for 32GB+ Oracle workloads)
# r5.4xlarge: 128GB RAM (good for 64GB+ Oracle workloads)

# Check instance memory
free -h
lscpu

# Monitor memory usage during startup
watch -n 1 'free -h && echo "--- SHM ---" && df -h /dev/shm'

Prevention Strategies

1. Capacity Planning

memory_assessment.sh

# Create memory assessment script
#!/bin/bash
echo "=== System Memory Assessment ==="
echo "Total Memory: $(grep MemTotal /proc/meminfo)"
echo "Available Memory: $(grep MemAvailable /proc/meminfo)"
echo ""

echo "=== Shared Memory Limits ==="
echo "SHMMAX: $(cat /proc/sys/kernel/shmmax) bytes"
echo "SHMALL: $(cat /proc/sys/kernel/shmall) pages"
echo "Page Size: $(getconf PAGE_SIZE) bytes"
echo ""

echo "=== /dev/shm Status ==="
df -h /dev/shm
echo ""

echo "=== Current Shared Memory Usage ==="
ipcs -m -u
echo ""

echo "=== Hugepages ==="
grep -i huge /proc/meminfo
echo ""

echo "=== Memory Recommendations ==="
TOTAL_MEM_KB=$(grep MemTotal /proc/meminfo | awk '{print $2}')
TOTAL_MEM_GB=$((TOTAL_MEM_KB / 1024 / 1024))
RECOMMENDED_SGA_GB=$((TOTAL_MEM_GB * 60 / 100))

echo "Total System Memory: ${TOTAL_MEM_GB}GB"
echo "Recommended max SGA: ${RECOMMENDED_SGA_GB}GB (60% of total)"
echo "Recommended /dev/shm: $((RECOMMENDED_SGA_GB + 2))GB"

2. Monitoring Setup

-- Create memory monitoring procedure
CREATE OR REPLACE PROCEDURE monitor_memory_usage AS
  v_sga_size NUMBER;
  v_pga_size NUMBER;
  v_total_memory NUMBER;
BEGIN
  -- Get SGA size
  SELECT SUM(value) INTO v_sga_size FROM v$sga;

  -- Get PGA size
  SELECT value INTO v_pga_size
  FROM v$pgastat WHERE name = 'total PGA allocated';

  v_total_memory := v_sga_size + v_pga_size;

  -- Log memory usage
  INSERT INTO memory_usage_log (
    log_time,
    sga_size_mb,
    pga_size_mb,
    total_memory_mb
  ) VALUES (
    SYSTIMESTAMP,
    ROUND(v_sga_size/1024/1024, 2),
    ROUND(v_pga_size/1024/1024, 2),
    ROUND(v_total_memory/1024/1024, 2)
  );

  COMMIT;

  -- Alert if memory usage is high
  IF v_total_memory > 32 * 1024 * 1024 * 1024 THEN -- 32GB threshold
    DBMS_OUTPUT.PUT_LINE('WARNING: High memory usage detected');
  END IF;
END;
/

-- Create monitoring table
CREATE TABLE memory_usage_log (
  log_time TIMESTAMP,
  sga_size_mb NUMBER,
  pga_size_mb NUMBER,
  total_memory_mb NUMBER
);

3. Automated System Checks

#!/bin/bash
# oracle_memory_check.sh - Pre-startup validation

ORACLE_SID=${1:-ORCL}
REQUIRED_SGA_GB=${2:-8}

echo "Checking memory requirements for Oracle instance $ORACLE_SID"
echo "Required SGA size: ${REQUIRED_SGA_GB}GB"

# Check /dev/shm space
SHM_AVAILABLE_GB=$(df /dev/shm | awk 'NR==2 {print int($4/1024/1024)}')
echo "Available /dev/shm space: ${SHM_AVAILABLE_GB}GB"

if [ $SHM_AVAILABLE_GB -lt $REQUIRED_SGA_GB ]; then
    echo "ERROR: Insufficient /dev/shm space"
    echo "Required: ${REQUIRED_SGA_GB}GB, Available: ${SHM_AVAILABLE_GB}GB"
    exit 1
fi

# Check SHMMAX
SHMMAX_GB=$(echo "$(cat /proc/sys/kernel/shmmax) / 1024 / 1024 / 1024" | bc)
echo "SHMMAX: ${SHMMAX_GB}GB"

if [ $SHMMAX_GB -lt $REQUIRED_SGA_GB ]; then
    echo "ERROR: SHMMAX too small"
    echo "Required: ${REQUIRED_SGA_GB}GB, Current: ${SHMMAX_GB}GB"
    exit 1
fi

# Check system memory
TOTAL_MEM_GB=$(free -g | awk 'NR==2{print $2}')
echo "Total system memory: ${TOTAL_MEM_GB}GB"

if [ $TOTAL_MEM_GB -lt $((REQUIRED_SGA_GB * 2)) ]; then
    echo "WARNING: System memory may be insufficient"
    echo "Recommended: $((REQUIRED_SGA_GB * 2))GB, Available: ${TOTAL_MEM_GB}GB"
fi

echo "Memory check completed successfully"

Related Errors

• ORA-00845 - MEMORY_TARGET not supported on this system
• ORA-04031 - Unable to allocate shared memory
• ORA-27102 - Out of memory (not documented yet)
• ORA-00600 - Internal error (when memory corruption occurs)

Emergency Response

Quick Resolution Checklist

1. Check available space

   df -h /dev/shm
   free -h

2. Increase /dev/shm temporarily

   sudo mount -o remount,size=16G /dev/shm

3. Check and adjust kernel parameters

   sudo sysctl -w kernel.shmmax=17179869184  # 16GB
   sudo sysctl -w kernel.shmall=4194304

4. Reduce Oracle memory if needed

   ALTER SYSTEM SET sga_target = 8G SCOPE = SPFILE;

5. Restart database

   STARTUP;

Quick Reference Commands

# Memory diagnostics
df -h /dev/shm
cat /proc/sys/kernel/shmmax
cat /proc/sys/kernel/shmall
free -h

# Increase shared memory limits
sudo sysctl -w kernel.shmmax=17179869184
sudo sysctl -w kernel.shmall=4194304
sudo mount -o remount,size=16G /dev/shm

# Oracle memory adjustment
sqlplus / as sysdba
ALTER SYSTEM SET sga_target = 8G SCOPE = SPFILE;
STARTUP;

System Configuration Template

# /etc/sysctl.conf additions for Oracle
# Shared memory settings
kernel.shmmax = 17179869184    # 16GB
kernel.shmall = 4194304        # 16GB in pages
kernel.shmmni = 4096           # Max shared memory segments

# Memory management
vm.overcommit_memory = 2
vm.overcommit_ratio = 80
vm.nr_hugepages = 8192         # For 16GB hugepages

# /etc/fstab addition for /dev/shm
tmpfs /dev/shm tmpfs defaults,size=20G 0 0