Introduction to Mainframe Concepts and z/VM Overview
What's a Mainframe?
Mainframe History & Evolution
Why Mainframes Matter
Virtualization Explained
Hypervisors: The Managers
z/VM: Mainframe's Hypervisor
Why z/VM is Special
z/VM's Core Components
Layers of z/VM
Virtual Machines in z/VM
z/VM vs. z/OS
z/VM vs. z/Linux
The Mainframe OS Family
Why z/Linux on z/VM?
Your Role in the Ecosystem
z/VM Architecture: Control Program (CP) Deep Dive
CP: The Brain of z/VM
CP's Virtualization Power
CP's Resource Management
VMs: CP's Creations
Starting & Stopping VMs
VM Interaction with CP
CP & CPU Management
CP & Memory Management
CP & I/O Management
CP's Privileged Modes
CP's System Console
CP's Role in IPL
CP Command Basics
Querying CP Status
CP's Role in Security
z/VM Architecture: Conversational Monitor System (CMS)
What is CMS?
CMS vs. CP: The Big Diff
Your CMS Virtual Machine
CMS File System Basics
Your Virtual Disks (Minidisks)
CMS File Commands: Part 1
CMS File Commands: Part 2
CMS File Commands: Part 3
Running CMS Programs
The XEDIT Editor
CMS Pipelines: Data Flow
CMS for System Admins
CMS User Environments
CMS Message Handling
CMS Shared File System (SFS)
CMS Batch Processing
CMS Utilities & Tools
z/VM Architecture: Other Key Components
GCS: The Group Manager
GCS Memory & Resources
GCS: Virtual Machine Groups
RSCS: The Print & File Hub
RSCS Network & Nodes
RSCS: Data Transfer
TSAF: The Service Broker
TSAF: Service Registration
TSAF: Cross-System Access
SFS: The Shared Storage
SFS: File Pools & Servers
SFS: Access & Permissions
Components: Working Together
Choosing the Right Tool
Key Components Recap
Planning for z/VM Installation: Hardware and Software Prerequisites
Mainframe Models & LPARs
Processors & Capacity
Memory: Real & Virtual
Storage: DASD & FCP
I/O Channels & Adapters
z/VM Version & Release
PTFs & Service Levels
Microcode & Firmware
Required Software Products
External Security Managers
Network Connectivity
System Console Access
IPL Procedures
Installation Media
Pre-Install Checklist
Planning for z/VM Installation: Resource Allocation Strategy
Why Resource Planning?
Mainframe Resource Types
Shared vs. Dedicated
CPU Basics for z/VM
Virtual CPU Allocation
CPU Weight & Capping
Memory for z/VM LPAR
Virtual Machine Memory
Paging & Swapping
I/O Device Types
DASD Allocation
Network Adapter Planning
Tape & Other I/O
Workload Analysis
Guest OS Requirements
Sizing Tools & Methods
z/VM Installation: Initial Program Load (IPL) and System Generation
What is IPL?
What is SYSGEN?
IPL vs. SYSGEN
IPL Prerequisites
SYSGEN Prerequisites
The IPL Process Step-by-Step
IPL from HMC
Initial Console Interaction
Basic System Parameters
Verifying IPL Success
SYSGEN Input Files
SYSGEN Phases
Running SYSGEN
Post-SYSGEN Verification
Troubleshooting IPL/SYSGEN
z/VM Installation: Post-Installation Configuration
Network Basics for z/VM
Configuring OSA Devices
Setting Up VSWITCH
IP Addressing for z/VM
Network Routes & Services
Testing Host Connectivity
Initial User IDs & Passwords
Basic Security Parameters
User Directory Security
Virtual Disk Setup
Virtual Network Devices
Virtual Console & Other I/O
Initial System Tuning
Verify System Status
Post-Install Checklist
Managing z/VM Users and Virtual Machines: User Directory
What's the User Directory?
User Directory Structure
Locating the Directory
Creating a New VM Entry
Modifying VM Entries
Adding Virtual Devices
CPU Allocation & Limits
Memory Allocation & Limits
Virtual Device Addressing
Password Management
Basic Access Controls
Privilege Classes
Activating Directory Changes
User Directory Best Practices
Troubleshooting Directory Issues
Managing z/VM Users and Virtual Machines: CP Commands for VM Management
VMs: Start, Stop, Reset
Creating a New VM
VM Status at a Glance
VM CPU & Memory Usage
VM I/O Device Status
Connecting to a VM Console
VM Privileges & Capabilities
VM Resource Limits
VM State Troubleshooting
VM Autolog & IPL
VM Message Handling
VM Device Detach/Attach
VM Spool File Mgmt
VM Performance Insights
VM Configuration Backup
Managing z/VM Resources: CPU Management
CPU Basics for z/VM
The Dispatcher's Role
Virtual CPUs Explained
Adding VCPUs to a VM
Setting CPU Attributes
Dynamic CPU Changes
CPU Sharing Concepts
Implementing CPU Capping
Dedicated vs. Shared CPUs
CP Monitor for CPU
CP Commands for CPU
Performance Toolkit CPU
High CPU Utilization
CPU Contention & Delays
CPU Optimization Tips
Managing z/VM Resources: Memory Management
Memory: The Basics
CP's Memory Domain
Virtual Memory Explained
Paging: The What & Why
Swapping: VM States
Allocating VM Memory
CP Query Memory
CP Monitor for Memory
Spotting Memory Bottlenecks
Memory Sharing Concepts
Overcommitment Strategies
Configuring Shared Memory
Tuning Memory Parameters
VM Memory Optimization
Memory Performance Best Practices
Managing z/VM Resources: I/O Management
I/O Basics on Mainframe
z/VM's I/O Virtualization
DASD: The Disk Workhorse
Virtual DASD Setup
Virtual Network Adapters
Virtual Tape Drives
Shared I/O Devices
Dedicated I/O Devices
Minidisk Sharing
CP I/O Monitoring Commands
I/O Performance Metrics
Performance Toolkit for I/O
Common I/O Problems
Diagnosing I/O Bottlenecks
Resolving I/O Issues
Introduction to REXX for z/VM Automation
Why REXX for z/VM?
Your First REXX Exec
Variables and Data Types
REXX and CP Commands
REXX and CMS Commands
Input and Output
Conditional Logic: IF-THEN-ELSE
Conditional Logic: SELECT
Looping: DO UNTIL/WHILE
Looping: DO FOREVER/FOR
Automating File Tasks
Automating VM Management
Automating User Tasks
Error Handling Basics
Debugging Your REXX
Advanced REXX for z/VM Automation
Advanced Variables & Arrays
Nested Control Structures
Functions & Subroutines
CP & CMS Command Output
Interacting with CP
Interacting with CMS
Error Trapping & Recovery
Logging & Debugging
User Input & Validation
String Manipulation
Numeric & Date/Time Ops
File I/O Operations
Creating Reusable Modules
Parameter Handling
Best Practices & Style
Introduction to z/Linux on z/VM
Linux on Mainframe?
Why z/Linux?
z/Linux vs. Other Linux
Who Uses z/Linux?
z/Linux & z/VM: A Team
Planning for z/Linux Installation: Resource Sizing and Networking
Why Size z/Linux Guests?
CPU Needs for z/Linux
Memory Needs for z/Linux
Storage Needs for z/Linux
Shared vs. Dedicated Resources
DASD for z/Linux
FCP/SCSI for z/Linux
Choosing Your Storage
Virtual Network Devices
IP Addressing for z/Linux
Network Connectivity Options
Scalability Considerations
High Availability Planning
Multi-Instance Resource Plan
Preparing the z/VM Environment for z/Linux Guests
Linux VM User ID
Virtual CPU & Memory
Virtual Console Access
VSWITCH Basics
Creating a VSWITCH
Connecting Linux to VSWITCH
DASD for Linux
FCP/SCSI for Linux
Minidisks for Linux
Virtual Device Addressing
IPLing the Linux VM
User Directory Review
Network Connectivity Check
Storage Accessibility Check
Pre-Install Checklist
Installing z/Linux: Initial Setup and Bootstrapping
Installation Prep Checklist
Bootstrapping z/Linux
Installation Media Access
IPLing the Installer
Installer Interface Basics
Disk Partitioning
Basic Network Setup
User Accounts & Root
Time and Locale Settings
Software Selection
Installation Summary
First Boot & Login
Verifying Installation
Post-Install Updates
Troubleshooting Installs
Configuring z/Linux Networking under z/VM
Virtual Network Basics
VSWITCH: The Core
VSWITCH Types & Modes
Creating a VSWITCH
VSWITCH Connectivity
z/Linux Network Devices
IP Addressing in z/Linux
Routing for z/Linux
DNS Resolution in z/Linux
Persistent Network Config
Network Bonding
Network Teaming
Basic Network Troubleshooting
Advanced Network Troubleshoot
VSWITCH Troubleshooting
Managing z/Linux Storage under z/VM
Storage on the Mainframe
DASD Basics for z/Linux
FCP/SCSI Basics for z/Linux
Attaching DASD to z/Linux
DASD Partitioning & Format
Mounting DASD File Systems
FCP Device Setup in z/VM
FCP/SCSI Device Discovery
FCP/SCSI Partitioning & Format
Mounting FCP/SCSI File Systems
LVM Concepts & Benefits
Creating LVM Components
Managing LVM Volumes
LVM File Systems & Mounts
Swap Space Management
Storage Best Practices
z/Linux System Administration Basics on z/VM
Users: Who's Who?
Groups: Teamwork in Linux
Adding & Deleting Users
Modifying Users & Groups
User & Group Info
Processes: The Basics
Managing Processes
Services: Systemd
Linux File System Map
Navigating the Filesystem
Permissions & Ownership
Logging: What's Happening?
Package Managers: Yum/Apt
Managing Software
Monitoring z/VM Performance: CP Monitor and Performance Toolkit
Why Monitor z/VM?
Key Performance Metrics
Monitoring Tools Overview
CP Monitor Basics
Monitor Data Destinations
Selecting Monitor Domains
Reading Monitor Output
CPU Metrics in CP Monitor
Memory Metrics in CP Monitor
I/O Metrics in CP Monitor
Intro to Perf Toolkit
Toolkit Installation & Setup
Navigating the Toolkit
Generating Reports
Visualizing Performance
Monitoring z/VM Performance: Resource Utilization Analysis
CPU Metrics Explained
Monitoring Host CPU
Monitoring Guest CPU
Memory Metrics Explained
Monitoring Host Memory
Monitoring Guest Memory
Paging & Swapping Deep Dive
I/O Metrics Explained
Monitoring Device I/O
Monitoring VM I/O
Identifying Contention
Analyzing Contention
Workload Characteristics
Performance Baselines
Capacity Planning Basics
Monitoring z/Linux Performance: Tools and Metrics
Why Monitor z/Linux?
Your First Look: 'top'
CPU Metrics with 'vmstat'
Memory Metrics with 'vmstat'
Disk I/O with 'iostat'
Network I/O with 'netstat'
Introducing 'sar'
CPU Analysis with 'sar'
Memory Analysis with 'sar'
Disk & Network with 'sar'
Finding Bottlenecks
z/VM's Resource Impact
Logging for Analysis
Other Useful Tools
Putting It All Together
Performance Optimization Strategies for z/VM
CPU Dispatching Basics
Setting Dispatch Priorities
CPU Capping Strategies
Memory Management Review
Shared Memory Techniques
Page Management & Tuning
I/O Device Configuration
I/O Path Management
VSWITCH Optimization
SRM Parameters Tuning
CP System Parameters
Guest OS Interaction
Workload Characterization
Resource Balancing Act
Capacity Planning Basics
Performance Optimization Strategies for z/Linux on z/VM
Kernel Parameters Intro
Memory Kernel Tuning
CPU Kernel Tuning
App Tuning Basics
Web Server Optimization
Database Optimization
File System Choices
Storage I/O Tuning
Swap Space Optimization
Network Kernel Tuning
Network Device Tuning
Network Service Tuning
VM-Linux Resource Balance
Cross-Layer Monitoring
Resolving Cross-Layer Issues
z/VM Security: User Authentication and Authorization
Security Model Overview
User Directory & Security
CP Commands for Security
Password Authentication
Strong Password Policies
Account Lockout
Intro to External Security
ESM for Authentication
ESM for Authorization
Privilege Classes
User Access Rights
Delegated Administration
Auditing Login Attempts
Auditing Access Violations
Security Reporting
z/VM Security: Resource Access Control
Why Resource Security?
z/VM's Security Model
Meet RACF for z/VM
RACF Resource Classes
Defining Resource Profiles
Access Lists & Permissions
Generic Profiles
Discretionary Access Control
Mandatory Access Control
Protecting Virtual Machines
Securing Minidisks & Files
RACF Auditing Basics
Reviewing Access Logs
Compliance Reporting
z/VM Security: Network and System Hardening
Network Security Basics
Controlling Network Access
Virtual Switch Security
Network Segmentation
Firewall Concepts
Securing z/VM Services
SSH and SFTP for z/VM
TLS/SSL for z/VM
NTP and DNS Security
SNMP Security
Patch Management
System Configuration Hardening
Security Policy Development
Incident Response Planning
Security Auditing & Logging
Troubleshooting z/VM: System Logs and Messages
Why Logs Matter
Where to Find Logs
Console Log Basics
Message Format Explained
Error Codes & Meanings
Common Message Types
DISPLAY Command Power
QUERY Command for Logs
Filtering Log Output
VM Startup Issues
Resource Shortages
I/O and Device Errors
The Analysis Workflow
Context is Key
Beyond the Obvious
Troubleshooting z/VM: Diagnostic Tools and Techniques
Why Diagnose z/VM?
Diagnostic Tool Overview
CP TRACE Basics
Advanced CP TRACE
Understanding Dumps
Capturing a CP Dump
Analyzing System Hangs
Analyzing System Crashes
VM State Analysis
Resource Contention
z/VM Service Assistant
Working with IBM Support
Dump Analysis Tools
Proactive Diagnostics
Troubleshooting Workflow
Troubleshooting z/Linux on z/VM: Common Issues
z/Linux Boot Sequence
Common Boot Failure Causes
Boot Failure Diagnostics
Network Setup Review
Common Network Issues
Network Diagnostic Tools
Storage Configuration Check
Common Storage Issues
Storage Diagnostic Tools
Performance Metrics Overview
CPU Performance Issues
Memory Performance Issues
I/O Performance Issues
System Log Analysis
Process Tracing (strace)
Troubleshooting z/Linux on z/VM: Interoperability Challenges
The VM-Linux Connection
Virtual Device Drivers
Driver Status Check
Common Driver Problems
Driver Error Logs
Driver Updates & Rollbacks
Resource Contention Basics
CPU Allocation Conflicts
Memory Allocation Conflicts
I/O Allocation Conflicts
Hypervisor Overhead
Minimizing Overhead
Cross-Layer Log Analysis
Troubleshooting Workflow
Advanced z/VM Features: Live Guest Relocation (LGR)
What is LGR?
Why Use LGR?
LGR vs. Other Migrations
LGR Hardware Needs
LGR Software Needs
Network Setup for LGR
Storage Setup for LGR
LGR Planning Checklist
LGR Commands
LGR Step-by-Step
Monitoring LGR Progress
Common LGR Errors
LGR Troubleshooting Tools
Resolving LGR Issues
Advanced z/VM Features: Single System Image (SSI)
SSI: The Big Picture
SSI vs. Standalone z/VM
SSI Architecture Unpacked
The SSI Coordinator
SSI Member Systems
SSI Communication Channels
SSI Planning Essentials
Building the SSI Cluster
SSI Shared Resources
VMs Across SSI Members
VM Relocation in SSI
SSI for Scalability
SSI Health Checks
Common SSI Issues
SSI Problem Solving
Advanced z/VM Features: HiperSockets and OSA
HiperSockets: What & Why?
HiperSockets Architecture
HiperSockets vs. VSWITCH
HiperSockets Setup: CP
HiperSockets for z/VM Guests
HiperSockets for z/Linux
OSA: Your External Link
OSA Modes & Features
OSA vs. HiperSockets
OSA Setup: HCD & LPAR
OSA for z/VM Host
OSA for z/Linux Guests
HiperSockets Performance
OSA Performance Tuning
Network Performance Best Practices
Advanced z/VM Features: z/VM Security Server and External Security Managers
Security Server Basics
Security Server Setup
Security Server Profiles
ESM Integration Overview
RACF Basics for z/VM
Configuring ESM Integration
LDAP Authentication
Multi-Factor Authentication
Other Auth Methods
Resource Authorization
Command Authorization
Virtual Machine Access
Security Event Logging
Security Reporting
Audit and Compliance
Disaster Recovery and Backup Strategies for z/VM and z/Linux
Why DR & Backup Matters
DR Plan Components
Backup Types & Methods
Backing Up z/VM Config
Restoring z/VM Config
CMS File Backup & Restore
z/Linux File System Backup
z/Linux Image Backup
z/Linux Backup Best Practices
Replication Technologies
DR Site Planning
DR Drill Execution
Validating DR Procedures
Automation in DR
Cloud & Hybrid DR
DR Reporting & Auditing
Best Practices and Future Trends in z/VM and z/Linux Administration
Efficient z/VM Setup
Resource Management Tips
Secure z/VM Admin
Maintenance & Updates
Efficient z/Linux Guests
Secure z/Linux Guests
z/Linux Performance Tuning
Mainframe Cloud Trends
Automation with REXX
DevOps on the Mainframe
Open Source on z/VM
IBM Documentation & Support
Community & Forums
Certifications & Training
Your Mainframe Journey
