partitions: add aix lvm partition support files
authorPhilippe De Muyter <phdm@macqel.be>
Mon, 8 Jul 2013 23:01:29 +0000 (16:01 -0700)
committerLinus Torvalds <torvalds@linux-foundation.org>
Tue, 9 Jul 2013 17:33:28 +0000 (10:33 -0700)
Add partitions/aix.h and partitions/aix.c.

AIX LVM permits to make "logical volumes" which are made of multiple
slices of multiple disks.  The new code allows only access to the
"logical volumes" which are made of one slice on the probed disk, a
slice being a contiguous disk area.  The code also detects "logical
volumes" made of multiple slices on the probed disk, but can not
describe them to the partition layer, because the partition layer
generic code does not support that.  When such non-contiguous "logical
volumes" are detected, a diagnostic message is printed.

[akpm@linux-foundation.org: coding-style fixes]
Signed-off-by: Philippe De Muyter <phdm@macqel.be>
Cc: Karel Zak <kzak@redhat.com>
Cc: Jens Axboe <axboe@kernel.dk>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
block/partitions/Kconfig
block/partitions/Makefile
block/partitions/aix.c [new file with mode: 0644]
block/partitions/aix.h [new file with mode: 0644]

index 75a54e1adbb5b58ea0fa8dfaad2e1ae0cffc30f0..4cebb2f0d2f406d6b11af7aad8e70c3d50bf3232 100644 (file)
@@ -68,6 +68,17 @@ config ACORN_PARTITION_RISCIX
          of machines called RISCiX.  If you say 'Y' here, Linux will be able
          to read disks partitioned under RISCiX.
 
+config AIX_PARTITION
+       bool "AIX basic partition table support" if PARTITION_ADVANCED
+       help
+         Say Y here if you would like to be able to read the hard disk
+         partition table format used by IBM or Motorola PowerPC machines
+         running AIX.  AIX actually uses a Logical Volume Manager, where
+         "logical volumes" can be spread across one or multiple disks,
+         but this driver works only for the simple case of partitions which
+         are contiguous.
+         Otherwise, say N.
+
 config OSF_PARTITION
        bool "Alpha OSF partition support" if PARTITION_ADVANCED
        default y if ALPHA
index 03af8eac51da81bf4f89cc49d7d9ca466d38c54b..2be4d7ba4e3ab4a3615cc3beb814b66f981b2619 100644 (file)
@@ -7,6 +7,7 @@ obj-$(CONFIG_BLOCK) := check.o
 obj-$(CONFIG_ACORN_PARTITION) += acorn.o
 obj-$(CONFIG_AMIGA_PARTITION) += amiga.o
 obj-$(CONFIG_ATARI_PARTITION) += atari.o
+obj-$(CONFIG_AIX_PARTITION) += aix.o
 obj-$(CONFIG_MAC_PARTITION) += mac.o
 obj-$(CONFIG_LDM_PARTITION) += ldm.o
 obj-$(CONFIG_MSDOS_PARTITION) += msdos.o
diff --git a/block/partitions/aix.c b/block/partitions/aix.c
new file mode 100644 (file)
index 0000000..43be471
--- /dev/null
@@ -0,0 +1,293 @@
+/*
+ *  fs/partitions/aix.c
+ *
+ *  Copyright (C) 2012-2013 Philippe De Muyter <phdm@macqel.be>
+ */
+
+#include "check.h"
+#include "aix.h"
+
+struct lvm_rec {
+       char lvm_id[4]; /* "_LVM" */
+       char reserved4[16];
+       __be32 lvmarea_len;
+       __be32 vgda_len;
+       __be32 vgda_psn[2];
+       char reserved36[10];
+       __be16 pp_size; /* log2(pp_size) */
+       char reserved46[12];
+       __be16 version;
+       };
+
+struct vgda {
+       __be32 secs;
+       __be32 usec;
+       char reserved8[16];
+       __be16 numlvs;
+       __be16 maxlvs;
+       __be16 pp_size;
+       __be16 numpvs;
+       __be16 total_vgdas;
+       __be16 vgda_size;
+       };
+
+struct lvd {
+       __be16 lv_ix;
+       __be16 res2;
+       __be16 res4;
+       __be16 maxsize;
+       __be16 lv_state;
+       __be16 mirror;
+       __be16 mirror_policy;
+       __be16 num_lps;
+       __be16 res10[8];
+       };
+
+struct lvname {
+       char name[64];
+       };
+
+struct ppe {
+       __be16 lv_ix;
+       unsigned short res2;
+       unsigned short res4;
+       __be16 lp_ix;
+       unsigned short res8[12];
+       };
+
+struct pvd {
+       char reserved0[16];
+       __be16 pp_count;
+       char reserved18[2];
+       __be32 psn_part1;
+       char reserved24[8];
+       struct ppe ppe[1016];
+       };
+
+#define LVM_MAXLVS 256
+
+/**
+ * last_lba(): return number of last logical block of device
+ * @bdev: block device
+ *
+ * Description: Returns last LBA value on success, 0 on error.
+ * This is stored (by sd and ide-geometry) in
+ *  the part[0] entry for this disk, and is the number of
+ *  physical sectors available on the disk.
+ */
+static u64 last_lba(struct block_device *bdev)
+{
+       if (!bdev || !bdev->bd_inode)
+               return 0;
+       return (bdev->bd_inode->i_size >> 9) - 1ULL;
+}
+
+/**
+ * read_lba(): Read bytes from disk, starting at given LBA
+ * @state
+ * @lba
+ * @buffer
+ * @count
+ *
+ * Description:  Reads @count bytes from @state->bdev into @buffer.
+ * Returns number of bytes read on success, 0 on error.
+ */
+static size_t read_lba(struct parsed_partitions *state, u64 lba, u8 *buffer,
+                       size_t count)
+{
+       size_t totalreadcount = 0;
+
+       if (!buffer || lba + count / 512 > last_lba(state->bdev))
+               return 0;
+
+       while (count) {
+               int copied = 512;
+               Sector sect;
+               unsigned char *data = read_part_sector(state, lba++, &sect);
+               if (!data)
+                       break;
+               if (copied > count)
+                       copied = count;
+               memcpy(buffer, data, copied);
+               put_dev_sector(sect);
+               buffer += copied;
+               totalreadcount += copied;
+               count -= copied;
+       }
+       return totalreadcount;
+}
+
+/**
+ * alloc_pvd(): reads physical volume descriptor
+ * @state
+ * @lba
+ *
+ * Description: Returns pvd on success,  NULL on error.
+ * Allocates space for pvd and fill it with disk blocks at @lba
+ * Notes: remember to free pvd when you're done!
+ */
+static struct pvd *alloc_pvd(struct parsed_partitions *state, u32 lba)
+{
+       size_t count = sizeof(struct pvd);
+       struct pvd *p;
+
+       p = kmalloc(count, GFP_KERNEL);
+       if (!p)
+               return NULL;
+
+       if (read_lba(state, lba, (u8 *) p, count) < count) {
+               kfree(p);
+               return NULL;
+       }
+       return p;
+}
+
+/**
+ * alloc_lvn(): reads logical volume names
+ * @state
+ * @lba
+ *
+ * Description: Returns lvn on success,  NULL on error.
+ * Allocates space for lvn and fill it with disk blocks at @lba
+ * Notes: remember to free lvn when you're done!
+ */
+static struct lvname *alloc_lvn(struct parsed_partitions *state, u32 lba)
+{
+       size_t count = sizeof(struct lvname) * LVM_MAXLVS;
+       struct lvname *p;
+
+       p = kmalloc(count, GFP_KERNEL);
+       if (!p)
+               return NULL;
+
+       if (read_lba(state, lba, (u8 *) p, count) < count) {
+               kfree(p);
+               return NULL;
+       }
+       return p;
+}
+
+int aix_partition(struct parsed_partitions *state)
+{
+       int ret = 0;
+       Sector sect;
+       unsigned char *d;
+       u32 pp_bytes_size;
+       u32 pp_blocks_size = 0;
+       u32 vgda_sector = 0;
+       u32 vgda_len = 0;
+       int numlvs = 0;
+       struct pvd *pvd;
+       struct lv_info {
+               unsigned short pps_per_lv;
+               unsigned short pps_found;
+               unsigned char lv_is_contiguous;
+       } *lvip;
+       struct lvname *n = NULL;
+
+       d = read_part_sector(state, 7, &sect);
+       if (d) {
+               struct lvm_rec *p = (struct lvm_rec *)d;
+               u16 lvm_version = be16_to_cpu(p->version);
+               char tmp[64];
+
+               if (lvm_version == 1) {
+                       int pp_size_log2 = be16_to_cpu(p->pp_size);
+
+                       pp_bytes_size = 1 << pp_size_log2;
+                       pp_blocks_size = pp_bytes_size / 512;
+                       snprintf(tmp, sizeof(tmp),
+                               " AIX LVM header version %u found\n",
+                               lvm_version);
+                       vgda_len = be32_to_cpu(p->vgda_len);
+                       vgda_sector = be32_to_cpu(p->vgda_psn[0]);
+               } else {
+                       snprintf(tmp, sizeof(tmp),
+                               " unsupported AIX LVM version %d found\n",
+                               lvm_version);
+               }
+               strlcat(state->pp_buf, tmp, PAGE_SIZE);
+               put_dev_sector(sect);
+       }
+       if (vgda_sector && (d = read_part_sector(state, vgda_sector, &sect))) {
+               struct vgda *p = (struct vgda *)d;
+
+               numlvs = be16_to_cpu(p->numlvs);
+               put_dev_sector(sect);
+       }
+       lvip = kzalloc(sizeof(struct lv_info) * state->limit, GFP_KERNEL);
+       if (!lvip)
+               return 0;
+       if (numlvs && (d = read_part_sector(state, vgda_sector + 1, &sect))) {
+               struct lvd *p = (struct lvd *)d;
+               int i;
+
+               n = alloc_lvn(state, vgda_sector + vgda_len - 33);
+               if (n) {
+                       int foundlvs = 0;
+
+                       for (i = 0; foundlvs < numlvs && i < state->limit; i += 1) {
+                               lvip[i].pps_per_lv = be16_to_cpu(p[i].num_lps);
+                               if (lvip[i].pps_per_lv)
+                                       foundlvs += 1;
+                       }
+               }
+               put_dev_sector(sect);
+       }
+       pvd = alloc_pvd(state, vgda_sector + 17);
+       if (pvd) {
+               int numpps = be16_to_cpu(pvd->pp_count);
+               int psn_part1 = be32_to_cpu(pvd->psn_part1);
+               int i;
+               int cur_lv_ix = -1;
+               int next_lp_ix = 1;
+               int lp_ix;
+
+               for (i = 0; i < numpps; i += 1) {
+                       struct ppe *p = pvd->ppe + i;
+                       unsigned int lv_ix;
+
+                       lp_ix = be16_to_cpu(p->lp_ix);
+                       if (!lp_ix) {
+                               next_lp_ix = 1;
+                               continue;
+                       }
+                       lv_ix = be16_to_cpu(p->lv_ix) - 1;
+                       if (lv_ix > state->limit) {
+                               cur_lv_ix = -1;
+                               continue;
+                       }
+                       lvip[lv_ix].pps_found += 1;
+                       if (lp_ix == 1) {
+                               cur_lv_ix = lv_ix;
+                               next_lp_ix = 1;
+                       } else if (lv_ix != cur_lv_ix || lp_ix != next_lp_ix) {
+                               next_lp_ix = 1;
+                               continue;
+                       }
+                       if (lp_ix == lvip[lv_ix].pps_per_lv) {
+                               char tmp[70];
+
+                               put_partition(state, lv_ix + 1,
+                                 (i + 1 - lp_ix) * pp_blocks_size + psn_part1,
+                                 lvip[lv_ix].pps_per_lv * pp_blocks_size);
+                               snprintf(tmp, sizeof(tmp), " <%s>\n",
+                                        n[lv_ix].name);
+                               strlcat(state->pp_buf, tmp, PAGE_SIZE);
+                               lvip[lv_ix].lv_is_contiguous = 1;
+                               ret = 1;
+                               next_lp_ix = 1;
+                       } else
+                               next_lp_ix += 1;
+               }
+               for (i = 0; i < state->limit; i += 1)
+                       if (lvip[i].pps_found && !lvip[i].lv_is_contiguous)
+                               pr_warn("partition %s (%u pp's found) is "
+                                       "not contiguous\n",
+                                       n[i].name, lvip[i].pps_found);
+               kfree(pvd);
+       }
+       kfree(n);
+       kfree(lvip);
+       return ret;
+}
diff --git a/block/partitions/aix.h b/block/partitions/aix.h
new file mode 100644 (file)
index 0000000..e0c66a9
--- /dev/null
@@ -0,0 +1 @@
+extern int aix_partition(struct parsed_partitions *state);