I was looking for something similar, but for tmux. I wanted to be able to search visible words in the current tmux pane, then copy that word to the system clipboard by pressing the associated label key.

I built https://github.com/Kristijan/flash-copy.tmux, with the aim to bring that functionality to tmux.

In the demonstration above, you can see how it works.

1. I launch the TMUX Flash Copy plugin using the default key binding <tmux prefix> Shift + f
2. The word option_override is what I want to copy, so I start searching for it. You can see as I search, words are highlighted in the pane and labels are assigned with each match.
3. I press the label key j associated with the word option_override, and it’s copied to the system clipboard.

You can automatically paste the copied text by holding the semicolon ; modifier key while selecting the label.

I tried to implement as many of the visual features from flash.nvim as possible, and added a few of my own which made sense:

• Dynamic Search: Type to filter words in real-time as you search.
• Overlay Labels: Single key selection with labels overlayed on matches in the pane.
• Dimmed Display: Non-matching content is dimmed for visual focus.
• Clipboard Copy: Selected text is immediately copied to the system clipboard.
• Auto-paste Modifier: Use semicolon key as a modifier to automatically paste selected text.
• Configurable Word Boundaries: Honours tmux’s word-separators by default, with override support.

There are many customisable options available, including:

• Customising the prompt position, indicator, and colour.
• Changing the colours used for highlighted matches and labels.
• Using either case sensitive or case insensitive searching.

You can find a lot more detail and configuration options in the README, and I welcome any feedback or contributions.

tmux has a concept of sessions, windows, and panes. A session is a collection of one or more windows, and a window can contain one or more panes. At work, I use sessions a lot. I’ll have a session that contains all my VIOS, another for all my NIM’s, and another for all my test servers. To switch from one session to another, you press prefix + s to bring up the current list of sessions, arrow down to the session, and hit enter. You can expand the session list to show all the windows, and from there further select the exact window from the session you want to go to.

This flow I find time consuming. I’d much rather bring up the list of sessions, and search to narrow down where I want to switch to. So piggy backing on another tool that I use, I wrote a small little tmux plugin that brings up a fzf window with my sessions, windows, and panes, and lets me quickly get to the pane I want.

https://github.com/Kristijan/fzf-pane-switch.tmux

Using the plugin with the default mapping of prefix + s, I now get a fzf window where I can narrow my search by filtering on the #{window_name}, #{pane_title}, or #{pane_current_command}. I’ve got a demo video below that shows it in action.

If you use tmux, hopefully you’ll see the benefit in using it.

This is enough information for me to quickly triage a security advisory and determine if I need to look into it in any further detail. However, looking at raw JSON data isn’t pretty, and I wanted it presented in a format that was a little more involved than what I could do with jq. I ended up writing something in python that you can find on my GitHub page that produces the below formatted table.

aix_security_advisories.py screenshot

I’m not using all the available data in the output. Additional items include a link to download a fix (if available) and a list of impacted filesets and versions. It’s not data that I need at a quick glance, and it’s all available at the advisory URL. If anyone wants that data included in the table, I welcome contributions, but also happy to add it in. All this is just me trying to have a better understanding of working with python, and making my day-to-day easier.

In a perfect world, I’d be manging the LPAR configurations using something like Terraform, but this currently isn’t an option. I can login to the HMC and manually verify the profiles (which is what I’ve been doing), but this is tedious and prone to error when you need to compare many profile pairs.

The HMC, a few major version releases ago, introduced a REST API that exposes all the profile data. I’ve written a script to collect this data, and present it in a more user friendly format for consumption. You can find the HMC profile diff script hosted on my GitHub.

Below are some screenshots of the script output.

Compare all LPAR profile attributes

Compare all LPAR profile attributes and only show differences

1. Don’t span paging logical volumes across different disks.
2. Create additional paging logical volumes of equal size. As paging space is allocated in a round-robin type manner, smaller paging spaces will fill up quicker than larger ones.
3. If you can’t increase the default paging logical volume hd6 to be equal size of all other additional paging logical volumes, deactivate it.

As a rule of thumb, I generally try and keep my rootvg volume groups relatively lean. I’ve been bitten way too often with failed multibos creations due to insufficient free capacity in the rootvg volume group. More often than not, this is because someone has increased the size of the hd6 paging space. Depending on the size of your rootvg, you may wish to impose a maximum size limit on the hd6 paging logical volume. Any requirements for an increase to (or additional) paging space, should be created on a separate volume.

If I have such a requirement for additional paging space (say the largest possible paging size of 64GB), I will create a separate volume group (for example, pagingvg) and allocate LUN’s of 64GB in size. Each paging logical volume will consume the entire LUN, and I will deactivate hd6 (see example below).

1
2
3
4
5
6
7
8
9
10
11
12
13
# lsps -a
Page Space      Physical Volume   Volume Group    Size %Used   Active    Auto    Type   Chksum
paging01        hdisk2            pagingvg     61344MB     0     yes     yes      lv       0
paging00        hdisk1            pagingvg     61344MB     0     yes     yes      lv       0
hd6             hdisk0            rootvg        8192MB     0      no     yes      lv       0
# lspv -l hdisk1
hdisk1:
LV NAME               LPs     PPs     DISTRIBUTION          MOUNT POINT
paging00              1917    1917    384..383..383..383..384 N/A
# lspv -l hdisk2
hdisk2:
LV NAME               LPs     PPs     DISTRIBUTION          MOUNT POINT
paging01              1917    1917    384..383..383..383..384 N/A

I then have the below script that runs at boot. It will deactivate the default paging device (hd6) if an alternate paging space is active, and greater in size.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
#!/bin/ksh
#
# Script      : deactivate_paging.sh
#
# Description : Script runs at boot and will deactivate the default
#               AIX paging device (hd6) if an alternate paging space is
#               active, and greater in size.
#
# Usage       : Script takes no parameters.

if lsps -ac | grep -Evq '^#|^hd6'; then
  # Get size of default paging space
  hd6_size=$(lsps -a | awk '/^hd6/{ print $4 }')

  # Create array of other paging space attributes
  set -A paging_name $(lsps -a | awk '!/^hd6/ && (NR!=1){ print $1 }')
  set -A paging_size $(lsps -a | awk '!/^hd6/ && (NR!=1){ print $4 }')
  set -A paging_active $(lsps -a | awk '!/^hd6/ && (NR!=1){ print $6 }')

  # Default paging space (hd6) will be turned off if any single
  # alternate paging space is active, and greater in size than
  # the default paging space
  count=0
  while [[ "${count}" -lt "${#paging_name[*]}" ]]; do
    if [[ ( "${paging_active[$count]}" = "yes" ) && ( "${paging_size[$count]%??}" -gt "${hd6_size%??}" ) ]]; then
      {
        echo "At least one alternate paging space detected and active [${paging_name[$count]}]"
        echo 'Deactivating default paging space hd6...'
        swapoff /dev/hd6
      } > /dev/console
      exit
    else
      (( count+=1 ))
    fi
  done
fi

Console output during system boot.

1
2
3
4
5
6
# alog -t console -o
...
...
...
         0 Mon Nov  7 10:23:14 AEDT 2022 At least one alternate paging space detected and active [paging00]
         0 Mon Nov  7 10:23:14 AEDT 2022 Deactivating default paging space hd6...

You can find some good information regarding paging space placement best practices on IBM’s website - https://www.ibm.com/support/pages/paging-space-placement-best-practices

Prepare NIM resources

There is a little setup work that you first need to perform on the NIM server to make this possible. At a minimum, on the NIM server, you will require a lpp_source resource to place the fixes in. Creating a lpp_source resource is outside the scope of this post, but you can find additional information here.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
(nim01) # lsnim -l 7200TL5SP4_lpp
7200TL5SP4_lpp:
   class       = resources
   type        = lpp_source
   comments    = AIX 7.2 TL5 SP4 lppsource
   arch        = power
   Rstate      = ready for use
   prev_state  = unavailable for use
   location    = /nim/lpp/7200TL5SP4_lpp
   simages     = yes
   alloc_count = 0
   server      = master
(nim01) # ls -l /nim/lpp/7200TL5SP4_lpp/emgr/ppc
total 64320
-rw-r--r--    1 root     system     28191901 Aug 16 00:49 1121201a.220804.epkg.Z
-rw-r--r--    1 root     system        49935 Jun 11 03:37 IJ39876s3a.220506.epkg.Z
-rw-r--r--    1 root     system      4683895 Aug 15 16:08 IJ41139m4a.220809.epkg.Z

Optionally, if you’re installing multiple fixes at the same time, you can create a NIM installp_bundle resource. Creating an installp_bundle resource is outside the scope of this post, but you can find additional information here.

1
2
3
4
5
6
7
8
9
10
(nim01) # lsnim -l 7200TL5SP4_emgr
7200TL5SP4_emgr:
   class       = resources
   type        = installp_bundle
   comments    = AIX 7.2 TL5 SP4 emgr_bundle
   Rstate      = ready for use
   prev_state  = unavailable for use
   location    = /nim/bundles/7200TL5SP4_emgr
   alloc_count = 0
   server      = master

Contents of /nim/bundles/7200TL5SP4_emgr

1
2
3
E:IJ39876s3a.220506.epkg.Z
E:IJ41139m4a.220809.epkg.Z
E:1121201a.220804.epkg.Z

Installing fixes on AIX hosts

You have two options when it comes to installing the fixes onto AIX hosts using the NIM server. You can either push the fixes from the NIM server to the AIX host, or you can pull the fixes from the AIX host.

Push

Installing a single fix from a NIM lpp_source resource.

1
2
3
4
5
6
7
(nim01) # nim -o cust -a lpp_source=7200TL5SP4_lpp -a filesets=E:1121201a.220804.epkg.Z aix01

Initializing log /var/adm/ras/emgr.log ...
EPKG NUMBER       LABEL               OPERATION              RESULT
===========       ==============      =================      ==============
1                 1121201a            INSTALL                SUCCESS
Return Status = SUCCESS

Installing multiple fixes from a NIM installp_bundle resource.

1
2
3
4
5
6
7
8
9
(nim01) # nim -o cust -a lpp_source=7200TL5SP4_lpp -a installp_bundle=7200TL5SP4_emgr aix01

Initializing log /var/adm/ras/emgr.log ...
EPKG NUMBER       LABEL               OPERATION              RESULT
===========       ==============      =================      ==============
1                 IJ39876s3a          INSTALL                SUCCESS
2                 IJ41139m4a          INSTALL                SUCCESS
3                 1121201a            INSTALL                SUCCESS
Return Status = SUCCESS

Pull

Installing a single fix from a NIM lpp_source resource.

1
2
3
4
5
6
7
(aix01) # nimclient -o cust -a lpp_source=7200TL5SP4_lpp -a filesets=E:1121201a.220804.epkg.Z

Initializing log /var/adm/ras/emgr.log ...
EPKG NUMBER       LABEL               OPERATION              RESULT
===========       ==============      =================      ==============
1                 1121201a            INSTALL                SUCCESS
Return Status = SUCCESS

Installing multiple fixes from a NIM installp_bundle resource.

1
2
3
4
5
6
7
8
9
(aix01) # nimclient -o cust -a lpp_source=7200TL5SP4_lpp -a installp_bundle=7200TL5SP4_emgr

Initializing log /var/adm/ras/emgr.log ...
EPKG NUMBER       LABEL               OPERATION              RESULT
===========       ==============      =================      ==============
1                 IJ39876s3a          INSTALL                SUCCESS
2                 IJ41139m4a          INSTALL                SUCCESS
3                 1121201a            INSTALL                SUCCESS
Return Status = SUCCESS

Deploying fixes at scale with Puppet Tasks

If you’re using Puppet Enterprise, and can use Puppet Tasks, here is one that allows you to install both a single fix, or multiple fixes using the above mentioned methods.

Task metadata

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
{
    "description": "A task for installing/uninstalling AIX fixes.",
    "parameters": {
        "install": {
            "description": "Set to true to install efix, or set to false to uninstall efix.",
            "type": "Boolean"
        },
        "lpp_source": {
            "description": "NIM lpp_source containing the efix(s).",
            "type": "String[1]"
        },
        "fix_name": {
            "description": "Name of a single efix to be installed/uninstalled.\n\tWhen installing, the 'fix_name' is the name of the package (e.g. IJ31191m1a.210322.epkg.Z).\n\tWhen uninstalling, the 'fix_name' is the name of the label (e.g. IJ31191m1a).",
            "type": "Optional[String[1]]"
        },
        "installp_bundle": {
            "description": "Name of installp_bundle to use when installing multiple efixes.",
            "type": "Optional[String[1]]"
        },
        "reboot": {
            "description": "If true, the system is rebooted after installing/uninstalling the efix(s).",
            "type": "Boolean"
        }
    },
    "puppet_task_version": 1,
    "supports_noop": false
}

Task

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
#!/opt/puppetlabs/puppet/bin/ruby
#
# A task for installing/uninstalling AIX fixes
require 'puppet'
require 'json'

# Set FACTERLIB so custom facts resolve
Puppet.initialize_settings
ENV['FACTERLIB'] = Puppet.settings['factpath']
require 'facter'

# Sanity check that we're an AIX host
if Facter.value(:operatingsystem) == "AIX" then
    params          = JSON.parse(STDIN.read)
    install         = params['install']
    lpp_source      = params['lpp_source']
    fix_name        = params['fix_name']
    installp_bundle = params['installp_bundle']
    reboot          = params['reboot']

    if install then
        # Check if we have either a fix_name or installp_bundle set
        if params.key?("installp_bundle") then
            fix = "installp_bundle=#{installp_bundle}"
        elsif params.key?("fix_name") then
            fix = "filesets=E:#{fix_name}"
        else
            print "You need to specify either a fix_name or installp_bundle."
            exit(2)
        end

        # Install efix(s)
        system("/usr/sbin/nimclient", "-o", "cust", "-a", "lpp_source=#{lpp_source}", "-a", "#{fix}")
        if $?.exitstatus != 0
            print "efix failed to install."
            exit(2)
        end
    else
        # Uninstall efix
        if params.key?("fix_name") then
            system("/usr/sbin/nimclient", "-o", "cust", "-a", "lpp_source=#{lpp_source}", "-a", "filesets=E:#{fix_name}", "-a", "installp_flags=u")
            if $?.exitstatus != 0
                print "efix failed to uninstall."
                exit(2)
            end
        else
            print "You need to specify a fix_name to uninstall."
        end
    end

    # Reboot
    if reboot then
        system("/usr/bin/echo '/usr/sbin/shutdown -r +3' | /usr/bin/at now")
    end
else
  print "Task only supported on AIX."
  exit(1)
end

Running the Task

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
$ puppet task show patch::aix_efix

patch::aix_efix - A task for installing/uninstalling AIX fixes.

USAGE:
$ puppet task run patch::aix_efix install=<value> lpp_source=<value> reboot=<value> [fix_name=<value>] [installp_bundle=<value>] <[--nodes, -n <node-names>] | [--query, -q <'query'>]>

PARAMETERS:
- install : Boolean
    Set to true to install efix, or set to false to uninstall efix.
- lpp_source : String[1]
    NIM lpp_source containing the efix(s).
- reboot : Boolean
    If true, the system is rebooted after installing/uninstalling the efix(s).
- fix_name : Optional[String[1]]
    Name of a single efix to be installed/uninstalled.
        When installing, the 'fix_name' is the name of the package (e.g. IJ31191m1a.210322.epkg.Z).
        When uninstalling, the 'fix_name' is the name of the label (e.g. IJ31191m1a).
- installp_bundle : Optional[String[1]]
    Name of installp_bundle to use when installing multiple efixes.

$ puppet task run patch::aix_efix install=true lpp_source=7200TL5SP4_lpp reboot=false installp_bundle=7200TL5SP4_emgr -n aix01
Starting job ...
Note: The task will run only on permitted nodes.
New job ID: 83786
Nodes: 1

Started on aix01 ...
Finished on node aix01
  STDOUT:

    Initializing log /var/adm/ras/emgr.log ...
    EPKG NUMBER       LABEL               OPERATION              RESULT
    ===========       ==============      =================      ==============
    1                 IJ39876s3a          INSTALL                SUCCESS
    2                 IJ41139m4a          INSTALL                SUCCESS
    3                 1121201a            INSTALL                SUCCESS
    Return Status = SUCCESS

Job completed. 1/1 nodes succeeded.
Duration: 1 min, 3 sec

Using EZH functions originally written by Brian Smith, I’ve added a function named lparwwpn that takes a list of LPAR names as arguments, and prints the virtual fibre channel WWPNs.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
kristijan@hmc:~> source lparwwpn
kristijan@hmc:~> lparwwpn aix1 aix2

aix1 [POWER-FRAME-1]
c0XXXXXXXXXXXXf2,c0XXXXXXXXXXXXf3
c0XXXXXXXXXXXXf4,c0XXXXXXXXXXXXf5
c0XXXXXXXXXXXXf6,c0XXXXXXXXXXXXf7
c0XXXXXXXXXXXXf8,c0XXXXXXXXXXXXf9

aix2 [POWER-FRAME-2]
c0XXXXXXXXXXXX20,c0XXXXXXXXXXXX21
c0XXXXXXXXXXXX22,c0XXXXXXXXXXXX23
c0XXXXXXXXXXXX24,c0XXXXXXXXXXXX25
c0XXXXXXXXXXXX26,c0XXXXXXXXXXXX27

Save the contents of the shell script below to a file named lparwwpn, and copy it over to the HMC.

You can name the file anything you like, just adjust the source command above accordingly.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
lparframelookup () {
    while read -r system; do
        while read -r lpar; do
            if [ "$lpar" = "$*" ]; then
                echo "${system}";
            fi
        done < <(lssyscfg -m "$system" -r lpar -F name)
    done < <(lssyscfg -r sys -F "name,state" | grep -E "Standby|Operating" | cut -d, -f 1) | tail -n 1
}

checklpar () {
    count=0;
    if [ -n "$1" ]; then
        while read -r system; do
            while read -r l; do
                if [ "$l" = "$1" ] ; then
                    count=$((count +1))
                fi
            done < <(lssyscfg -m "$system" -r lpar -F name)
        done < <(lssyscfg -r sys -F "name,state" | grep -E "Standby|Operating" | cut -d, -f 1)
        l=""
        if [ $count -eq 0 ]; then
            echo "ERROR:  LPAR not found: $1"
            return 1
        fi
        if [ $count -gt 1 ]; then
            echo "ERROR:  Multiple LPAR's with same name $1"
            return 2
        fi
    else
        unset input
        unset lpararray
        echo "Select LPAR: "
        while read -r system; do
            while read -r l; do
                count=$((count +1))
                printf "%5s. %-20s %-20s\n" $count "$l" "$(lssyscfg -r lpar -m \""${system}"\" -F state --filter lpar_names=\""${l}"\")"
                lpararray[$count]="$l"
            done < <(lssyscfg -m "$system" -r lpar -F name)
        done < <(lssyscfg -r sys -F "name,state" | grep -E "Standby|Operating" | cut -d, -f 1)
        echo
        while [ -z "${lpararray[$input]}" ]; do
            printf "%s\n" "Enter LPAR number (1-$count, \"q\" to quit): ";
            read -r input
            if [ "$input" = "q" -o "$input" = "Q" ]; then return 1; fi
        done
        lpar="${lpararray[$input]}"
        checklpar "$lpar" || return 2
    fi
}

lparwwpn () {
    for lpar in "$@"; do
        frame=$(lparframelookup "${lpar}")
        printf "\n%s [%s]\n" "${lpar}" "${frame}"
        checklpar "$lpar" && eval lshwres -m "${frame}" -r virtualio --rsubtype fc --level lpar --filter \"lpar_names="${lpar}"\" | cut -d '=' -f11 | sed 's/\"//' | sort;
    done
}

I’ve recently come across EEZH, which appears to be a fork of Brian Smith’s original EZH code. Might be more beneficial to add lparwwpn into that project.

While we’re on the subject of displaying WWPNs, here is a recent post from Chris Gibson on Displaying WWPN information on Power10 Systems.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
kristijan@aix13 # nimclient -l -L -t mksysb aix13 | grep aix13
aix13_220720_img     mksysb
aix13_220713_img     mksysb
kristijan@aix13 # nimclient -l -l aix13_220720_img
aix13_220720_img:
   class         = resources
   type          = mksysb
   creation_date = Wed Jul 20 00:17:25 2022
   source_image  = aix13
   arch          = power
   Rstate        = ready for use
   prev_state    = unavailable for use
   location      = /mksysb/aix13/aix13_220720_img
   version       = 7
   release       = 2
   mod           = 5
   oslevel_r     = 7200-05
   oslevel_s     = 7200-05-04-2220
   alloc_count   = 0
   server        = master

In my AIX environment, I define a “valid” mksysb as one that was created within the last 2 weeks. Anything created after that date I’d be hesitant in restoring from. Parsing the creation_date with a shell script isn’t all that elegant. The python datetime module allows us to parse this easily.

The script does assume (on line 18) that your NIM mksysb resource names contain the hostname you’re running the script from.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
#!/usr/bin/env python3
#
# Check that there is at least one mksysb for the client, and
# that the creation date of the mksysb is not older than 15 days

import sys
import socket
import subprocess
from datetime import datetime

# Get hostname
hostname = socket.gethostname()

# Get current time
current_time = datetime.now()

# Create list of mksysb resources from the NIM server
nim_mksysb_list = subprocess.check_output(f"/usr/sbin/nimclient -l -L -t mksysb {hostname} | /usr/bin/awk '/{hostname}/{{ print $1 }}'", shell=True, encoding='utf-8').split()
# If the subprocess above returns no values, the result is a
# single item list with an empty string. Let's strip that out.
nim_mksysb_list = filter(None, nim_mksysb_list)

# Parse list of NIM mksysb backups and compare creation date
if nim_mksysb_list:
    for mksysb in nim_mksysb_list:
        mksysb_creation_time = subprocess.check_output(f"/usr/sbin/nimclient -l -l {mksysb} | /usr/bin/awk -F = '/creation_date/{{ print $2 }}'", shell=True, encoding='utf-8').strip()
        mksysb_creation_time = datetime.strptime(''.join(mksysb_creation_time), '%c')
        elapsed = current_time - mksysb_creation_time
        if elapsed.days < 15:
            # mksysb found on NIM and is not older than 15 days
            sys.exit(0)
else:
    # List is empty, no mksysb backups on NIM.
    sys.exit(1)

# If we've made it this far, all mksysb's are older than 15 days
sys.exit(2)

The above script will return the following exit codes:

The use of exit codes to determine the validity of a mksysb is because its intended use is part of a larger pipeline of checks that occur before an AIX LPAR is patched. It forms one of many pre-checks that are run on an AIX LPAR before it’s deemed healthy to be patched.

For those currently using SDDPCM, removing the driver can be somewhat complicated, and even more so when the boot LUN (rootvg LUN) is being managed by SDDPCM. Buried deep in the Multipath Subsystem Device Driver Users Guide is a command called manage_disk_drivers. The manage_disk_drivers command can be used to display a list of storage families, and the driver that manages or supports each family. The command also allows us to easily switch (with a reboot if you boot from an SDDPCM managed device) the driver from SDDPCM to AIXPCM (or vice versa). Below I detail how to switch from SDDPCM to AIXPCM when using LUN’s presented to the host via SVC.

Existing driver manging IBMSVC

From the man page for manage_disk_drivers

If the present driver attribute is set to NO_OVERRIDE, the AIX operating system selects an alternate path control module (PCM), such as Subsystem Device Driver Path Control Module (SDDPCM), if it is installed.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# manage_disk_drivers -l
Device              Present Driver        Driver Options
2810XIV             AIX_AAPCM             AIX_AAPCM,AIX_non_MPIO
DS4100              AIX_SDDAPPCM          AIX_APPCM,AIX_SDDAPPCM
DS4200              AIX_SDDAPPCM          AIX_APPCM,AIX_SDDAPPCM
DS4300              AIX_SDDAPPCM          AIX_APPCM,AIX_SDDAPPCM
DS4500              AIX_SDDAPPCM          AIX_APPCM,AIX_SDDAPPCM
DS4700              AIX_SDDAPPCM          AIX_APPCM,AIX_SDDAPPCM
DS4800              AIX_SDDAPPCM          AIX_APPCM,AIX_SDDAPPCM
DS3950              AIX_SDDAPPCM          AIX_APPCM,AIX_SDDAPPCM
DS5020              AIX_SDDAPPCM          AIX_APPCM,AIX_SDDAPPCM
DCS3700             AIX_APPCM             AIX_APPCM
DCS3860             AIX_APPCM             AIX_APPCM
DS5100/DS5300       AIX_SDDAPPCM          AIX_APPCM,AIX_SDDAPPCM
DS3500              AIX_APPCM             AIX_APPCM
XIVCTRL             MPIO_XIVCTRL          MPIO_XIVCTRL,nonMPIO_XIVCTRL
2107DS8K            NO_OVERRIDE           NO_OVERRIDE,AIX_AAPCM,AIX_non_MPIO
IBMFlash            NO_OVERRIDE           NO_OVERRIDE,AIX_AAPCM,AIX_non_MPIO
IBMSVC              NO_OVERRIDE           NO_OVERRIDE,AIX_AAPCM,AIX_non_MPIO

Switch to using AIXPCM

1
2
3
# manage_disk_drivers -d IBMSVC -o AIX_AAPCM
 ********************** ATTENTION *************************
  For the change to take effect the system must be rebooted

After the reboot, you will now see AIX_AAPCM as the present driver being used.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# manage_disk_drivers -l
Device              Present Driver        Driver Options
2810XIV             AIX_AAPCM             AIX_AAPCM,AIX_non_MPIO
DS4100              AIX_SDDAPPCM          AIX_APPCM,AIX_SDDAPPCM
DS4200              AIX_SDDAPPCM          AIX_APPCM,AIX_SDDAPPCM
DS4300              AIX_SDDAPPCM          AIX_APPCM,AIX_SDDAPPCM
DS4500              AIX_SDDAPPCM          AIX_APPCM,AIX_SDDAPPCM
DS4700              AIX_SDDAPPCM          AIX_APPCM,AIX_SDDAPPCM
DS4800              AIX_SDDAPPCM          AIX_APPCM,AIX_SDDAPPCM
DS3950              AIX_SDDAPPCM          AIX_APPCM,AIX_SDDAPPCM
DS5020              AIX_SDDAPPCM          AIX_APPCM,AIX_SDDAPPCM
DCS3700             AIX_APPCM             AIX_APPCM
DCS3860             AIX_APPCM             AIX_APPCM
DS5100/DS5300       AIX_SDDAPPCM          AIX_APPCM,AIX_SDDAPPCM
DS3500              AIX_APPCM             AIX_APPCM
XIVCTRL             MPIO_XIVCTRL          MPIO_XIVCTRL,nonMPIO_XIVCTRL
2107DS8K            NO_OVERRIDE           NO_OVERRIDE,AIX_AAPCM,AIX_non_MPIO
IBMFlash            NO_OVERRIDE           NO_OVERRIDE,AIX_AAPCM,AIX_non_MPIO
IBMSVC              AIX_AAPCM             NO_OVERRIDE,AIX_AAPCM,AIX_non_MPIO

From here, you can do one of two things. Leave the SDDPCM driver installed, as this will allow for easy rollback should you experience performance issues, or other driver related problems. Or completely remove the SDDPCM driver from the LPAR.

A few things to keep in mind.

• If you’ve modified the queue_depth attribute on the hdisk, this will be reset to the AIXPCM default of 20. There is already a good write up on best practises and considerations when working with the default AIXPCM driver.
• When using SDDPCM, you would have used the pcmpath command to display and manage devices. As above, someone has already written a good write up on resiliency and problem determination, and some common lsmpio commands you’ll want to know.

Taking the IBM recommendations into account, I’ll set the hdisk attributes accordingly.

1
2
3
# lsdev -Cc disk -F name | while read -r hdisk; do chdev -l ${hdisk} -a queue_depth=32 -a reserve_policy=no_reserve -a algorithm=shortest_queue -P; done
hdisk0 changed
hdisk1 changed

Another handy command, which isn’t related to the overall driver migration, is using chdef to change the default values of the predefined attributes in ODM. Any future LUN’s presented to the host will now have the queue_depth, reserve_policy, and algorithm set to the values I want.

1
2
3
4
5
6
# chdef -a queue_depth=32 -c disk -s fcp -t mpioosdisk
queue_depth changed
# chdef -a reserve_policy=no_reserve -c disk -s fcp -t mpioosdisk
reserve_policy changed
# chdef -a algorithm=shortest_queue -c disk -s fcp -t mpioosdisk
algorithm changed

Rollback

Should you need to go back to using SDDPCM as the driver, and haven’t removed it, you can use manage_disk_drivers to flip back and reboot.

1
2
3
# manage_disk_drivers -d IBMSVC -o NO_OVERRIDE
 ********************** ATTENTION *************************
 For the change to take effect the system must be rebooted

• System type
• System serial number
• Anchor card CCIN
• Anchor card serial number
• Anchor card unique identifier
• Resource identifier
• Activate resources
• Sequence number
• Entry check

All this information can be gathered from either the HMC GUI or the CLI. Preferring to work on the CLI, I’ve written a function (inspiration from Brian Smith) that collects and generates all the data the website requires in a nice to read format (well, nicer to read than what’s presented via the lscod command).

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
kristijan@hmc:~> source onoffdetails
 
kristijan@hmc:~> onoffdetails
Usage: onoffdetails [managed system] [mem | proc]
 
kristijan@hmc:~> onoffdetails 9119-FHB-SN1234567 mem
 
Memory details for 9119-FHB-SN1234567
 
                   System type : 9119
          System serial number : 12-34567
              Anchor card CCIN : 52C4
     Anchor card serial number : 00-236D000
 Anchor card unique identifier : 316405567831037C
           Resource identifier : D973
            Activate resources : 0540
               Sequence number : 0046
                   Entry check : A3
 
kristijan@hmc:~> onoffdetails 9119-FHB-SN1234567 proc
 
Processor details for 9119-FHB-SN1234567
 
                   System type : 9119
          System serial number : 12-34567
              Anchor card CCIN : 52C4
     Anchor card serial number : 00-236D000
 Anchor card unique identifier : 316405567831037C
           Resource identifier : D971
            Activate resources : 0450
               Sequence number : 0045
                   Entry check : A1

Function code is below, you just need to copy it over to the HMC, and then source it after you’ve logged in.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
# Script: onoffdetails
#
# Usage: Gathers all the details required to self request On/Off
#        Capacity on Demand from IBM's self-service portal.
#        (https://www-304.ibm.com/support/customercare/ss/escod/home)
#
# Change log:
#    Date       Who                   Comment
#    ----       --                    -------
#    18/11/15   Kristian Milos        Initial write.
#
onoffdetails () {
if [ $# -lt 2 ]; then
       printf "Usage: onoffdetails [managed system] [mem | proc]\n"
else
       COUNT=0
       ERROR=0
       while read SYSTEM; do
              if [ "${SYSTEM}" = "$1" ] ; then
                     COUNT=$((COUNT +1))
              fi
       done < <(lssyscfg -r sys -F "name")
       if [ ${COUNT} -eq 0 ]; then
              printf "\nERROR:  System not found: $1\n\n"
              printf "Known managed systems:\n"
              lssyscfg -r sys -F name
              ERROR=1
       fi
 
       if [[ $2 = "mem" || $2 = "proc" && ${ERROR} != 1 ]]; then
              SYSTEM=$1
              RESOURCE=$2
 
              sys_type=$(lscod -m ${SYSTEM} -t code -r ${RESOURCE} -c onoff -F sys_type)
              sys_serial_num=$(lscod -m ${SYSTEM} -t code -r ${RESOURCE} -c onoff -F sys_serial_num)
              anchor_card_ccin=$(lscod -m ${SYSTEM} -t code -r ${RESOURCE} -c onoff -F anchor_card_ccin)
              anchor_card_serial_num=$(lscod -m ${SYSTEM} -t code -r ${RESOURCE} -c onoff -F anchor_card_serial_num)
              anchor_card_unique_id=$(lscod -m ${SYSTEM} -t code -r ${RESOURCE} -c onoff -F anchor_card_unique_id)
              resource_id=$(lscod -m ${SYSTEM} -t code -r ${RESOURCE} -c onoff -F resource_id)
              activated_resources=$(lscod -m ${SYSTEM} -t code -r ${RESOURCE} -c onoff -F activated_resources)
              sequence_num=$(lscod -m ${SYSTEM} -t code -r ${RESOURCE} -c onoff -F sequence_num)
              entry_check=$(lscod -m ${SYSTEM} -t code -r ${RESOURCE} -c onoff -F entry_check)
 
              if [ ${RESOURCE} == "mem" ]; then
                     printf "\nMemory details for ${SYSTEM}\n\n"
              elif [ ${RESOURCE} == "proc" ]; then
                     printf "\nProcessor details for ${SYSTEM}\n\n"
              fi
              printf "                   System type : ${sys_type}\n"
              printf "          System serial number : ${sys_serial_num}\n"
              printf "              Anchor card CCIN : ${anchor_card_ccin}\n"
              printf "     Anchor card serial number : ${anchor_card_serial_num}\n"
              printf " Anchor card unique identifier : ${anchor_card_unique_id}\n"
              printf "           Resource identifier : ${resource_id}\n"
              printf "            Activate resources : ${activated_resources}\n"
              printf "               Sequence number : ${sequence_num}\n"
              printf "                   Entry check : ${entry_check}\n"
       else
              printf "\nUsage: onoffdetails [managed system] [mem | proc]\n"
       fi
fi
}