Like many things in C, we start defining a structure, but this structure is a required IBM stuff and it looks this way, store that in a file called create_class.cre:

class mystuff {
  char		Customer[100];
  int		ActivationDate;
  int		ExpirationDate;
  char		Key[100];
  char		Product[100];
  char		Version[100];
};

Then, let’s define some functions in an odm.h file:

#include <stdio.h>
#include <stdlib.h>
#include <odmi.h>
#include <errno.h>
#include <strings.h>
#include <time.h>
#include <unistd.h>

#include "create_class.h"

typedef struct mystuff mystuff_t;

#define TRIAL_PERIOD  2592000

int create_odm_class();
int write_odm();
int check_odm_class();
mystuff_t *read_odm();

And then the implementation of these functions in odm.c:

#include "odm.h"

#ifdef __PPC__

int create_odm_class() {
  char *error_message;

  if(DEBUG>1) printf("Creation of class mystuff.\n");
  syslog(LOG_DEBUG, "Creation of ODM class.");
  if(odm_create_class(mystuff_CLASS)!=0) {
    odm_err_msg ( odmerrno, &error_message );
    if(DEBUG>1) printf("Problem accessing ODM. %s", error_message);
    syslog(LOG_ERR, "Problem accessing ODM. %s", error_message);
    return(1);
  }

  return(0);
}

int write_odm() {
  struct mystuff *data2write;
  data2write=(struct mystuff*)malloc(sizeof(struct mystuff));

  time_t now = time(NULL);

  data2write->ActivationDate = now;

  odm_add_obj(mystuff_CLASS, data2write);
  return(0);
}

int check_odm_class() {
  char *error_message;

  if(odm_mount_class("mystuff")==(CLASS_SYMBOL)-1) {
    odm_err_msg ( odmerrno, &error_message );
    if(DEBUG>1) printf("[check_odm_class] Error searching for class mystuff #%d: %s\n", odmerrno, error_message);
    syslog(LOG_ERR, "[check_odm_class] Error searching for class mystuff #%d: %s", odmerrno, error_message);
    if(odmerrno==0) {
      create_odm_class();
      write_odm();
    } else {
      if(DEBUG) printf("[create_odm_class] Class mystuff created successfully.\n");
      syslog(LOG_DEBUG, "[create_odm_class] Class mystuff created successfully.");
    }
  }

  return(0);
}

mystuff_t *read_odm() {
  struct tm ts;
  char buf[80];
  mystuff_t *data2read;
  data2read=(struct mystuff*)malloc(sizeof(struct mystuff));

  odm_get_first(mystuff_CLASS, NULL, data2read);
  if(DEBUG>1) {
    ts = *localtime((const time_t *)&data2read->ActivationDate);
    strftime(buf, sizeof(buf), "%a %Y-%m-%d %H:%M:%S %Z", &ts);
    printf("\n[read_odm] Activation Date: %ld [%s]\n", data2read->ActivationDate, buf);
    printf("[read_odm] Customer: %s\n", data2read->Customer);
    printf("[read_odm] Key: %s\n", data2read->Key);
    printf("\n");
  }
  syslog(LOG_DEBUG, "[read_odm] Activation Date: %ld; Key: %s", data2read->ActivationDate, data2read->Key);

  return(data2read);
}

Alright, that looks sexy but what do I do with all this mess buddy!? That:

int main(int argc, char **argv) {
  check_odm_class();
  return(0);
}

And this is already the time for compilation baby! Here is your Makefile:

CC=gcc
OS ?= $(shell uname -s)
CFLAGS=-g -ggdb -Wall 
LFLAGS=-L/opt/freeware/lib
LDFLAGS=-lodm -lerrlog -lm

SRC:= src

all: mystuff

src/create_class.o:
	/usr/bin/odmcreate -h src/create_class.cre
	$(CC) -g -ggdb  -c src/create_class.c -o src/create_class.o

%.o: $(SRC)/%.c
	$(CC) $(CFLAGS) -c $< -o $@

mystuff: src/create_class.o src/odm.o
	$(CC) $(CFLAGS) $(LFLAGS) $(LDFLAGS) src/main.c src/create_class.o src/odm.o -o build/mystuff 

clean:
	\rm -f build/mystuff src/*.o .toc src/create_class.?

If you do not understand it all, do not call me, I am in holidays.
So that means you can literally store anything in the ODM and access and read it back anytime with this set of functions. Be aware that anyone with ODM skills can access them also using the set of get_odm commands. So for sensitive informations, you will need to encrypt that.

Have fun! I’ll see you next time.

- name: Create stuffvg and its filesystems
  hosts: target
  remote_user: root
  collections:
    - ibm.power_aix
  var:
    prefix: "stuff"

  tasks:
  - name: Be sure the wanted disks are usable with a cfgmgr
    ansible.builtin.shell: cfgmgr

  - name: Create "{{ prefix }}vg"
    ibm.power_aix.lvg:
      state: present
      vg_name: "{{ prefix }}vg"
      pvs: hdisk1
      vg_type: scalable

At this stage we already have a scalable Volume Group named stuffvg. Now, let’s add some filesystems in it but first thing first, we then need to create the jfs2log LV:

  - name: Create the jfs2Log lv
    aix_lvol:
      vg: "{{ prefix }}vg" 
      lv: stuffj2log
      lv_type: jfs2log
      size: 128M

  - name: Logform the jfs2log
    ansible.builtin.shell: yes | /usr/sbin/logform -V jfs2 /dev/stuffj2log

Now we are ready to create our Logical Volumes:

  - name: Create LVs
    aix_lvol:
      vg: "{{ prefix }}vg"
      lv: 	"{{ item.name }}"
      lv_type: 	"{{ item.type }}"
      size: 	"{{ item.size }}"
    loop:
      - { name: 'stuff_users',	type: 'jfs2', 	size: '20G' }
      - { name: 'stuffora19c',	type: 'jfs2', 	size: '2G' }
      - { name: 'stuff_ora', 	type: 'jfs2', 	size: '3G' }

Now it’s time to create JFS2 filesystems on our freshly made LV, and to mount them:

 - name: Creation of JFS2 filesystems
    ibm.power_aix.filesystem:
      state:		present
      device: 	  	"{{ item.device }}"
      filesystem: 	"{{ item.mountpoint }}"
      fs_type:		jfs2
      auto_mount:	true
    loop:
      - { device: 'stuffora',	        mountpoint: '/home/oracle' }
      - { device: 'stuff_users',	mountpoint: '/home/users' }
      - { device: 'stuffora19c',	mountpoint: '/home/oracle/product/v19c' }

  - name: Mount FS
    ansible.builtin.shell: mount "{{ item }}"
    with_items:
      - "/home/oracle"
      - "/home/users"
      - "/home/oracle/product/v19c"

Last but not least, some exotic stuff to finish, as I know you are kind of that:

  - name: chlv -x 3000 hd1
    ibm.power_aix.lvol:
      vg: rootvg
      lv: hd1
      extra_opts: "-x 3000"

  - name: Increase size of a filesystem
    ibm.power_aix.filesystem:
      filesystem: /home
      state: present
      attributes: size=25G

And here we are. No more excuse to create twice the same FS.

I’ll see you next time.

rendev -l hdisk1 -n aix53_rootvg
mkwpar -D devname=aix53_rootvg rootvg=yes -C -B /mksysb/mksysb0139 -t -n aix53 -l -O
[...]

Once created, you can then wait for the migration day with confidence. Once the source lpar has been shutdowned, configure the IP addresses into the wpar:

chwpar -N interface=en0 address=10.30.191.130 netmask=255.255.255.0 aix53
chwpar -N interface=en0 address=10.30.191.131 netmask=255.255.255.0 aix53
chwpar -N interface=en0 address=10.30.191.132 netmask=255.255.255.0 aix53

chwpar -N interface=en1 address=10.30.194.130 netmask=255.255.255.0 aix53
chwpar -N interface=en1 address=10.30.194.131 netmask=255.255.255.0 aix53
chwpar -N interface=en1 address=10.30.194.132 netmask=255.255.255.0 aix53

You can do so for multiple addresses, including IP aliases into the wpar on the same physical interface/

To map new or migrated disks (by SAN for example), you can use this same chwpar command:

chwpar -D devname=hdisk2 devtype=disk aix53
chwpar -D devname=hdisk3 devtype=disk aix53
chwpar -D devname=hdisk4 devtype=disk aix53

Once the disks are added, login into the wpar using clogin, and pass a cfgmgr in order to load the newly mapped disks. You should then be able to import your Volume Group and or create a new one.

Have fun :/

[root@aixboix /root]# devrsrv -f -c release -l hdisk28
Device Reservation State Information
==================================================
Device Name                     :  hdisk28
Device Open On Current Host?    :  YES
ODM Reservation Policy          :  NO RESERVE
Device Reservation State        :  SINGLE PATH RESERVE
Device is currently Open on this host by a process.
Do you want to continue y/n:y
The command was successful.
The reservation has been cleared on the device.

Simply.

Then, I advice to clear up the errpt logs and check few minutes later if no new error log appeared:

[root@aix ~]# errclear 0
[root@aixbox ~]# 

Remember you can visualize your disk pathes ID, parents device, WWPN, LUN number and its status with the following lspah options:

[root@aix ~]# for D in `lspv | awk {' print $1 '}`; do echo $D: ; lspath -l $D -F"path_id;connection:parent:path_status:status" ; echo ;  done
hdisk130:
0;524a9376d185dd12,ca000000000000:fscsi4:Available:Enabled
1;524a9376d185dd02,ca000000000000:fscsi5:Available:Enabled

hdisk12:
0;524a9376d185dd12,e0000000000000:fscsi4:Available:Enabled
1;524a9376d185dd02,e0000000000000:fscsi5:Available:Enabled

 - name: Extract bos.mp64 fileset version
   ibm.power_aix.lpp_facts:
     filesets:
       - bos.adt.base
       - bos.adt.lib
       - bos.mp64

Then we extract the version string from the dict:

  - set_fact:
      version_string: "{{ item.key }}"
    loop: "{{ ansible_facts.filesets['bos.mp64'].levels | dict2items }}"
    when: item.value.vrmf is defined
    register: version_fact

  - name: Check bos.mp64 version
    debug:
      msg: "ifix #IJ04311 needs to be applied: bos.mp64 {{ version_string }}."
    when: "'bos.mp64' in ansible_facts.filesets and version_string is version('7.1.5.43', '<')"

And finally the playbook output:

ok: [aixbox] => 
(item=
  {'key': '7.1.5.43', 
   'value': 
     {'vrmf': 
       {'ver': 7, 'rel': 1, 'mod': 5, 'fix': 43},
       'state': 'committed',
       'type': 'install',
       'description': 'Base Operating System 64-bit Multiprocessor Runtime',
       'emgr_locked': False,
       'sources': ['/usr/lib/objrepos', '/etc/objrepos']
       }
    }
) => {"ansible_facts": 
       {"version_string": "7.1.5.43"},
       "ansible_loop_var": "item",
       "changed": false,
       "item": 
       {"key": "7.1.5.43",
        "value": 
          {"description": "Base Operating System 64-bit Multiprocessor Runtime", 
           "emgr_locked": false,
           "sources": ["/usr/lib/objrepos", "/etc/objrepos"],          
           "state": "committed",
           "type": "install",
           "vrmf": 
             {"fix": 43, "mod": 5, "rel": 1, "ver": 7}
          }
        }
      }

TASK [Check bos.mp64 version]
skipping: [aixbox] => 
  {"false_condition": 
    "'bos.mp64' in ansible_facts.filesets and version_string is version('7.1.5.43', '<')"}

 Yes, you are welcomed. ^^