MFV r353623: 10473 zfs(1M) missing cross-reference to zfs-program(1M)

[FreeBSD/FreeBSD.git] / contrib / ofed / opensm / opensm / osm_torus.c

/*
 * Copyright 2009 Sandia Corporation.  Under the terms of Contract
 * DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
 * certain rights in this software.
 * Copyright (c) 2009-2011 ZIH, TU Dresden, Federal Republic of Germany. All rights reserved.
 * Copyright (c) 2010-2012 Mellanox Technologies LTD. All rights reserved.
 *
 * This software is available to you under a choice of one of two
 * licenses.  You may choose to be licensed under the terms of the GNU
 * General Public License (GPL) Version 2, available from the file
 * COPYING in the main directory of this source tree, or the
 * OpenIB.org BSD license below:
 *
 *     Redistribution and use in source and binary forms, with or
 *     without modification, are permitted provided that the following
 *     conditions are met:
 *
 *      - Redistributions of source code must retain the above
 *        copyright notice, this list of conditions and the following
 *        disclaimer.
 *
 *      - Redistributions in binary form must reproduce the above
 *        copyright notice, this list of conditions and the following
 *        disclaimer in the documentation and/or other materials
 *        provided with the distribution.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 */

#define _WITH_GETLINE   /* for getline() */
#include <stdint.h>
#include <stdbool.h>
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>

#if HAVE_CONFIG_H
#  include <config.h>
#endif                          /* HAVE_CONFIG_H */

#include <opensm/osm_file_ids.h>
#define FILE_ID OSM_FILE_TORUS_C
#include <opensm/osm_log.h>
#include <opensm/osm_port.h>
#include <opensm/osm_switch.h>
#include <opensm/osm_node.h>
#include <opensm/osm_opensm.h>

#define TORUS_MAX_DIM        3
#define PORTGRP_MAX_PORTS    16
#define SWITCH_MAX_PORTGRPS  (1 + 2 * TORUS_MAX_DIM)
#define DEFAULT_MAX_CHANGES  32

#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))

typedef ib_net64_t guid_t;

/*
 * An endpoint terminates a link, and is one of three types:
 *   UNKNOWN  - Uninitialized endpoint.
 *   SRCSINK  - generates or consumes traffic, and thus has an associated LID;
 *                i.e. a CA or router port.
 *   PASSTHRU - Has no associated LID; i.e. a switch port.
 *
 * If it is possible to communicate in-band with a switch, it will require
 * a port with a GUID in the switch to source/sink that traffic, but there
 * will be no attached link.  This code assumes there is only one such port.
 *
 * Here is an endpoint taxonomy:
 *
 *   type == SRCSINK
 *   link == pointer to a valid struct link
 *     ==> This endpoint is a CA or router port connected via a link to
 *           either a switch or another CA/router.  Thus:
 *         n_id ==> identifies the CA/router node GUID
 *         sw   ==> NULL
 *         port ==> identifies the port on the CA/router this endpoint uses
 *         pgrp ==> NULL
 *
 *   type == SRCSINK
 *   link == NULL pointer
 *     ==> This endpoint is the switch port used for in-band communication
 *           with the switch itself.  Thus:
 *         n_id ==> identifies the node GUID used to talk to the switch
 *                    containing this endpoint
 *         sw   ==> pointer to valid struct switch containing this endpoint
 *         port ==> identifies the port on the switch this endpoint uses
 *         pgrp ==> NULL, or pointer to the valid struct port_grp holding
 *                    the port in a t_switch.
 *
 *   type == PASSTHRU
 *   link == pointer to valid struct link
 *     ==> This endpoint is a switch port connected via a link to either
 *           another switch or a CA/router.  Thus:
 *         n_id ==> identifies the node GUID used to talk to the switch
 *                    containing this endpoint - since each switch is assumed
 *                    to have only one in-band communication port, this is a
 *                    convenient unique name for the switch itself.
 *         sw   ==> pointer to valid struct switch containing this endpoint,
 *                    or NULL, in the case of a fabric link that has been
 *                    disconnected after being transferred to a torus link.
 *         port ==> identifies the port on the switch this endpoint uses.
 *                    Note that in the special case of the coordinate direction
 *                    links, the port value is -1, as those links aren't
 *                    really connected to anything.
 *         pgrp ==> NULL, or pointer to the valid struct port_grp holding
 *                    the port in a t_switch.
 */
enum endpt_type { UNKNOWN = 0, SRCSINK, PASSTHRU };
struct torus;
struct t_switch;
struct port_grp;

struct endpoint {
        enum endpt_type type;
        int port;
        guid_t n_id;            /* IBA node GUID */
        void *sw;               /* void* can point to either switch type */
        struct link *link;
        struct port_grp *pgrp;
        void *tmp;
        /*
         * Note: osm_port is only guaranteed to contain a valid pointer
         * when the call stack contains torus_build_lfts() or
         * osm_port_relink_endpoint().
         *
         * Otherwise, the opensm core could have deleted an osm_port object
         * without notifying us, invalidating the pointer we hold.
         *
         * When presented with a pointer to an osm_port_t, it is generally
         * safe and required to cast osm_port_t:priv to struct endpoint, and
         * check that the endpoint's osm_port is the same as the original
         * osm_port_t pointer.  Failure to do so means that invalidated
         * pointers will go undetected.
         */
        struct osm_port *osm_port;
};

struct link {
        struct endpoint end[2];
};

/*
 * A port group is a collection of endpoints on a switch that share certain
 * characteristics.  All the endpoints in a port group must have the same
 * type.  Furthermore, if that type is PASSTHRU, then the connected links:
 *   1) are parallel to a given coordinate direction
 *   2) share the same two switches as endpoints.
 *
 * Torus-2QoS uses one master spanning tree for multicast, of which every
 * multicast group spanning tree is a subtree.  to_stree_root is a pointer
 * to the next port_grp on the path to the master spanning tree root.
 * to_stree_tip is a pointer to the next port_grp on the path to a master
 * spanning tree branch tip.
 *
 * Each t_switch can have at most one port_grp with a non-NULL to_stree_root.
 * Exactly one t_switch in the fabric will have all port_grp objects with
 * to_stree_root NULL; it is the master spanning tree root.
 *
 * A t_switch with all port_grp objects where to_stree_tip is NULL is at a
 * master spanning tree branch tip.
 */
struct port_grp {
        enum endpt_type type;
        size_t port_cnt;        /* number of attached ports in group */
        size_t port_grp;        /* what switch port_grp we're in */
        unsigned sw_dlid_cnt;   /* switch dlids routed through this group */
        unsigned ca_dlid_cnt;   /* CA dlids routed through this group */
        struct t_switch *sw;    /* what switch we're attached to */
        struct port_grp *to_stree_root;
        struct port_grp *to_stree_tip;
        struct endpoint **port;
};

/*
 * A struct t_switch is used to represent a switch as placed in a torus.
 *
 * A t_switch used to build an N-dimensional torus will have 2N+1 port groups,
 * used as follows, assuming 0 <= d < N:
 *   port_grp[2d]   => links leaving in negative direction for coordinate d
 *   port_grp[2d+1] => links leaving in positive direction for coordinate d
 *   port_grp[2N]   => endpoints local to switch; i.e., hosts on switch
 *
 * struct link objects referenced by a t_switch are assumed to be oriented:
 * traversing a link from link.end[0] to link.end[1] is always in the positive
 * coordinate direction.
 */
struct t_switch {
        guid_t n_id;            /* IBA node GUID */
        int i, j, k;
        unsigned port_cnt;      /* including management port */
        struct torus *torus;
        void *tmp;
        /*
         * Note: osm_switch is only guaranteed to contain a valid pointer
         * when the call stack contains torus_build_lfts().
         *
         * Otherwise, the opensm core could have deleted an osm_switch object
         * without notifying us, invalidating the pointer we hold.
         *
         * When presented with a pointer to an osm_switch_t, it is generally
         * safe and required to cast osm_switch_t:priv to struct t_switch, and
         * check that the switch's osm_switch is the same as the original
         * osm_switch_t pointer.  Failure to do so means that invalidated
         * pointers will go undetected.
         */
        struct osm_switch *osm_switch;

        struct port_grp ptgrp[SWITCH_MAX_PORTGRPS];
        struct endpoint **port;
};

/*
 * We'd like to be able to discover the torus topology in a pile of switch
 * links if we can.  We'll use a struct f_switch to store raw topology for a
 * fabric description, then contruct the torus topology from struct t_switch
 * objects as we process the fabric and recover it.
 */
struct f_switch {
        guid_t n_id;            /* IBA node GUID */
        unsigned port_cnt;      /* including management port */
        void *tmp;
        /*
         * Same rules apply here as for a struct t_switch member osm_switch.
         */
        struct osm_switch *osm_switch;
        struct endpoint **port;
};

struct fabric {
        osm_opensm_t *osm;
        unsigned ca_cnt;
        unsigned link_cnt;
        unsigned switch_cnt;

        unsigned link_cnt_max;
        unsigned switch_cnt_max;

        struct link **link;
        struct f_switch **sw;
};

struct coord_dirs {
        /*
         * These links define the coordinate directions for the torus.
         * They are duplicates of links connected to switches.  Each of
         * these links must connect to a common switch.
         *
         * In the event that a failed switch was specified as one of these
         * link endpoints, our algorithm would not be able to find the
         * torus in the fabric.  So, we'll allow multiple instances of
         * this in the config file to allow improved resiliency.
         */
        struct link xm_link, ym_link, zm_link;
        struct link xp_link, yp_link, zp_link;
        /*
         * A torus dimension has coordinate values 0, 1, ..., radix - 1.
         * The dateline, where we need to change VLs to avoid credit loops,
         * for a torus dimension is always between coordinate values
         * radix - 1 and 0.  The following specify the dateline location
         * relative to the coordinate links shared switch location.
         *
         * E.g. if the shared switch is at 0,0,0, the following are all
         * zero; if the shared switch is at 1,1,1, the following are all
         * -1, etc.
         *
         * Since our SL/VL assignment for a path depends on the position
         * of the path endpoints relative to the torus datelines, we need
         * this information to keep SL/VL assignment constant in the event
         * one of the switches used to specify coordinate directions fails.
         */
        int x_dateline, y_dateline, z_dateline;
};

struct torus {
        osm_opensm_t *osm;
        unsigned ca_cnt;
        unsigned link_cnt;
        unsigned switch_cnt;
        unsigned seed_cnt, seed_idx;
        unsigned x_sz, y_sz, z_sz;

        unsigned port_order[IB_NODE_NUM_PORTS_MAX+1];

        unsigned sw_pool_sz;
        unsigned link_pool_sz;
        unsigned seed_sz;
        unsigned portgrp_sz;    /* max ports for port groups in this torus */

        struct fabric *fabric;
        struct t_switch **sw_pool;
        struct link *link_pool;

        struct coord_dirs *seed;
        struct t_switch ****sw;
        struct t_switch *master_stree_root;

        unsigned flags;
        unsigned max_changes;
        int debug;
};

/*
 * Bits to use in torus.flags
 */
#define X_MESH (1U << 0)
#define Y_MESH (1U << 1)
#define Z_MESH (1U << 2)
#define MSG_DEADLOCK (1U << 29)
#define NOTIFY_CHANGES (1U << 30)

#define ALL_MESH(flags) \
        ((flags & (X_MESH | Y_MESH | Z_MESH)) == (X_MESH | Y_MESH | Z_MESH))


struct torus_context {
        osm_opensm_t *osm;
        struct torus *torus;
        struct fabric fabric;
};

static
void teardown_fabric(struct fabric *f)
{
        unsigned l, p, s;
        struct endpoint *port;
        struct f_switch *sw;

        if (!f)
                return;

        if (f->sw) {
                /*
                 * Need to free switches, and also find/free the endpoints
                 * we allocated for switch management ports.
                 */
                for (s = 0; s < f->switch_cnt; s++) {
                        sw = f->sw[s];
                        if (!sw)
                                continue;

                        for (p = 0; p < sw->port_cnt; p++) {
                                port = sw->port[p];
                                if (port && !port->link)
                                        free(port);     /* management port */
                        }
                        free(sw);
                }
                free(f->sw);
        }
        if (f->link) {
                for (l = 0; l < f->link_cnt; l++)
                        if (f->link[l])
                                free(f->link[l]);

                free(f->link);
        }
        memset(f, 0, sizeof(*f));
}

void teardown_torus(struct torus *t)
{
        unsigned p, s;
        struct endpoint *port;
        struct t_switch *sw;

        if (!t)
                return;

        if (t->sw_pool) {
                /*
                 * Need to free switches, and also find/free the endpoints
                 * we allocated for switch management ports.
                 */
                for (s = 0; s < t->switch_cnt; s++) {
                        sw = t->sw_pool[s];
                        if (!sw)
                                continue;

                        for (p = 0; p < sw->port_cnt; p++) {
                                port = sw->port[p];
                                if (port && !port->link)
                                        free(port);     /* management port */
                        }
                        free(sw);
                }
                free(t->sw_pool);
        }
        if (t->link_pool)
                free(t->link_pool);

        if (t->sw)
                free(t->sw);

        if (t->seed)
                free(t->seed);

        free(t);
}

static
struct torus_context *torus_context_create(osm_opensm_t *osm)
{
        struct torus_context *ctx;

        ctx = calloc(1, sizeof(*ctx));
        if (ctx)
                ctx->osm = osm;
        else
                OSM_LOG(&osm->log, OSM_LOG_ERROR,
                        "ERR 4E01: calloc: %s\n", strerror(errno));

        return ctx;
}

static
void torus_context_delete(void *context)
{
        struct torus_context *ctx = context;

        teardown_fabric(&ctx->fabric);
        if (ctx->torus)
                teardown_torus(ctx->torus);
        free(ctx);
}

static
bool grow_seed_array(struct torus *t, int new_seeds)
{
        unsigned cnt;
        void *ptr;

        cnt = t->seed_cnt + new_seeds;
        if (cnt > t->seed_sz) {
                cnt += 2 + cnt / 2;
                ptr = realloc(t->seed, cnt * sizeof(*t->seed));
                if (!ptr)
                        return false;
                t->seed = ptr;
                t->seed_sz = cnt;
                memset(&t->seed[t->seed_cnt], 0,
                       (cnt - t->seed_cnt) * sizeof(*t->seed));
        }
        return true;
}

static
struct f_switch *find_f_sw(struct fabric *f, guid_t sw_guid)
{
        unsigned s;
        struct f_switch *sw;

        if (f->sw) {
                for (s = 0; s < f->switch_cnt; s++) {
                        sw = f->sw[s];
                        if (sw->n_id == sw_guid)
                                return sw;
                }
        }
        return NULL;
}

static
struct link *find_f_link(struct fabric *f,
                         guid_t guid0, int port0, guid_t guid1, int port1)
{
        unsigned l;
        struct link *link;

        if (f->link) {
                for (l = 0; l < f->link_cnt; l++) {
                        link = f->link[l];
                        if ((link->end[0].n_id == guid0 &&
                             link->end[0].port == port0 &&
                             link->end[1].n_id == guid1 &&
                             link->end[1].port == port1) ||
                            (link->end[0].n_id == guid1 &&
                             link->end[0].port == port1 &&
                             link->end[1].n_id == guid0 &&
                             link->end[1].port == port0))
                                return link;
                }
        }
        return NULL;
}

static
struct f_switch *alloc_fswitch(struct fabric *f,
                               guid_t sw_id, unsigned port_cnt)
{
        size_t new_sw_sz;
        unsigned cnt_max;
        struct f_switch *sw = NULL;
        void *ptr;

        if (f->switch_cnt >= f->switch_cnt_max) {

                cnt_max = 16 + 5 * f->switch_cnt_max / 4;
                ptr = realloc(f->sw, cnt_max * sizeof(*f->sw));
                if (!ptr) {
                        OSM_LOG(&f->osm->log, OSM_LOG_ERROR,
                                "ERR 4E02: realloc: %s\n", strerror(errno));
                        goto out;
                }
                f->sw = ptr;
                f->switch_cnt_max = cnt_max;
                memset(&f->sw[f->switch_cnt], 0,
                       (f->switch_cnt_max - f->switch_cnt)*sizeof(*f->sw));
        }
        new_sw_sz = sizeof(*sw) + port_cnt * sizeof(*sw->port);
        sw = calloc(1, new_sw_sz);
        if (!sw) {
                OSM_LOG(&f->osm->log, OSM_LOG_ERROR,
                        "ERR 4E03: calloc: %s\n", strerror(errno));
                goto out;
        }
        sw->port = (void *)(sw + 1);
        sw->n_id = sw_id;
        sw->port_cnt = port_cnt;
        f->sw[f->switch_cnt++] = sw;
out:
        return sw;
}

static
struct link *alloc_flink(struct fabric *f)
{
        unsigned cnt_max;
        struct link *l = NULL;
        void *ptr;

        if (f->link_cnt >= f->link_cnt_max) {

                cnt_max = 16 + 5 * f->link_cnt_max / 4;
                ptr = realloc(f->link, cnt_max * sizeof(*f->link));
                if (!ptr) {
                        OSM_LOG(&f->osm->log, OSM_LOG_ERROR,
                                "ERR 4E04: realloc: %s\n", strerror(errno));
                        goto out;
                }
                f->link = ptr;
                f->link_cnt_max = cnt_max;
                memset(&f->link[f->link_cnt], 0,
                       (f->link_cnt_max - f->link_cnt) * sizeof(*f->link));
        }
        l = calloc(1, sizeof(*l));
        if (!l) {
                OSM_LOG(&f->osm->log, OSM_LOG_ERROR,
                        "ERR 4E05: calloc: %s\n", strerror(errno));
                goto out;
        }
        f->link[f->link_cnt++] = l;
out:
        return l;
}

/*
 * Caller must ensure osm_port points to a valid port which contains
 * a valid osm_physp_t pointer for port 0, the switch management port.
 */
static
bool build_sw_endpoint(struct fabric *f, osm_port_t *osm_port)
{
        int sw_port;
        guid_t sw_guid;
        struct osm_switch *osm_sw;
        struct f_switch *sw;
        struct endpoint *ep;
        bool success = false;

        sw_port = osm_physp_get_port_num(osm_port->p_physp);
        sw_guid = osm_node_get_node_guid(osm_port->p_node);
        osm_sw = osm_port->p_node->sw;

        /*
         * The switch must already exist.
         */
        sw = find_f_sw(f, sw_guid);
        if (!sw) {
                OSM_LOG(&f->osm->log, OSM_LOG_ERROR,
                        "ERR 4E06: missing switch w/GUID 0x%04"PRIx64"\n",
                        cl_ntoh64(sw_guid));
                goto out;
        }
        /*
         * The endpoint may already exist.
         */
        if (sw->port[sw_port]) {
                if (sw->port[sw_port]->n_id == sw_guid) {
                        ep = sw->port[sw_port];
                        goto success;
                } else
                        OSM_LOG(&f->osm->log, OSM_LOG_ERROR,
                                "ERR 4E07: switch port %d has id "
                                "0x%04"PRIx64", expected 0x%04"PRIx64"\n",
                                sw_port, cl_ntoh64(sw->port[sw_port]->n_id),
                                cl_ntoh64(sw_guid));
                goto out;
        }
        ep = calloc(1, sizeof(*ep));
        if (!ep) {
                OSM_LOG(&f->osm->log, OSM_LOG_ERROR,
                        "ERR 4E08: allocating endpoint: %s\n", strerror(errno));
                goto out;
        }
        ep->type = SRCSINK;
        ep->port = sw_port;
        ep->n_id = sw_guid;
        ep->link = NULL;
        ep->sw = sw;

        sw->port[sw_port] = ep;

success:
        /*
         * Fabric objects are temporary, so don't set osm_sw/osm_port priv
         * pointers using them.  Wait until torus objects get constructed.
         */
        sw->osm_switch = osm_sw;
        ep->osm_port = osm_port;

        success = true;
out:
        return success;
}

static
bool build_ca_link(struct fabric *f,
                   osm_port_t *osm_port_ca, guid_t sw_guid, int sw_port)
{
        int ca_port;
        guid_t ca_guid;
        struct link *l;
        struct f_switch *sw;
        bool success = false;

        ca_port = osm_physp_get_port_num(osm_port_ca->p_physp);
        ca_guid = osm_node_get_node_guid(osm_port_ca->p_node);

        /*
         * The link may already exist.
         */
        l = find_f_link(f, sw_guid, sw_port, ca_guid, ca_port);
        if (l) {
                success = true;
                goto out;
        }
        /*
         * The switch must already exist.
         */
        sw = find_f_sw(f, sw_guid);
        if (!sw) {
                OSM_LOG(&f->osm->log, OSM_LOG_ERROR,
                        "ERR 4E09: missing switch w/GUID 0x%04"PRIx64"\n",
                        cl_ntoh64(sw_guid));
                goto out;
        }
        l = alloc_flink(f);
        if (!l)
                goto out;

        l->end[0].type = PASSTHRU;
        l->end[0].port = sw_port;
        l->end[0].n_id = sw_guid;
        l->end[0].sw = sw;
        l->end[0].link = l;

        sw->port[sw_port] = &l->end[0];

        l->end[1].type = SRCSINK;
        l->end[1].port = ca_port;
        l->end[1].n_id = ca_guid;
        l->end[1].sw = NULL;            /* Correct for a CA */
        l->end[1].link = l;

        /*
         * Fabric objects are temporary, so don't set osm_sw/osm_port priv
         * pointers using them.  Wait until torus objects get constructed.
         */
        l->end[1].osm_port = osm_port_ca;

        ++f->ca_cnt;
        success = true;
out:
        return success;
}

static
bool build_link(struct fabric *f,
                guid_t sw_guid0, int sw_port0, guid_t sw_guid1, int sw_port1)
{
        struct link *l;
        struct f_switch *sw0, *sw1;
        bool success = false;

        /*
         * The link may already exist.
         */
        l = find_f_link(f, sw_guid0, sw_port0, sw_guid1, sw_port1);
        if (l) {
                success = true;
                goto out;
        }
        /*
         * The switches must already exist.
         */
        sw0 = find_f_sw(f, sw_guid0);
        if (!sw0) {
                OSM_LOG(&f->osm->log, OSM_LOG_ERROR,
                        "ERR 4E0A: missing switch w/GUID 0x%04"PRIx64"\n",
                        cl_ntoh64(sw_guid0));
                goto out;
        }
        sw1 = find_f_sw(f, sw_guid1);
        if (!sw1) {
                OSM_LOG(&f->osm->log, OSM_LOG_ERROR,
                        "ERR 4E0B: missing switch w/GUID 0x%04"PRIx64"\n",
                        cl_ntoh64(sw_guid1));
                goto out;
        }
        l = alloc_flink(f);
        if (!l)
                goto out;

        l->end[0].type = PASSTHRU;
        l->end[0].port = sw_port0;
        l->end[0].n_id = sw_guid0;
        l->end[0].sw = sw0;
        l->end[0].link = l;

        sw0->port[sw_port0] = &l->end[0];

        l->end[1].type = PASSTHRU;
        l->end[1].port = sw_port1;
        l->end[1].n_id = sw_guid1;
        l->end[1].sw = sw1;
        l->end[1].link = l;

        sw1->port[sw_port1] = &l->end[1];

        success = true;
out:
        return success;
}

static
bool parse_size(unsigned *tsz, unsigned *tflags, unsigned mask,
                const char *parse_sep)
{
        char *val, *nextchar;

        val = strtok(NULL, parse_sep);
        if (!val)
                return false;
        *tsz = strtoul(val, &nextchar, 0);
        if (*tsz) {
                if (*nextchar == 't' || *nextchar == 'T')
                        *tflags &= ~mask;
                else if (*nextchar == 'm' || *nextchar == 'M')
                        *tflags |= mask;
                /*
                 * A torus of radix two is also a mesh of radix two
                 * with multiple links between switches in that direction.
                 *
                 * Make it so always, otherwise the failure case routing
                 * logic gets confused.
                 */
                if (*tsz == 2)
                        *tflags |= mask;
        }
        return true;
}

static
bool parse_torus(struct torus *t, const char *parse_sep)
{
        unsigned i, j, k, cnt;
        char *ptr;
        bool success = false;

        /*
         * There can be only one.  Ignore the imposters.
         */
        if (t->sw_pool)
                goto out;

        if (!parse_size(&t->x_sz, &t->flags, X_MESH, parse_sep))
                goto out;

        if (!parse_size(&t->y_sz, &t->flags, Y_MESH, parse_sep))
                goto out;

        if (!parse_size(&t->z_sz, &t->flags, Z_MESH, parse_sep))
                goto out;

        /*
         * Set up a linear array of switch pointers big enough to hold
         * all expected switches.
         */
        t->sw_pool_sz = t->x_sz * t->y_sz * t->z_sz;
        t->sw_pool = calloc(t->sw_pool_sz, sizeof(*t->sw_pool));
        if (!t->sw_pool) {
                OSM_LOG(&t->osm->log, OSM_LOG_ERROR,
                        "ERR 4E0C: Torus switch array calloc: %s\n",
                        strerror(errno));
                goto out;
        }
        /*
         * Set things up so that t->sw[i][j][k] can point to the i,j,k switch.
         */
        cnt = t->x_sz * (1 + t->y_sz * (1 + t->z_sz));
        t->sw = malloc(cnt * sizeof(void *));
        if (!t->sw) {
                OSM_LOG(&t->osm->log, OSM_LOG_ERROR,
                        "ERR 4E0D: Torus switch array malloc: %s\n",
                        strerror(errno));
                goto out;
        }
        ptr = (void *)(t->sw);

        ptr += t->x_sz * sizeof(void *);
        for (i = 0; i < t->x_sz; i++) {
                t->sw[i] = (void *)ptr;
                ptr += t->y_sz * sizeof(void *);
        }
        for (i = 0; i < t->x_sz; i++)
                for (j = 0; j < t->y_sz; j++) {
                        t->sw[i][j] = (void *)ptr;
                        ptr += t->z_sz * sizeof(void *);
                }

        for (i = 0; i < t->x_sz; i++)
                for (j = 0; j < t->y_sz; j++)
                        for (k = 0; k < t->z_sz; k++)
                                t->sw[i][j][k] = NULL;

        success = true;
out:
        return success;
}

static
bool parse_unsigned(unsigned *result, const char *parse_sep)
{
        char *val, *nextchar;

        val = strtok(NULL, parse_sep);
        if (!val)
                return false;
        *result = strtoul(val, &nextchar, 0);
        return true;
}

static
bool parse_port_order(struct torus *t, const char *parse_sep)
{
        unsigned i, j, k, n;

        for (i = 0; i < ARRAY_SIZE(t->port_order); i++) {
                if (!parse_unsigned(&(t->port_order[i]), parse_sep))
                        break;

                for (j = 0; j < i; j++) {
                        if (t->port_order[j] == t->port_order[i]) {
                                OSM_LOG(&t->osm->log, OSM_LOG_INFO,
                                        "Ignored duplicate port %u in"
                                        " port_order parsing\n",
                                        t->port_order[j]);
                                i--;    /* Ignore duplicate port number */
                                break;
                        }
                }
        }

        n = i;
        for (j = 0; j < ARRAY_SIZE(t->port_order); j++) {
                for (k = 0; k < i; k++)
                        if (t->port_order[k] == j)
                                break;
                if (k >= i)
                        t->port_order[n++] = j;
        }

        return true;
}

static
bool parse_guid(struct torus *t, guid_t *guid, const char *parse_sep)
{
        char *val;
        bool success = false;

        val = strtok(NULL, parse_sep);
        if (!val)
                goto out;
        *guid = strtoull(val, NULL, 0);
        *guid = cl_hton64(*guid);

        success = true;
out:
        return success;
}

static
bool parse_dir_link(int c_dir, struct torus *t, const char *parse_sep)
{
        guid_t sw_guid0, sw_guid1;
        struct link *l;
        bool success = false;

        if (!parse_guid(t, &sw_guid0, parse_sep))
                goto out;

        if (!parse_guid(t, &sw_guid1, parse_sep))
                goto out;

        if (!t) {
                success = true;
                goto out;
        }

        switch (c_dir) {
        case -1:
                l = &t->seed[t->seed_cnt - 1].xm_link;
                break;
        case  1:
                l = &t->seed[t->seed_cnt - 1].xp_link;
                break;
        case -2:
                l = &t->seed[t->seed_cnt - 1].ym_link;
                break;
        case  2:
                l = &t->seed[t->seed_cnt - 1].yp_link;
                break;
        case -3:
                l = &t->seed[t->seed_cnt - 1].zm_link;
                break;
        case  3:
                l = &t->seed[t->seed_cnt - 1].zp_link;
                break;
        default:
                OSM_LOG(&t->osm->log, OSM_LOG_ERROR,
                        "ERR 4E0E: unknown link direction %d\n", c_dir);
                goto out;
        }
        l->end[0].type = PASSTHRU;
        l->end[0].port = -1;            /* We don't really connect. */
        l->end[0].n_id = sw_guid0;
        l->end[0].sw = NULL;            /* Fix this up later. */
        l->end[0].link = NULL;          /* Fix this up later. */

        l->end[1].type = PASSTHRU;
        l->end[1].port = -1;            /* We don't really connect. */
        l->end[1].n_id = sw_guid1;
        l->end[1].sw = NULL;            /* Fix this up later. */
        l->end[1].link = NULL;          /* Fix this up later. */

        success = true;
out:
        return success;
}

static
bool parse_dir_dateline(int c_dir, struct torus *t, const char *parse_sep)
{
        char *val;
        int *dl, max_dl;
        bool success = false;

        val = strtok(NULL, parse_sep);
        if (!val)
                goto out;

        if (!t) {
                success = true;
                goto out;
        }

        switch (c_dir) {
        case  1:
                dl = &t->seed[t->seed_cnt - 1].x_dateline;
                max_dl = t->x_sz;
                break;
        case  2:
                dl = &t->seed[t->seed_cnt - 1].y_dateline;
                max_dl = t->y_sz;
                break;
        case  3:
                dl = &t->seed[t->seed_cnt - 1].z_dateline;
                max_dl = t->z_sz;
                break;
        default:
                OSM_LOG(&t->osm->log, OSM_LOG_ERROR,
                        "ERR 4E0F: unknown dateline direction %d\n", c_dir);
                goto out;
        }
        *dl = strtol(val, NULL, 0);

        if ((*dl < 0 && *dl <= -max_dl) || *dl >= max_dl)
                OSM_LOG(&t->osm->log, OSM_LOG_ERROR,
                        "ERR 4E10: dateline value for coordinate direction %d "
                        "must be %d < dl < %d\n",
                        c_dir, -max_dl, max_dl);
        else
                success = true;
out:
        return success;
}

static
bool parse_config(const char *fn, struct fabric *f, struct torus *t)
{
        FILE *fp;
        unsigned i;
        char *keyword;
        char *line_buf = NULL;
        const char *parse_sep = " \n\t\015";
        size_t line_buf_sz = 0;
        size_t line_cntr = 0;
        ssize_t llen;
        bool kw_success, success = true;

        if (!grow_seed_array(t, 2))
                return false;

        for (i = 0; i < ARRAY_SIZE(t->port_order); i++)
                t->port_order[i] = i;

        fp = fopen(fn, "r");
        if (!fp) {
                OSM_LOG(&t->osm->log, OSM_LOG_ERROR,
                        "ERR 4E11: Opening %s: %s\n", fn, strerror(errno));
                return false;
        }
        t->flags |= NOTIFY_CHANGES;
        t->portgrp_sz = PORTGRP_MAX_PORTS;
        t->max_changes = DEFAULT_MAX_CHANGES;

next_line:
        llen = getline(&line_buf, &line_buf_sz, fp);
        if (llen < 0)
                goto out;

        ++line_cntr;

        keyword = strtok(line_buf, parse_sep);
        if (!keyword)
                goto next_line;

        if (strcmp("torus", keyword) == 0) {
                kw_success = parse_torus(t, parse_sep);
        } else if (strcmp("mesh", keyword) == 0) {
                t->flags |= X_MESH | Y_MESH | Z_MESH;
                kw_success = parse_torus(t, parse_sep);
        } else if (strcmp("port_order", keyword) == 0) {
                kw_success = parse_port_order(t, parse_sep);
        } else if (strcmp("next_seed", keyword) == 0) {
                kw_success = grow_seed_array(t, 1);
                t->seed_cnt++;
        } else if (strcmp("portgroup_max_ports", keyword) == 0) {
                kw_success = parse_unsigned(&t->portgrp_sz, parse_sep);
        } else if (strcmp("xp_link", keyword) == 0) {
                if (!t->seed_cnt)
                        t->seed_cnt++;
                kw_success = parse_dir_link(1, t, parse_sep);
        } else if (strcmp("xm_link", keyword) == 0) {
                if (!t->seed_cnt)
                        t->seed_cnt++;
                kw_success = parse_dir_link(-1, t, parse_sep);
        } else if (strcmp("x_dateline", keyword) == 0) {
                if (!t->seed_cnt)
                        t->seed_cnt++;
                kw_success = parse_dir_dateline(1, t, parse_sep);
        } else if (strcmp("yp_link", keyword) == 0) {
                if (!t->seed_cnt)
                        t->seed_cnt++;
                kw_success = parse_dir_link(2, t, parse_sep);
        } else if (strcmp("ym_link", keyword) == 0) {
                if (!t->seed_cnt)
                        t->seed_cnt++;
                kw_success = parse_dir_link(-2, t, parse_sep);
        } else if (strcmp("y_dateline", keyword) == 0) {
                if (!t->seed_cnt)
                        t->seed_cnt++;
                kw_success = parse_dir_dateline(2, t, parse_sep);
        } else if (strcmp("zp_link", keyword) == 0) {
                if (!t->seed_cnt)
                        t->seed_cnt++;
                kw_success = parse_dir_link(3, t, parse_sep);
        } else if (strcmp("zm_link", keyword) == 0) {
                if (!t->seed_cnt)
                        t->seed_cnt++;
                kw_success = parse_dir_link(-3, t, parse_sep);
        } else if (strcmp("z_dateline", keyword) == 0) {
                if (!t->seed_cnt)
                        t->seed_cnt++;
                kw_success = parse_dir_dateline(3, t, parse_sep);
        } else if (strcmp("max_changes", keyword) == 0) {
                kw_success = parse_unsigned(&t->max_changes, parse_sep);
        } else if (keyword[0] == '#')
                goto next_line;
        else {
                OSM_LOG(&t->osm->log, OSM_LOG_ERROR,
                        "ERR 4E12: no keyword found: line %u\n",
                        (unsigned)line_cntr);
                kw_success = false;
        }
        if (!kw_success) {
                OSM_LOG(&t->osm->log, OSM_LOG_ERROR,
                        "ERR 4E13: parsing '%s': line %u\n",
                        keyword, (unsigned)line_cntr);
        }
        success = success && kw_success;
        goto next_line;

out:
        if (line_buf)
                free(line_buf);
        fclose(fp);
        return success;
}

static
bool capture_fabric(struct fabric *fabric)
{
        osm_subn_t *subnet = &fabric->osm->subn;
        osm_switch_t *osm_sw;
        osm_physp_t *lphysp, *rphysp;
        osm_port_t *lport;
        osm_node_t *osm_node;
        cl_map_item_t *item;
        uint8_t ltype, rtype;
        int p, port_cnt;
        guid_t sw_guid;
        bool success = true;

        OSM_LOG_ENTER(&fabric->osm->log);

        /*
         * On OpenSM data structures:
         *
         * Apparently, every port in a fabric has an associated osm_physp_t,
         * but not every port has an associated osm_port_t.  Apparently every
         * osm_port_t has an associated osm_physp_t.
         *
         * So, in order to find the inter-switch links we need to walk the
         * switch list and examine each port, via its osm_physp_t object.
         *
         * But, we need to associate our CA and switch management port
         * endpoints with the corresponding osm_port_t objects, in order
         * to simplify computation of LFT entries and perform SL lookup for
         * path records. Since it is apparently difficult to locate the
         * osm_port_t that corresponds to a given osm_physp_t, we also
         * need to walk the list of ports indexed by GUID to get access
         * to the appropriate osm_port_t objects.
         *
         * Need to allocate our switches before we do anything else.
         */
        item = cl_qmap_head(&subnet->sw_guid_tbl);
        while (item != cl_qmap_end(&subnet->sw_guid_tbl)) {

                osm_sw = (osm_switch_t *)item;
                item = cl_qmap_next(item);
                osm_sw->priv = NULL;  /* avoid stale pointer dereferencing */
                osm_node = osm_sw->p_node;

                if (osm_node_get_type(osm_node) != IB_NODE_TYPE_SWITCH)
                        continue;

                port_cnt = osm_node_get_num_physp(osm_node);
                sw_guid = osm_node_get_node_guid(osm_node);

                success = alloc_fswitch(fabric, sw_guid, port_cnt);
                if (!success)
                        goto out;
        }
        /*
         * Now build all our endpoints.
         */
        item = cl_qmap_head(&subnet->port_guid_tbl);
        while (item != cl_qmap_end(&subnet->port_guid_tbl)) {

                lport = (osm_port_t *)item;
                item = cl_qmap_next(item);
                lport->priv = NULL;  /* avoid stale pointer dereferencing */

                lphysp = lport->p_physp;
                if (!(lphysp && osm_physp_is_valid(lphysp)))
                        continue;

                ltype = osm_node_get_type(lphysp->p_node);
                /*
                 * Switch management port is always port 0.
                 */
                if (lphysp->port_num == 0 && ltype == IB_NODE_TYPE_SWITCH) {
                        success = build_sw_endpoint(fabric, lport);
                        if (!success)
                                goto out;
                        continue;
                }
                rphysp = lphysp->p_remote_physp;
                if (!(rphysp && osm_physp_is_valid(rphysp)))
                        continue;

                rtype = osm_node_get_type(rphysp->p_node);

                if ((ltype != IB_NODE_TYPE_CA &&
                     ltype != IB_NODE_TYPE_ROUTER) ||
                    rtype != IB_NODE_TYPE_SWITCH)
                        continue;

                success =
                        build_ca_link(fabric, lport,
                                      osm_node_get_node_guid(rphysp->p_node),
                                      osm_physp_get_port_num(rphysp));
                if (!success)
                        goto out;
        }
        /*
         * Lastly, build all our interswitch links.
         */
        item = cl_qmap_head(&subnet->sw_guid_tbl);
        while (item != cl_qmap_end(&subnet->sw_guid_tbl)) {

                osm_sw = (osm_switch_t *)item;
                item = cl_qmap_next(item);

                port_cnt = osm_node_get_num_physp(osm_sw->p_node);
                for (p = 0; p < port_cnt; p++) {

                        lphysp = osm_node_get_physp_ptr(osm_sw->p_node, p);
                        if (!(lphysp && osm_physp_is_valid(lphysp)))
                                continue;

                        rphysp = lphysp->p_remote_physp;
                        if (!(rphysp && osm_physp_is_valid(rphysp)))
                                continue;

                        if (lphysp == rphysp)
                                continue;       /* ignore loopbacks */

                        ltype = osm_node_get_type(lphysp->p_node);
                        rtype = osm_node_get_type(rphysp->p_node);

                        if (ltype != IB_NODE_TYPE_SWITCH ||
                            rtype != IB_NODE_TYPE_SWITCH)
                                continue;

                        success =
                                build_link(fabric,
                                           osm_node_get_node_guid(lphysp->p_node),
                                           osm_physp_get_port_num(lphysp),
                                           osm_node_get_node_guid(rphysp->p_node),
                                           osm_physp_get_port_num(rphysp));
                        if (!success)
                                goto out;
                }
        }
out:
        OSM_LOG_EXIT(&fabric->osm->log);
        return success;
}

/*
 * diagnose_fabric() is just intended to report on fabric elements that
 * could not be placed into the torus.  We want to warn that there were
 * non-torus fabric elements, but they will be ignored for routing purposes.
 * Having them is not an error, and diagnose_fabric() thus has no return
 * value.
 */
static
void diagnose_fabric(struct fabric *f)
{
        struct link *l;
        struct endpoint *ep;
        unsigned k, p;

        /*
         * Report on any links that didn't get transferred to the torus.
         */
        for (k = 0; k < f->link_cnt; k++) {
                l = f->link[k];

                if (!(l->end[0].sw && l->end[1].sw))
                        continue;

                OSM_LOG(&f->osm->log, OSM_LOG_INFO,
                        "Found non-torus fabric link:"
                        " sw GUID 0x%04"PRIx64" port %d <->"
                        " sw GUID 0x%04"PRIx64" port %d\n",
                        cl_ntoh64(l->end[0].n_id), l->end[0].port,
                        cl_ntoh64(l->end[1].n_id), l->end[1].port);
        }
        /*
         * Report on any switches with ports using endpoints that didn't
         * get transferred to the torus.
         */
        for (k = 0; k < f->switch_cnt; k++)
                for (p = 0; p < f->sw[k]->port_cnt; p++) {

                        if (!f->sw[k]->port[p])
                                continue;

                        ep = f->sw[k]->port[p];

                        /*
                         * We already reported on inter-switch links above.
                         */
                        if (ep->type == PASSTHRU)
                                continue;

                        OSM_LOG(&f->osm->log, OSM_LOG_INFO,
                                "Found non-torus fabric port:"
                                " sw GUID 0x%04"PRIx64" port %d\n",
                                cl_ntoh64(f->sw[k]->n_id), p);
                }
}

static
struct t_switch *alloc_tswitch(struct torus *t, struct f_switch *fsw)
{
        unsigned g;
        size_t new_sw_sz;
        struct t_switch *sw = NULL;
        void *ptr;

        if (!fsw)
                goto out;

        if (t->switch_cnt >= t->sw_pool_sz) {
                /*
                 * This should never happen, but occasionally a particularly
                 * pathological fabric can induce it.  So log an error.
                 */
                OSM_LOG(&t->osm->log, OSM_LOG_ERROR,
                        "ERR 4E14: unexpectedly requested too many switch "
                        "structures!\n");
                goto out;
        }
        new_sw_sz = sizeof(*sw)
                + fsw->port_cnt * sizeof(*sw->port)
                + SWITCH_MAX_PORTGRPS * t->portgrp_sz * sizeof(*sw->ptgrp[0].port);
        sw = calloc(1, new_sw_sz);
        if (!sw) {
                OSM_LOG(&t->osm->log, OSM_LOG_ERROR,
                        "ERR 4E15: calloc: %s\n", strerror(errno));
                goto out;
        }
        sw->port = (void *)(sw + 1);
        sw->n_id = fsw->n_id;
        sw->port_cnt = fsw->port_cnt;
        sw->torus = t;
        sw->tmp = fsw;

        ptr = &sw->port[sw->port_cnt];

        for (g = 0; g < SWITCH_MAX_PORTGRPS; g++) {
                sw->ptgrp[g].port_grp = g;
                sw->ptgrp[g].sw = sw;
                sw->ptgrp[g].port = ptr;
                ptr = &sw->ptgrp[g].port[t->portgrp_sz];
        }
        t->sw_pool[t->switch_cnt++] = sw;
out:
        return sw;
}

/*
 * install_tswitch() expects the switch coordinates i,j,k to be canonicalized
 * by caller.
 */
static
bool install_tswitch(struct torus *t,
                     int i, int j, int k, struct f_switch *fsw)
{
        struct t_switch **sw = &t->sw[i][j][k];

        if (!*sw)
                *sw = alloc_tswitch(t, fsw);

        if (*sw) {
                (*sw)->i = i;
                (*sw)->j = j;
                (*sw)->k = k;
        }
        return !!*sw;
}

static
struct link *alloc_tlink(struct torus *t)
{
        if (t->link_cnt >= t->link_pool_sz) {
                OSM_LOG(&t->osm->log, OSM_LOG_ERROR,
                        "ERR 4E16: unexpectedly out of pre-allocated link "
                        "structures!\n");
                return NULL;
        }
        return &t->link_pool[t->link_cnt++];
}

static
int canonicalize(int v, int vmax)
{
        if (v >= 0 && v < vmax)
                return v;

        if (v < 0)
                v += vmax * (1 - v/vmax);

        return v % vmax;
}

static
unsigned set_fp_bit(bool present, int i, int j, int k)
{
        return (unsigned)(!present) << (i + 2 * j + 4 * k);
}

/*
 * Returns an 11-bit fingerprint of what switches are absent in a cube of
 * neighboring switches.  Each bit 0-7 corresponds to a corner of the cube;
 * if a bit is set the corresponding switch is absent.
 *
 * Bits 8-10 distinguish between 2D and 3D cases.  If bit 8+d is set,
 * for 0 <= d < 3;  the d dimension of the desired torus has radix greater
 * than 1. Thus, if all bits 8-10 are set, the desired torus is 3D.
 */
static
unsigned fingerprint(struct torus *t, int i, int j, int k)
{
        unsigned fp;
        int ip1, jp1, kp1;
        int x_sz_gt1, y_sz_gt1, z_sz_gt1;

        x_sz_gt1 = t->x_sz > 1;
        y_sz_gt1 = t->y_sz > 1;
        z_sz_gt1 = t->z_sz > 1;

        ip1 = canonicalize(i + 1, t->x_sz);
        jp1 = canonicalize(j + 1, t->y_sz);
        kp1 = canonicalize(k + 1, t->z_sz);

        fp  = set_fp_bit(t->sw[i][j][k], 0, 0, 0);
        fp |= set_fp_bit(t->sw[ip1][j][k], x_sz_gt1, 0, 0);
        fp |= set_fp_bit(t->sw[i][jp1][k], 0, y_sz_gt1, 0);
        fp |= set_fp_bit(t->sw[ip1][jp1][k], x_sz_gt1, y_sz_gt1, 0);
        fp |= set_fp_bit(t->sw[i][j][kp1], 0, 0, z_sz_gt1);
        fp |= set_fp_bit(t->sw[ip1][j][kp1], x_sz_gt1, 0, z_sz_gt1);
        fp |= set_fp_bit(t->sw[i][jp1][kp1], 0, y_sz_gt1, z_sz_gt1);
        fp |= set_fp_bit(t->sw[ip1][jp1][kp1], x_sz_gt1, y_sz_gt1, z_sz_gt1);

        fp |= x_sz_gt1 << 8;
        fp |= y_sz_gt1 << 9;
        fp |= z_sz_gt1 << 10;

        return fp;
}

static
bool connect_tlink(struct port_grp *pg0, struct endpoint *f_ep0,
                   struct port_grp *pg1, struct endpoint *f_ep1,
                   struct torus *t)
{
        struct link *l;
        bool success = false;

        if (pg0->port_cnt == t->portgrp_sz) {
                OSM_LOG(&t->osm->log, OSM_LOG_ERROR,
                        "ERR 4E17: exceeded port group max "
                        "port count (%d): switch GUID 0x%04"PRIx64"\n",
                        t->portgrp_sz, cl_ntoh64(pg0->sw->n_id));
                goto out;
        }
        if (pg1->port_cnt == t->portgrp_sz) {
                OSM_LOG(&t->osm->log, OSM_LOG_ERROR,
                        "ERR 4E18: exceeded port group max "
                        "port count (%d): switch GUID 0x%04"PRIx64"\n",
                        t->portgrp_sz, cl_ntoh64(pg1->sw->n_id));
                goto out;
        }
        l = alloc_tlink(t);
        if (!l)
                goto out;

        l->end[0].type = f_ep0->type;
        l->end[0].port = f_ep0->port;
        l->end[0].n_id = f_ep0->n_id;
        l->end[0].sw = pg0->sw;
        l->end[0].link = l;
        l->end[0].pgrp = pg0;
        pg0->port[pg0->port_cnt++] = &l->end[0];
        pg0->sw->port[f_ep0->port] = &l->end[0];

        if (f_ep0->osm_port) {
                l->end[0].osm_port = f_ep0->osm_port;
                l->end[0].osm_port->priv = &l->end[0];
                f_ep0->osm_port = NULL;
        }

        l->end[1].type = f_ep1->type;
        l->end[1].port = f_ep1->port;
        l->end[1].n_id = f_ep1->n_id;
        l->end[1].sw = pg1->sw;
        l->end[1].link = l;
        l->end[1].pgrp = pg1;
        pg1->port[pg1->port_cnt++] = &l->end[1];
        pg1->sw->port[f_ep1->port] = &l->end[1];

        if (f_ep1->osm_port) {
                l->end[1].osm_port = f_ep1->osm_port;
                l->end[1].osm_port->priv = &l->end[1];
                f_ep1->osm_port = NULL;
        }
        /*
         * Disconnect fabric link, so that later we can see if any were
         * left unconnected in the torus.
         */
        ((struct f_switch *)f_ep0->sw)->port[f_ep0->port] = NULL;
        f_ep0->sw = NULL;
        f_ep0->port = -1;

        ((struct f_switch *)f_ep1->sw)->port[f_ep1->port] = NULL;
        f_ep1->sw = NULL;
        f_ep1->port = -1;

        success = true;
out:
        return success;
}

static
bool link_tswitches(struct torus *t, int cdir,
                    struct t_switch *t_sw0, struct t_switch *t_sw1)
{
        int p;
        struct port_grp *pg0, *pg1;
        struct f_switch *f_sw0, *f_sw1;
        const char *cdir_name = "unknown";
        unsigned port_cnt;
        int success = false;

        /*
         * If this is a 2D torus, it is possible for this function to be
         * called with its two switch arguments being the same switch, in
         * which case there are no links to install.
         */
        if (t_sw0 == t_sw1 &&
            ((cdir == 0 && t->x_sz == 1) ||
             (cdir == 1 && t->y_sz == 1) ||
             (cdir == 2 && t->z_sz == 1))) {
                success = true;
                goto out;
        }
        /*
         * Ensure that t_sw1 is in the positive cdir direction wrt. t_sw0.
         * ring_next_sw() relies on it.
         */
        switch (cdir) {
        case 0:
                if (t->x_sz > 1 &&
                    canonicalize(t_sw0->i + 1, t->x_sz) != t_sw1->i) {
                        cdir_name = "x";
                        goto cdir_error;
                }
                break;
        case 1:
                if (t->y_sz > 1 &&
                    canonicalize(t_sw0->j + 1, t->y_sz) != t_sw1->j) {
                        cdir_name = "y";
                        goto cdir_error;
                }
                break;
        case 2:
                if (t->z_sz > 1 &&
                    canonicalize(t_sw0->k + 1, t->z_sz) != t_sw1->k) {
                        cdir_name = "z";
                        goto cdir_error;
                }
                break;
        default:
        cdir_error:
                OSM_LOG(&t->osm->log, OSM_LOG_ERROR, "ERR 4E19: "
                        "sw 0x%04"PRIx64" (%d,%d,%d) <--> "
                        "sw 0x%04"PRIx64" (%d,%d,%d) "
                        "invalid torus %s link orientation\n",
                        cl_ntoh64(t_sw0->n_id), t_sw0->i, t_sw0->j, t_sw0->k,
                        cl_ntoh64(t_sw1->n_id), t_sw1->i, t_sw1->j, t_sw1->k,
                        cdir_name);
                goto out;
        }

        f_sw0 = t_sw0->tmp;
        f_sw1 = t_sw1->tmp;

        if (!f_sw0 || !f_sw1) {
                OSM_LOG(&t->osm->log, OSM_LOG_ERROR,
                        "ERR 4E1A: missing fabric switches!\n"
                        "  switch GUIDs: 0x%04"PRIx64" 0x%04"PRIx64"\n",
                        cl_ntoh64(t_sw0->n_id), cl_ntoh64(t_sw1->n_id));
                goto out;
        }
        pg0 = &t_sw0->ptgrp[2*cdir + 1];
        pg0->type = PASSTHRU;

        pg1 = &t_sw1->ptgrp[2*cdir];
        pg1->type = PASSTHRU;

        port_cnt = f_sw0->port_cnt;
        /*
         * Find all the links between these two switches.
         */
        for (p = 0; p < port_cnt; p++) {
                struct endpoint *f_ep0 = NULL, *f_ep1 = NULL;

                if (!f_sw0->port[p] || !f_sw0->port[p]->link)
                        continue;

                if (f_sw0->port[p]->link->end[0].n_id == t_sw0->n_id &&
                    f_sw0->port[p]->link->end[1].n_id == t_sw1->n_id) {

                        f_ep0 = &f_sw0->port[p]->link->end[0];
                        f_ep1 = &f_sw0->port[p]->link->end[1];
                } else if (f_sw0->port[p]->link->end[1].n_id == t_sw0->n_id &&
                           f_sw0->port[p]->link->end[0].n_id == t_sw1->n_id) {

                        f_ep0 = &f_sw0->port[p]->link->end[1];
                        f_ep1 = &f_sw0->port[p]->link->end[0];
                } else
                        continue;

                if (!(f_ep0->type == PASSTHRU && f_ep1->type == PASSTHRU)) {
                        OSM_LOG(&t->osm->log, OSM_LOG_ERROR,
                                "ERR 4E1B: not interswitch "
                                "link:\n  0x%04"PRIx64"/%d <-> 0x%04"PRIx64"/%d\n",
                                cl_ntoh64(f_ep0->n_id), f_ep0->port,
                                cl_ntoh64(f_ep1->n_id), f_ep1->port);
                        goto out;
                }
                /*
                 * Skip over links that already have been established in the
                 * torus.
                 */
                if (!(f_ep0->sw && f_ep1->sw))
                        continue;

                if (!connect_tlink(pg0, f_ep0, pg1, f_ep1, t))
                        goto out;
        }
        success = true;
out:
        return success;
}

static
bool link_srcsink(struct torus *t, int i, int j, int k)
{
        struct endpoint *f_ep0;
        struct endpoint *f_ep1;
        struct t_switch *tsw;
        struct f_switch *fsw;
        struct port_grp *pg;
        struct link *fl, *tl;
        unsigned p, port_cnt;
        bool success = false;

        i = canonicalize(i, t->x_sz);
        j = canonicalize(j, t->y_sz);
        k = canonicalize(k, t->z_sz);

        tsw = t->sw[i][j][k];
        if (!tsw)
                return true;

        fsw = tsw->tmp;
        /*
         * link_srcsink is supposed to get called once for every switch in
         * the fabric.  At this point every fsw we encounter must have a
         * non-null osm_switch.  Otherwise something has gone horribly
         * wrong with topology discovery; the most likely reason is that
         * the fabric contains a radix-4 torus dimension, but the user gave
         * a config that didn't say so, breaking all the checking in
         * safe_x_perpendicular and friends.
         */
        if (!(fsw && fsw->osm_switch)) {
                OSM_LOG(&t->osm->log, OSM_LOG_ERROR,
                        "ERR 4E1C: Invalid topology discovery. "
                        "Verify torus-2QoS.conf contents.\n");
                return false;
        }

        pg = &tsw->ptgrp[2 * TORUS_MAX_DIM];
        pg->type = SRCSINK;
        tsw->osm_switch = fsw->osm_switch;
        tsw->osm_switch->priv = tsw;
        fsw->osm_switch = NULL;

        port_cnt = fsw->port_cnt;
        for (p = 0; p < port_cnt; p++) {

                if (!fsw->port[p])
                        continue;

                if (fsw->port[p]->type == SRCSINK) {
                        /*
                         * If the endpoint is the switch port used for in-band
                         * communication with the switch itself, move it to
                         * the torus.
                         */
                        if (pg->port_cnt == t->portgrp_sz) {
                                OSM_LOG(&t->osm->log, OSM_LOG_ERROR,
                                        "ERR 4E1D: exceeded port group max port "
                                        "count (%d): switch GUID 0x%04"PRIx64"\n",
                                        t->portgrp_sz, cl_ntoh64(tsw->n_id));
                                goto out;
                        }
                        fsw->port[p]->sw = tsw;
                        fsw->port[p]->pgrp = pg;
                        tsw->port[p] = fsw->port[p];
                        tsw->port[p]->osm_port->priv = tsw->port[p];
                        pg->port[pg->port_cnt++] = fsw->port[p];
                        fsw->port[p] = NULL;

                } else if (fsw->port[p]->link &&
                           fsw->port[p]->type == PASSTHRU) {
                        /*
                         * If the endpoint is a link to a CA, create a new link
                         * in the torus.  Disconnect the fabric link.
                         */

                        fl = fsw->port[p]->link;

                        if (fl->end[0].sw == fsw) {
                                f_ep0 = &fl->end[0];
                                f_ep1 = &fl->end[1];
                        } else if (fl->end[1].sw == fsw) {
                                f_ep1 = &fl->end[0];
                                f_ep0 = &fl->end[1];
                        } else
                                continue;

                        if (f_ep1->type != SRCSINK)
                                continue;

                        if (pg->port_cnt == t->portgrp_sz) {
                                OSM_LOG(&t->osm->log, OSM_LOG_ERROR,
                                        "ERR 4E1E: exceeded port group max port "
                                        "count (%d): switch GUID 0x%04"PRIx64"\n",
                                        t->portgrp_sz, cl_ntoh64(tsw->n_id));
                                goto out;
                        }
                        /*
                         * Switch ports connected to links don't get
                         * associated with osm_port_t objects; see
                         * capture_fabric().  So just check CA end.
                         */
                        if (!f_ep1->osm_port) {
                                OSM_LOG(&t->osm->log, OSM_LOG_ERROR,
                                        "ERR 4E1F: NULL osm_port->priv port "
                                        "GUID 0x%04"PRIx64"\n",
                                        cl_ntoh64(f_ep1->n_id));
                                goto out;
                        }
                        tl = alloc_tlink(t);
                        if (!tl)
                                continue;

                        tl->end[0].type = f_ep0->type;
                        tl->end[0].port = f_ep0->port;
                        tl->end[0].n_id = f_ep0->n_id;
                        tl->end[0].sw = tsw;
                        tl->end[0].link = tl;
                        tl->end[0].pgrp = pg;
                        pg->port[pg->port_cnt++] = &tl->end[0];
                        pg->sw->port[f_ep0->port] =  &tl->end[0];

                        tl->end[1].type = f_ep1->type;
                        tl->end[1].port = f_ep1->port;
                        tl->end[1].n_id = f_ep1->n_id;
                        tl->end[1].sw = NULL;   /* Correct for a CA */
                        tl->end[1].link = tl;
                        tl->end[1].pgrp = NULL; /* Correct for a CA */

                        tl->end[1].osm_port = f_ep1->osm_port;
                        tl->end[1].osm_port->priv = &tl->end[1];
                        f_ep1->osm_port = NULL;

                        t->ca_cnt++;
                        f_ep0->sw = NULL;
                        f_ep0->port = -1;
                        fsw->port[p] = NULL;
                }
        }
        success = true;
out:
        return success;
}

static
struct f_switch *ffind_face_corner(struct f_switch *fsw0,
                                   struct f_switch *fsw1,
                                   struct f_switch *fsw2)
{
        int p0, p3;
        struct link *l;
        struct endpoint *far_end;
        struct f_switch *fsw, *fsw3 = NULL;

        if (!(fsw0 && fsw1 && fsw2))
                goto out;

        for (p0 = 0; p0 < fsw0->port_cnt; p0++) {
                /*
                 * Ignore everything except switch links that haven't
                 * been installed into the torus.
                 */
                if (!(fsw0->port[p0] && fsw0->port[p0]->sw &&
                      fsw0->port[p0]->type == PASSTHRU))
                        continue;

                l = fsw0->port[p0]->link;

                if (l->end[0].n_id == fsw0->n_id)
                        far_end = &l->end[1];
                else
                        far_end = &l->end[0];

                /*
                 * Ignore CAs
                 */
                if (!(far_end->type == PASSTHRU && far_end->sw))
                        continue;

                fsw3 = far_end->sw;
                if (fsw3->n_id == fsw1->n_id)   /* existing corner */
                        continue;

                for (p3 = 0; p3 < fsw3->port_cnt; p3++) {
                        /*
                         * Ignore everything except switch links that haven't
                         * been installed into the torus.
                         */
                        if (!(fsw3->port[p3] && fsw3->port[p3]->sw &&
                              fsw3->port[p3]->type == PASSTHRU))
                                continue;

                        l = fsw3->port[p3]->link;

                        if (l->end[0].n_id == fsw3->n_id)
                                far_end = &l->end[1];
                        else
                                far_end = &l->end[0];

                        /*
                         * Ignore CAs
                         */
                        if (!(far_end->type == PASSTHRU && far_end->sw))
                                continue;

                        fsw = far_end->sw;
                        if (fsw->n_id == fsw2->n_id)
                                goto out;
                }
        }
        fsw3 = NULL;
out:
        return fsw3;
}

static
struct f_switch *tfind_face_corner(struct t_switch *tsw0,
                                   struct t_switch *tsw1,
                                   struct t_switch *tsw2)
{
        if (!(tsw0 && tsw1 && tsw2))
                return NULL;

        return ffind_face_corner(tsw0->tmp, tsw1->tmp, tsw2->tmp);
}

/*
 * This code can break on any torus with a dimension that has radix four.
 *
 * What is supposed to happen is that this code will find the
 * two faces whose shared edge is the desired perpendicular.
 *
 * What actually happens is while searching we send two connected
 * edges that are colinear in a torus dimension with radix four to
 * ffind_face_corner(), which tries to complete a face by finding a
 * 4-loop of edges.
 *
 * In the radix four torus case, it can find a 4-loop which is a ring in a
 * dimension with radix four, rather than the desired face.  It thus returns
 * true when it shouldn't, so the wrong edge is returned as the perpendicular.
 *
 * The appropriate instance of safe_N_perpendicular() (where N == x, y, z)
 * should be used to determine if it is safe to call ffind_perpendicular();
 * these functions will return false it there is a possibility of finding
 * a wrong perpendicular.
 */
struct f_switch *ffind_3d_perpendicular(struct f_switch *fsw0,
                                        struct f_switch *fsw1,
                                        struct f_switch *fsw2,
                                        struct f_switch *fsw3)
{
        int p1;
        struct link *l;
        struct endpoint *far_end;
        struct f_switch *fsw4 = NULL;

        if (!(fsw0 && fsw1 && fsw2 && fsw3))
                goto out;

        /*
         * Look at all the ports on the switch, fsw1,  that is the base of
         * the perpendicular.
         */
        for (p1 = 0; p1 < fsw1->port_cnt; p1++) {
                /*
                 * Ignore everything except switch links that haven't
                 * been installed into the torus.
                 */
                if (!(fsw1->port[p1] && fsw1->port[p1]->sw &&
                      fsw1->port[p1]->type == PASSTHRU))
                        continue;

                l = fsw1->port[p1]->link;

                if (l->end[0].n_id == fsw1->n_id)
                        far_end = &l->end[1];
                else
                        far_end = &l->end[0];
                /*
                 * Ignore CAs
                 */
                if (!(far_end->type == PASSTHRU && far_end->sw))
                        continue;

                fsw4 = far_end->sw;
                if (fsw4->n_id == fsw3->n_id)   /* wrong perpendicular */
                        continue;

                if (ffind_face_corner(fsw0, fsw1, fsw4) &&
                    ffind_face_corner(fsw2, fsw1, fsw4))
                        goto out;
        }
        fsw4 = NULL;
out:
        return fsw4;
}
struct f_switch *ffind_2d_perpendicular(struct f_switch *fsw0,
                                        struct f_switch *fsw1,
                                        struct f_switch *fsw2)
{
        int p1;
        struct link *l;
        struct endpoint *far_end;
        struct f_switch *fsw3 = NULL;

        if (!(fsw0 && fsw1 && fsw2))
                goto out;

        /*
         * Look at all the ports on the switch, fsw1,  that is the base of
         * the perpendicular.
         */
        for (p1 = 0; p1 < fsw1->port_cnt; p1++) {
                /*
                 * Ignore everything except switch links that haven't
                 * been installed into the torus.
                 */
                if (!(fsw1->port[p1] && fsw1->port[p1]->sw &&
                      fsw1->port[p1]->type == PASSTHRU))
                        continue;

                l = fsw1->port[p1]->link;

                if (l->end[0].n_id == fsw1->n_id)
                        far_end = &l->end[1];
                else
                        far_end = &l->end[0];
                /*
                 * Ignore CAs
                 */
                if (!(far_end->type == PASSTHRU && far_end->sw))
                        continue;

                fsw3 = far_end->sw;
                if (fsw3->n_id == fsw2->n_id)   /* wrong perpendicular */
                        continue;

                if (ffind_face_corner(fsw0, fsw1, fsw3))
                        goto out;
        }
        fsw3 = NULL;
out:
        return fsw3;
}

static
struct f_switch *tfind_3d_perpendicular(struct t_switch *tsw0,
                                        struct t_switch *tsw1,
                                        struct t_switch *tsw2,
                                        struct t_switch *tsw3)
{
        if (!(tsw0 && tsw1 && tsw2 && tsw3))
                return NULL;

        return ffind_3d_perpendicular(tsw0->tmp, tsw1->tmp,
                                      tsw2->tmp, tsw3->tmp);
}

static
struct f_switch *tfind_2d_perpendicular(struct t_switch *tsw0,
                                        struct t_switch *tsw1,
                                        struct t_switch *tsw2)
{
        if (!(tsw0 && tsw1 && tsw2))
                return NULL;

        return ffind_2d_perpendicular(tsw0->tmp, tsw1->tmp, tsw2->tmp);
}

static
bool safe_x_ring(struct torus *t, int i, int j, int k)
{
        int im1, ip1, ip2;
        bool success = true;

        /*
         * If this x-direction radix-4 ring has at least two links
         * already installed into the torus,  then this ring does not
         * prevent us from looking for y or z direction perpendiculars.
         *
         * It is easier to check for the appropriate switches being installed
         * into the torus than it is to check for the links, so force the
         * link installation if the appropriate switches are installed.
         *
         * Recall that canonicalize(n - 2, 4) == canonicalize(n + 2, 4).
         */
        if (t->x_sz != 4 || t->flags & X_MESH)
                goto out;

        im1 = canonicalize(i - 1, t->x_sz);
        ip1 = canonicalize(i + 1, t->x_sz);
        ip2 = canonicalize(i + 2, t->x_sz);

        if (!!t->sw[im1][j][k] +
            !!t->sw[ip1][j][k] + !!t->sw[ip2][j][k] < 2) {
                success = false;
                goto out;
        }
        if (t->sw[ip2][j][k] && t->sw[im1][j][k])
                success = link_tswitches(t, 0,
                                         t->sw[ip2][j][k],
                                         t->sw[im1][j][k])
                        && success;

        if (t->sw[im1][j][k] && t->sw[i][j][k])
                success = link_tswitches(t, 0,
                                         t->sw[im1][j][k],
                                         t->sw[i][j][k])
                        && success;

        if (t->sw[i][j][k] && t->sw[ip1][j][k])
                success = link_tswitches(t, 0,
                                         t->sw[i][j][k],
                                         t->sw[ip1][j][k])
                        && success;

        if (t->sw[ip1][j][k] && t->sw[ip2][j][k])
                success = link_tswitches(t, 0,
                                         t->sw[ip1][j][k],
                                         t->sw[ip2][j][k])
                        && success;
out:
        return success;
}

static
bool safe_y_ring(struct torus *t, int i, int j, int k)
{
        int jm1, jp1, jp2;
        bool success = true;

        /*
         * If this y-direction radix-4 ring has at least two links
         * already installed into the torus,  then this ring does not
         * prevent us from looking for x or z direction perpendiculars.
         *
         * It is easier to check for the appropriate switches being installed
         * into the torus than it is to check for the links, so force the
         * link installation if the appropriate switches are installed.
         *
         * Recall that canonicalize(n - 2, 4) == canonicalize(n + 2, 4).
         */
        if (t->y_sz != 4 || (t->flags & Y_MESH))
                goto out;

        jm1 = canonicalize(j - 1, t->y_sz);
        jp1 = canonicalize(j + 1, t->y_sz);
        jp2 = canonicalize(j + 2, t->y_sz);

        if (!!t->sw[i][jm1][k] +
            !!t->sw[i][jp1][k] + !!t->sw[i][jp2][k] < 2) {
                success = false;
                goto out;
        }
        if (t->sw[i][jp2][k] && t->sw[i][jm1][k])
                success = link_tswitches(t, 1,
                                         t->sw[i][jp2][k],
                                         t->sw[i][jm1][k])
                        && success;

        if (t->sw[i][jm1][k] && t->sw[i][j][k])
                success = link_tswitches(t, 1,
                                         t->sw[i][jm1][k],
                                         t->sw[i][j][k])
                        && success;

        if (t->sw[i][j][k] && t->sw[i][jp1][k])
                success = link_tswitches(t, 1,
                                         t->sw[i][j][k],
                                         t->sw[i][jp1][k])
                        && success;

        if (t->sw[i][jp1][k] && t->sw[i][jp2][k])
                success = link_tswitches(t, 1,
                                         t->sw[i][jp1][k],
                                         t->sw[i][jp2][k])
                        && success;
out:
        return success;
}

static
bool safe_z_ring(struct torus *t, int i, int j, int k)
{
        int km1, kp1, kp2;
        bool success = true;

        /*
         * If this z-direction radix-4 ring has at least two links
         * already installed into the torus,  then this ring does not
         * prevent us from looking for x or y direction perpendiculars.
         *
         * It is easier to check for the appropriate switches being installed
         * into the torus than it is to check for the links, so force the
         * link installation if the appropriate switches are installed.
         *
         * Recall that canonicalize(n - 2, 4) == canonicalize(n + 2, 4).
         */
        if (t->z_sz != 4 || t->flags & Z_MESH)
                goto out;

        km1 = canonicalize(k - 1, t->z_sz);
        kp1 = canonicalize(k + 1, t->z_sz);
        kp2 = canonicalize(k + 2, t->z_sz);

        if (!!t->sw[i][j][km1] +
            !!t->sw[i][j][kp1] + !!t->sw[i][j][kp2] < 2) {
                success = false;
                goto out;
        }
        if (t->sw[i][j][kp2] && t->sw[i][j][km1])
                success = link_tswitches(t, 2,
                                         t->sw[i][j][kp2],
                                         t->sw[i][j][km1])
                        && success;

        if (t->sw[i][j][km1] && t->sw[i][j][k])
                success = link_tswitches(t, 2,
                                         t->sw[i][j][km1],
                                         t->sw[i][j][k])
                        && success;

        if (t->sw[i][j][k] && t->sw[i][j][kp1])
                success = link_tswitches(t, 2,
                                         t->sw[i][j][k],
                                         t->sw[i][j][kp1])
                        && success;

        if (t->sw[i][j][kp1] && t->sw[i][j][kp2])
                success = link_tswitches(t, 2,
                                         t->sw[i][j][kp1],
                                         t->sw[i][j][kp2])
                        && success;
out:
        return success;
}

/*
 * These functions return true when it safe to call
 * tfind_3d_perpendicular()/ffind_3d_perpendicular().
 */
static
bool safe_x_perpendicular(struct torus *t, int i, int j, int k)
{
        /*
         * If the dimensions perpendicular to the search direction are
         * not radix 4 torus dimensions, it is always safe to search for
         * a perpendicular.
         *
         * Here we are checking for enough appropriate links having been
         * installed into the torus to prevent an incorrect link from being
         * considered as a perpendicular candidate.
         */
        return safe_y_ring(t, i, j, k) && safe_z_ring(t, i, j, k);
}

static
bool safe_y_perpendicular(struct torus *t, int i, int j, int k)
{
        /*
         * If the dimensions perpendicular to the search direction are
         * not radix 4 torus dimensions, it is always safe to search for
         * a perpendicular.
         *
         * Here we are checking for enough appropriate links having been
         * installed into the torus to prevent an incorrect link from being
         * considered as a perpendicular candidate.
         */
        return safe_x_ring(t, i, j, k) && safe_z_ring(t, i, j, k);
}

static
bool safe_z_perpendicular(struct torus *t, int i, int j, int k)
{
        /*
         * If the dimensions perpendicular to the search direction are
         * not radix 4 torus dimensions, it is always safe to search for
         * a perpendicular.
         *
         * Implement this by checking for enough appropriate links having
         * been installed into the torus to prevent an incorrect link from
         * being considered as a perpendicular candidate.
         */
        return safe_x_ring(t, i, j, k) && safe_y_ring(t, i, j, k);
}

/*
 * Templates for determining 2D/3D case fingerprints. Recall that if
 * a fingerprint bit is set the corresponding switch is absent from
 * the all-switches-present template.
 *
 * I.e., for the 2D case where the x,y dimensions have a radix greater
 * than one, and the z dimension has radix 1, fingerprint bits 4-7 are
 * always zero.
 *
 * For the 2D case where the x,z dimensions have a radix greater than
 * one, and the y dimension has radix 1, fingerprint bits 2,3,6,7 are
 * always zero.
 *
 * For the 2D case where the y,z dimensions have a radix greater than
 * one, and the x dimension has radix 1, fingerprint bits 1,3,5,7 are
 * always zero.
 *
 * Recall also that bits 8-10 distinguish between 2D and 3D cases.
 * If bit 8+d is set, for 0 <= d < 3;  the d dimension of the desired
 * torus has radix greater than 1.
 */

/*
 * 2D case 0x300
 *  b0: t->sw[i  ][j  ][0  ]
 *  b1: t->sw[i+1][j  ][0  ]
 *  b2: t->sw[i  ][j+1][0  ]
 *  b3: t->sw[i+1][j+1][0  ]
 *                                    O . . . . . O
 * 2D case 0x500                      .           .
 *  b0: t->sw[i  ][0  ][k  ]          .           .
 *  b1: t->sw[i+1][0  ][k  ]          .           .
 *  b4: t->sw[i  ][0  ][k+1]          .           .
 *  b5: t->sw[i+1][0  ][k+1]          .           .
 *                                    @ . . . . . O
 * 2D case 0x600
 *  b0: t->sw[0  ][j  ][k  ]
 *  b2: t->sw[0  ][j+1][k  ]
 *  b4: t->sw[0  ][j  ][k+1]
 *  b6: t->sw[0  ][j+1][k+1]
 */

/*
 * 3D case 0x700:                           O
 *                                        . . .
 *  b0: t->sw[i  ][j  ][k  ]            .   .   .
 *  b1: t->sw[i+1][j  ][k  ]          .     .     .
 *  b2: t->sw[i  ][j+1][k  ]        .       .       .
 *  b3: t->sw[i+1][j+1][k  ]      O         .         O
 *  b4: t->sw[i  ][j  ][k+1]      . .       O       . .
 *  b5: t->sw[i+1][j  ][k+1]      .   .   .   .   .   .
 *  b6: t->sw[i  ][j+1][k+1]      .     .       .     .
 *  b7: t->sw[i+1][j+1][k+1]      .   .   .   .   .   .
 *                                . .       O       . .
 *                                O         .         O
 *                                  .       .       .
 *                                    .     .     .
 *                                      .   .   .
 *                                        . . .
 *                                          @
 */

static
void log_no_crnr(struct torus *t, unsigned n,
                 int case_i, int case_j, int case_k,
                 int crnr_i, int crnr_j, int crnr_k)
{
        if (t->debug)
                OSM_LOG(&t->osm->log, OSM_LOG_INFO, "Case 0x%03x "
                        "@ %d %d %d: no corner @ %d %d %d\n",
                        n, case_i, case_j, case_k, crnr_i, crnr_j, crnr_k);
}

static
void log_no_perp(struct torus *t, unsigned n,
                 int case_i, int case_j, int case_k,
                 int perp_i, int perp_j, int perp_k)
{
        if (t->debug)
                OSM_LOG(&t->osm->log, OSM_LOG_INFO, "Case 0x%03x "
                        "@ %d %d %d: no perpendicular @ %d %d %d\n",
                        n, case_i, case_j, case_k, perp_i, perp_j, perp_k);
}

/*
 * Handle the 2D cases with a single existing edge.
 *
 */

/*
 * 2D case 0x30c
 *  b0: t->sw[i  ][j  ][0  ]
 *  b1: t->sw[i+1][j  ][0  ]
 *  b2:
 *  b3:
 *                                    O           O
 * 2D case 0x530
 *  b0: t->sw[i  ][0  ][k  ]
 *  b1: t->sw[i+1][0  ][k  ]
 *  b4:
 *  b5:
 *                                    @ . . . . . O
 * 2D case 0x650
 *  b0: t->sw[0  ][j  ][k  ]
 *  b2: t->sw[0  ][j+1][k  ]
 *  b4:
 *  b6:
 */
static
bool handle_case_0x30c(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int jm1 = canonicalize(j - 1, t->y_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);

        if (safe_y_perpendicular(t, i, j, k) &&
            install_tswitch(t, i, jp1, k,
                            tfind_2d_perpendicular(t->sw[ip1][j][k],
                                                   t->sw[i][j][k],
                                                   t->sw[i][jm1][k]))) {
                return true;
        }
        log_no_perp(t, 0x30c, i, j, k, i, j, k);

        if (safe_y_perpendicular(t, ip1, j, k) &&
            install_tswitch(t, ip1, jp1, k,
                            tfind_2d_perpendicular(t->sw[i][j][k],
                                                   t->sw[ip1][j][k],
                                                   t->sw[ip1][jm1][k]))) {
                return true;
        }
        log_no_perp(t, 0x30c, i, j, k, ip1, j, k);
        return false;
}

static
bool handle_case_0x530(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int km1 = canonicalize(k - 1, t->z_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (safe_z_perpendicular(t, i, j, k) &&
            install_tswitch(t, i, j, kp1,
                            tfind_2d_perpendicular(t->sw[ip1][j][k],
                                                   t->sw[i][j][k],
                                                   t->sw[i][j][km1]))) {
                return true;
        }
        log_no_perp(t, 0x530, i, j, k, i, j, k);

        if (safe_z_perpendicular(t, ip1, j, k) &&
              install_tswitch(t, ip1, j, kp1,
                              tfind_2d_perpendicular(t->sw[i][j][k],
                                                     t->sw[ip1][j][k],
                                                     t->sw[ip1][j][km1]))) {
                return true;
        }
        log_no_perp(t, 0x530, i, j, k, ip1, j, k);
        return false;
}

static
bool handle_case_0x650(struct torus *t, int i, int j, int k)
{
        int jp1 = canonicalize(j + 1, t->y_sz);
        int km1 = canonicalize(k - 1, t->z_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (safe_z_perpendicular(t, i, j, k) &&
            install_tswitch(t, i, j, kp1,
                            tfind_2d_perpendicular(t->sw[i][jp1][k],
                                                   t->sw[i][j][k],
                                                   t->sw[i][j][km1]))) {
                return true;
        }
        log_no_perp(t, 0x650, i, j, k, i, j, k);

        if (safe_z_perpendicular(t, i, jp1, k) &&
            install_tswitch(t, i, jp1, kp1,
                            tfind_2d_perpendicular(t->sw[i][j][k],
                                                   t->sw[i][jp1][k],
                                                   t->sw[i][jp1][km1]))) {
                return true;
        }
        log_no_perp(t, 0x650, i, j, k, i, jp1, k);
        return false;
}

/*
 * 2D case 0x305
 *  b0:
 *  b1: t->sw[i+1][j  ][0  ]
 *  b2:
 *  b3: t->sw[i+1][j+1][0  ]
 *                                    O           O
 * 2D case 0x511                                  .
 *  b0:                                           .
 *  b1: t->sw[i+1][0  ][k  ]                      .
 *  b4:                                           .
 *  b5: t->sw[i+1][0  ][k+1]                      .
 *                                    @           O
 * 2D case 0x611
 *  b0:
 *  b2: t->sw[0  ][j+1][k  ]
 *  b4:
 *  b6: t->sw[0  ][j+1][k+1]
 */
static
bool handle_case_0x305(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int ip2 = canonicalize(i + 2, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);

        if (safe_x_perpendicular(t, ip1, j, k) &&
            install_tswitch(t, i, j, k,
                            tfind_2d_perpendicular(t->sw[ip1][jp1][k],
                                                   t->sw[ip1][j][k],
                                                   t->sw[ip2][j][k]))) {
                return true;
        }
        log_no_perp(t, 0x305, i, j, k, ip1, j, k);

        if (safe_x_perpendicular(t, ip1, jp1, k) &&
            install_tswitch(t, i, jp1, k,
                            tfind_2d_perpendicular(t->sw[ip1][j][k],
                                                   t->sw[ip1][jp1][k],
                                                   t->sw[ip2][jp1][k]))) {
                return true;
        }
        log_no_perp(t, 0x305, i, j, k, ip1, jp1, k);
        return false;
}

static
bool handle_case_0x511(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int ip2 = canonicalize(i + 2, t->x_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (safe_x_perpendicular(t, ip1, j, k) &&
            install_tswitch(t, i, j, k,
                            tfind_2d_perpendicular(t->sw[ip1][j][kp1],
                                                   t->sw[ip1][j][k],
                                                   t->sw[ip2][j][k]))) {
                return true;
        }
        log_no_perp(t, 0x511, i, j, k, ip1, j, k);

        if (safe_x_perpendicular(t, ip1, j, kp1) &&
            install_tswitch(t, i, j, kp1,
                            tfind_2d_perpendicular(t->sw[ip1][j][k],
                                                   t->sw[ip1][j][kp1],
                                                   t->sw[ip2][j][kp1]))) {
                return true;
        }
        log_no_perp(t, 0x511, i, j, k, ip1, j, kp1);
        return false;
}

static
bool handle_case_0x611(struct torus *t, int i, int j, int k)
{
        int jp1 = canonicalize(j + 1, t->y_sz);
        int jp2 = canonicalize(j + 2, t->y_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (safe_y_perpendicular(t, i, jp1, k) &&
            install_tswitch(t, i, j, k,
                            tfind_2d_perpendicular(t->sw[i][jp1][kp1],
                                                   t->sw[i][jp1][k],
                                                   t->sw[i][jp2][k]))) {
                return true;
        }
        log_no_perp(t, 0x611, i, j, k, i, jp1, k);

        if (safe_y_perpendicular(t, i, jp1, kp1) &&
            install_tswitch(t, i, j, kp1,
                            tfind_2d_perpendicular(t->sw[i][jp1][k],
                                                   t->sw[i][jp1][kp1],
                                                   t->sw[i][jp2][kp1]))) {
                return true;
        }
        log_no_perp(t, 0x611, i, j, k, i, jp1, kp1);
        return false;
}

/*
 * 2D case 0x303
 *  b0:
 *  b1:
 *  b2: t->sw[i  ][j+1][0  ]
 *  b3: t->sw[i+1][j+1][0  ]
 *                                    O . . . . . O
 * 2D case 0x503
 *  b0:
 *  b1:
 *  b4: t->sw[i  ][0  ][k+1]
 *  b5: t->sw[i+1][0  ][k+1]
 *                                    @           O
 * 2D case 0x605
 *  b0:
 *  b2:
 *  b4: t->sw[0  ][j  ][k+1]
 *  b6: t->sw[0  ][j+1][k+1]
 */
static
bool handle_case_0x303(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);
        int jp2 = canonicalize(j + 2, t->y_sz);

        if (safe_y_perpendicular(t, i, jp1, k) &&
            install_tswitch(t, i, j, k,
                            tfind_2d_perpendicular(t->sw[ip1][jp1][k],
                                                   t->sw[i][jp1][k],
                                                   t->sw[i][jp2][k]))) {
                return true;
        }
        log_no_perp(t, 0x303, i, j, k, i, jp1, k);

        if (safe_y_perpendicular(t, ip1, jp1, k) &&
            install_tswitch(t, ip1, j, k,
                            tfind_2d_perpendicular(t->sw[i][jp1][k],
                                                   t->sw[ip1][jp1][k],
                                                   t->sw[ip1][jp2][k]))) {
                return true;
        }
        log_no_perp(t, 0x303, i, j, k, ip1, jp1, k);
        return false;
}

static
bool handle_case_0x503(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);
        int kp2 = canonicalize(k + 2, t->z_sz);

        if (safe_z_perpendicular(t, i, j, kp1) &&
            install_tswitch(t, i, j, k,
                            tfind_2d_perpendicular(t->sw[ip1][j][kp1],
                                                   t->sw[i][j][kp1],
                                                   t->sw[i][j][kp2]))) {
                return true;
        }
        log_no_perp(t, 0x503, i, j, k, i, j, kp1);

        if (safe_z_perpendicular(t, ip1, j, kp1) &&
            install_tswitch(t, ip1, j, k,
                            tfind_2d_perpendicular(t->sw[i][j][kp1],
                                                   t->sw[ip1][j][kp1],
                                                   t->sw[ip1][j][kp2]))) {
                return true;
        }
        log_no_perp(t, 0x503, i, j, k, ip1, j, kp1);
        return false;
}

static
bool handle_case_0x605(struct torus *t, int i, int j, int k)
{
        int jp1 = canonicalize(j + 1, t->y_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);
        int kp2 = canonicalize(k + 2, t->z_sz);

        if (safe_z_perpendicular(t, i, j, kp1) &&
            install_tswitch(t, i, j, k,
                            tfind_2d_perpendicular(t->sw[i][jp1][kp1],
                                                   t->sw[i][j][kp1],
                                                   t->sw[i][j][kp2]))) {
                return true;
        }
        log_no_perp(t, 0x605, i, j, k, i, j, kp1);

        if (safe_z_perpendicular(t, i, jp1, kp1) &&
            install_tswitch(t, i, jp1, k,
                            tfind_2d_perpendicular(t->sw[i][j][kp1],
                                                   t->sw[i][jp1][kp1],
                                                   t->sw[i][jp1][kp2]))) {
                return true;
        }
        log_no_perp(t, 0x605, i, j, k, i, jp1, kp1);
        return false;
}

/*
 * 2D case 0x30a
 *  b0: t->sw[i  ][j  ][0  ]
 *  b1:
 *  b2: t->sw[i  ][j+1][0  ]
 *  b3:
 *                                    O           O
 * 2D case 0x522                      .
 *  b0: t->sw[i  ][0  ][k  ]          .
 *  b1:                               .
 *  b4: t->sw[i  ][0  ][k+1]          .
 *  b5:                               .
 *                                    @           O
 * 2D case 0x644
 *  b0: t->sw[0  ][j  ][k  ]
 *  b2:
 *  b4: t->sw[0  ][j  ][k+1]
 *  b6:
 */
static
bool handle_case_0x30a(struct torus *t, int i, int j, int k)
{
        int im1 = canonicalize(i - 1, t->x_sz);
        int ip1 = canonicalize(i + 1, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);

        if (safe_x_perpendicular(t, i, j, k) &&
            install_tswitch(t, ip1, j, k,
                            tfind_2d_perpendicular(t->sw[i][jp1][k],
                                                   t->sw[i][j][k],
                                                   t->sw[im1][j][k]))) {
                return true;
        }
        log_no_perp(t, 0x30a, i, j, k, i, j, k);

        if (safe_x_perpendicular(t, i, jp1, k) &&
            install_tswitch(t, ip1, jp1, k,
                            tfind_2d_perpendicular(t->sw[i][j][k],
                                                   t->sw[i][jp1][k],
                                                   t->sw[im1][jp1][k]))) {
                return true;
        }
        log_no_perp(t, 0x30a, i, j, k, i, jp1, k);
        return false;
}

static
bool handle_case_0x522(struct torus *t, int i, int j, int k)
{
        int im1 = canonicalize(i - 1, t->x_sz);
        int ip1 = canonicalize(i + 1, t->x_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (safe_x_perpendicular(t, i, j, k) &&
            install_tswitch(t, ip1, j, k,
                            tfind_2d_perpendicular(t->sw[i][j][kp1],
                                                   t->sw[i][j][k],
                                                   t->sw[im1][j][k]))) {
                return true;
        }
        log_no_perp(t, 0x522, i, j, k, i, j, k);

        if (safe_x_perpendicular(t, i, j, kp1) &&
            install_tswitch(t, ip1, j, kp1,
                            tfind_2d_perpendicular(t->sw[i][j][k],
                                                   t->sw[i][j][kp1],
                                                   t->sw[im1][j][kp1]))) {
                return true;
        }
        log_no_perp(t, 0x522, i, j, k, i, j, kp1);
        return false;
}

static
bool handle_case_0x644(struct torus *t, int i, int j, int k)
{
        int jm1 = canonicalize(j - 1, t->y_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (safe_y_perpendicular(t, i, j, k) &&
            install_tswitch(t, i, jp1, k,
                            tfind_2d_perpendicular(t->sw[i][j][kp1],
                                                   t->sw[i][j][k],
                                                   t->sw[i][jm1][k]))) {
                return true;
        }
        log_no_perp(t, 0x644, i, j, k, i, j, k);

        if (safe_y_perpendicular(t, i, j, kp1) &&
            install_tswitch(t, i, jp1, kp1,
                            tfind_2d_perpendicular(t->sw[i][j][k],
                                                   t->sw[i][j][kp1],
                                                   t->sw[i][jm1][kp1]))) {
                return true;
        }
        log_no_perp(t, 0x644, i, j, k, i, j, kp1);
        return false;
}

/*
 * Handle the 2D cases where two existing edges meet at a corner.
 *
 */

/*
 * 2D case 0x301
 *  b0:
 *  b1: t->sw[i+1][j  ][0  ]
 *  b2: t->sw[i  ][j+1][0  ]
 *  b3: t->sw[i+1][j+1][0  ]
 *                                    O . . . . . O
 * 2D case 0x501                                  .
 *  b0:                                           .
 *  b1: t->sw[i+1][0  ][k  ]                      .
 *  b4: t->sw[i  ][0  ][k+1]                      .
 *  b5: t->sw[i+1][0  ][k+1]                      .
 *                                    @           O
 * 2D case 0x601
 *  b0:
 *  b2: t->sw[0  ][j+1][k  ]
 *  b4: t->sw[0  ][j  ][k+1]
 *  b6: t->sw[0  ][j+1][k+1]
 */
static
bool handle_case_0x301(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);

        if (install_tswitch(t, i, j, k,
                            tfind_face_corner(t->sw[ip1][j][k],
                                              t->sw[ip1][jp1][k],
                                              t->sw[i][jp1][k]))) {
                return true;
        }
        log_no_crnr(t, 0x301, i, j, k, i, j, k);
        return false;
}

static
bool handle_case_0x501(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (install_tswitch(t, i, j, k,
                            tfind_face_corner(t->sw[ip1][j][k],
                                              t->sw[ip1][j][kp1],
                                              t->sw[i][j][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x501, i, j, k, i, j, k);
        return false;
}

static
bool handle_case_0x601(struct torus *t, int i, int j, int k)
{
        int jp1 = canonicalize(j + 1, t->y_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (install_tswitch(t, i, j, k,
                            tfind_face_corner(t->sw[i][jp1][k],
                                              t->sw[i][jp1][kp1],
                                              t->sw[i][j][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x601, i, j, k, i, j, k);
        return false;
}

/*
 * 2D case 0x302
 *  b0: t->sw[i  ][j  ][0  ]
 *  b1:
 *  b2: t->sw[i  ][j+1][0  ]
 *  b3: t->sw[i+1][j+1][0  ]
 *                                    O . . . . . O
 * 2D case 0x502                      .
 *  b0: t->sw[i  ][0  ][k  ]          .
 *  b1:                               .
 *  b4: t->sw[i  ][0  ][k+1]          .
 *  b5: t->sw[i+1][0  ][k+1]          .
 *                                    @           O
 * 2D case 0x604
 *  b0: t->sw[0  ][j  ][k  ]
 *  b2:
 *  b4: t->sw[0  ][j  ][k+1]
 *  b6: t->sw[0  ][j+1][k+1]
 */
static
bool handle_case_0x302(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);

        if (install_tswitch(t, ip1, j, k,
                            tfind_face_corner(t->sw[i][j][k],
                                              t->sw[i][jp1][k],
                                              t->sw[ip1][jp1][k]))) {
                return true;
        }
        log_no_crnr(t, 0x302, i, j, k, ip1, j, k);
        return false;
}

static
bool handle_case_0x502(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (install_tswitch(t, ip1, j, k,
                            tfind_face_corner(t->sw[i][j][k],
                                              t->sw[i][j][kp1],
                                              t->sw[ip1][j][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x502, i, j, k, ip1, j, k);
        return false;
}

static
bool handle_case_0x604(struct torus *t, int i, int j, int k)
{
        int jp1 = canonicalize(j + 1, t->y_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (install_tswitch(t, i, jp1, k,
                            tfind_face_corner(t->sw[i][j][k],
                                              t->sw[i][j][kp1],
                                              t->sw[i][jp1][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x604, i, j, k, i, jp1, k);
        return false;
}


/*
 * 2D case 0x308
 *  b0: t->sw[i  ][j  ][0  ]
 *  b1: t->sw[i+1][j  ][0  ]
 *  b2: t->sw[i  ][j+1][0  ]
 *  b3:
 *                                    O           O
 * 2D case 0x520                      .
 *  b0: t->sw[i  ][0  ][k  ]          .
 *  b1: t->sw[i+1][0  ][k  ]          .
 *  b4: t->sw[i  ][0  ][k+1]          .
 *  b5:                               .
 *                                    @ . . . . . O
 * 2D case 0x640
 *  b0: t->sw[0  ][j  ][k  ]
 *  b2: t->sw[0  ][j+1][k  ]
 *  b4: t->sw[0  ][j  ][k+1]
 *  b6:
 */
static
bool handle_case_0x308(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);

        if (install_tswitch(t, ip1, jp1, k,
                            tfind_face_corner(t->sw[ip1][j][k],
                                              t->sw[i][j][k],
                                              t->sw[i][jp1][k]))) {
                return true;
        }
        log_no_crnr(t, 0x308, i, j, k, ip1, jp1, k);
        return false;
}

static
bool handle_case_0x520(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (install_tswitch(t, ip1, j, kp1,
                            tfind_face_corner(t->sw[ip1][j][k],
                                              t->sw[i][j][k],
                                              t->sw[i][j][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x520, i, j, k, ip1, j, kp1);
        return false;
}

static
bool handle_case_0x640(struct torus *t, int i, int j, int k)
{
        int jp1 = canonicalize(j + 1, t->y_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (install_tswitch(t, i, jp1, kp1,
                            tfind_face_corner(t->sw[i][jp1][k],
                                              t->sw[i][j][k],
                                              t->sw[i][j][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x640, i, j, k, i, jp1, kp1);
        return false;
}

/*
 * 2D case 0x304
 *  b0: t->sw[i  ][j  ][0  ]
 *  b1: t->sw[i+1][j  ][0  ]
 *  b2:
 *  b3: t->sw[i+1][j+1][0  ]
 *                                    O           O
 * 2D case 0x510                                  .
 *  b0: t->sw[i  ][0  ][k  ]                      .
 *  b1: t->sw[i+1][0  ][k  ]                      .
 *  b4:                                           .
 *  b5: t->sw[i+1][0  ][k+1]                      .
 *                                    @ . . . . . O
 * 2D case 0x610
 *  b0: t->sw[0  ][j  ][k  ]
 *  b2: t->sw[0  ][j+1][k  ]
 *  b4:
 *  b6: t->sw[0  ][j+1][k+1]
 */
static
bool handle_case_0x304(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);

        if (install_tswitch(t, i, jp1, k,
                            tfind_face_corner(t->sw[i][j][k],
                                              t->sw[ip1][j][k],
                                              t->sw[ip1][jp1][k]))) {
                return true;
        }
        log_no_crnr(t, 0x304, i, j, k, i, jp1, k);
        return false;
}

static
bool handle_case_0x510(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (install_tswitch(t, i, j, kp1,
                            tfind_face_corner(t->sw[i][j][k],
                                              t->sw[ip1][j][k],
                                              t->sw[ip1][j][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x510, i, j, k, i, j, kp1);
        return false;
}

static
bool handle_case_0x610(struct torus *t, int i, int j, int k)
{
        int jp1 = canonicalize(j + 1, t->y_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (install_tswitch(t, i, j, kp1,
                            tfind_face_corner(t->sw[i][j][k],
                                              t->sw[i][jp1][k],
                                              t->sw[i][jp1][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x610, i, j, k, i, j, kp1);
        return false;
}

/*
 * Handle the 3D cases where two existing edges meet at a corner.
 *
 */

/*
 * 3D case 0x71f:                           O
 *                                        .   .
 *  b0:                                 .       .
 *  b1:                               .           .
 *  b2:                             .               .
 *  b3:                           O                   O
 *  b4:                                     O
 *  b5: t->sw[i+1][j  ][k+1]
 *  b6: t->sw[i  ][j+1][k+1]
 *  b7: t->sw[i+1][j+1][k+1]
 *                                          O
 *                                O                   O
 *
 *
 *
 *
 *                                          @
 */
static
bool handle_case_0x71f(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);
        int kp2 = canonicalize(k + 2, t->z_sz);

        if (safe_z_perpendicular(t, ip1, jp1, kp1) &&
            install_tswitch(t, ip1, jp1, k,
                            tfind_3d_perpendicular(t->sw[ip1][j][kp1],
                                                   t->sw[ip1][jp1][kp1],
                                                   t->sw[i][jp1][kp1],
                                                   t->sw[ip1][jp1][kp2]))) {
                return true;
        }
        log_no_perp(t, 0x71f, i, j, k, ip1, jp1, kp1);
        return false;
}

/*
 * 3D case 0x72f:                           O
 *                                        .
 *  b0:                                 .
 *  b1:                               .
 *  b2:                             .
 *  b3:                           O                   O
 *  b4: t->sw[i  ][j  ][k+1]        .       O
 *  b5:                               .
 *  b6: t->sw[i  ][j+1][k+1]            .
 *  b7: t->sw[i+1][j+1][k+1]              .
 *                                          O
 *                                O                   O
 *
 *
 *
 *
 *                                          @
 */
static
bool handle_case_0x72f(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);
        int kp2 = canonicalize(k + 2, t->z_sz);

        if (safe_z_perpendicular(t, i, jp1, kp1) &&
            install_tswitch(t, i, jp1, k,
                            tfind_3d_perpendicular(t->sw[i][j][kp1],
                                                   t->sw[i][jp1][kp1],
                                                   t->sw[ip1][jp1][kp1],
                                                   t->sw[i][jp1][kp2]))) {
                return true;
        }
        log_no_perp(t, 0x72f, i, j, k, i, jp1, kp1);
        return false;
}

/*
 * 3D case 0x737:                           O
 *                                        . .
 *  b0:                                 .   .
 *  b1:                               .     .
 *  b2:                             .       .
 *  b3: t->sw[i+1][j+1][k  ]      O         .         O
 *  b4:                                     O
 *  b5:
 *  b6: t->sw[i  ][j+1][k+1]
 *  b7: t->sw[i+1][j+1][k+1]
 *                                          O
 *                                O                   O
 *
 *
 *
 *
 *                                          @
 */
static
bool handle_case_0x737(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);
        int jp2 = canonicalize(j + 2, t->y_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (safe_y_perpendicular(t, ip1, jp1, kp1) &&
            install_tswitch(t, ip1, j, kp1,
                            tfind_3d_perpendicular(t->sw[i][jp1][kp1],
                                                   t->sw[ip1][jp1][kp1],
                                                   t->sw[ip1][jp1][k],
                                                   t->sw[ip1][jp2][kp1]))) {
                return true;
        }
        log_no_perp(t, 0x737, i, j, k, ip1, jp1, kp1);
        return false;
}

/*
 * 3D case 0x73b:                           O
 *                                        .
 *  b0:                                 .
 *  b1:                               .
 *  b2: t->sw[i  ][j+1][k  ]        .
 *  b3:                           O                   O
 *  b4:                           .         O
 *  b5:                           .
 *  b6: t->sw[i  ][j+1][k+1]      .
 *  b7: t->sw[i+1][j+1][k+1]      .
 *                                .         O
 *                                O                   O
 *
 *
 *
 *
 *                                          @
 */
static
bool handle_case_0x73b(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);
        int jp2 = canonicalize(j + 2, t->y_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (safe_y_perpendicular(t, i, jp1, kp1) &&
            install_tswitch(t, i, j, kp1,
                            tfind_3d_perpendicular(t->sw[i][jp1][k],
                                                   t->sw[i][jp1][kp1],
                                                   t->sw[ip1][jp1][kp1],
                                                   t->sw[i][jp2][kp1]))) {
                return true;
        }
        log_no_perp(t, 0x73b, i, j, k, i, jp1, kp1);
        return false;
}

/*
 * 3D case 0x74f:                           O
 *                                            .
 *  b0:                                         .
 *  b1:                                           .
 *  b2:                                             .
 *  b3:                           O                   O
 *  b4: t->sw[i  ][j  ][k+1]                O       .
 *  b5: t->sw[i+1][j  ][k+1]                      .
 *  b6:                                         .
 *  b7: t->sw[i+1][j+1][k+1]                  .
 *                                          O
 *                                O                   O
 *
 *
 *
 *
 *                                          @
 */
static
bool handle_case_0x74f(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);
        int kp2 = canonicalize(k + 2, t->z_sz);

        if (safe_z_perpendicular(t, ip1, j, kp1) &&
            install_tswitch(t, ip1, j, k,
                            tfind_3d_perpendicular(t->sw[i][j][kp1],
                                                   t->sw[ip1][j][kp1],
                                                   t->sw[ip1][jp1][kp1],
                                                   t->sw[ip1][j][kp2]))) {
                return true;
        }
        log_no_perp(t, 0x74f, i, j, k, ip1, j, kp1);
        return false;
}

/*
 * 3D case 0x757:                           O
 *                                          . .
 *  b0:                                     .   .
 *  b1:                                     .     .
 *  b2:                                     .       .
 *  b3: t->sw[i+1][j+1][k  ]      O         .         O
 *  b4:                                     O
 *  b5: t->sw[i+1][j  ][k+1]
 *  b6:
 *  b7: t->sw[i+1][j+1][k+1]
 *                                          O
 *                                O                   O
 *
 *
 *
 *
 *                                          @
 */
static
bool handle_case_0x757(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int ip2 = canonicalize(i + 2, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (safe_x_perpendicular(t, ip1, jp1, kp1) &&
            install_tswitch(t, i, jp1, kp1,
                            tfind_3d_perpendicular(t->sw[ip1][j][kp1],
                                                   t->sw[ip1][jp1][kp1],
                                                   t->sw[ip1][jp1][k],
                                                   t->sw[ip2][jp1][kp1]))) {
                return true;
        }
        log_no_perp(t, 0x757, i, j, k, ip1, jp1, kp1);
        return false;
}

/*
 * 3D case 0x75d:                           O
 *                                            .
 *  b0:                                         .
 *  b1: t->sw[i+1][j  ][k  ]                      .
 *  b2:                                             .
 *  b3:                           O                   O
 *  b4:                                     O         .
 *  b5: t->sw[i+1][j  ][k+1]                          .
 *  b6:                                               .
 *  b7: t->sw[i+1][j+1][k+1]                          .
 *                                          O         .
 *                                O                   O
 *
 *
 *
 *
 *                                          @
 */
static
bool handle_case_0x75d(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int ip2 = canonicalize(i + 2, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (safe_x_perpendicular(t, ip1, j, kp1) &&
            install_tswitch(t, i, j, kp1,
                            tfind_3d_perpendicular(t->sw[ip1][j][k],
                                                   t->sw[ip1][j][kp1],
                                                   t->sw[ip1][jp1][kp1],
                                                   t->sw[ip2][j][kp1]))) {
                return true;
        }
        log_no_perp(t, 0x75d, i, j, k, ip1, j, kp1);
        return false;
}

/*
 * 3D case 0x773:                           O
 *                                          .
 *  b0:                                     .
 *  b1:                                     .
 *  b2: t->sw[i  ][j+1][k  ]                .
 *  b3: t->sw[i+1][j+1][k  ]      O         .         O
 *  b4:                                     O
 *  b5:                                   .
 *  b6:                                 .
 *  b7: t->sw[i+1][j+1][k+1]          .
 *                                  .       O
 *                                O                   O
 *
 *
 *
 *
 *                                          @
 */
static
bool handle_case_0x773(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);
        int jp2 = canonicalize(j + 2, t->y_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (safe_y_perpendicular(t, ip1, jp1, k) &&
            install_tswitch(t, ip1, j, k,
                            tfind_3d_perpendicular(t->sw[i][jp1][k],
                                                   t->sw[ip1][jp1][k],
                                                   t->sw[ip1][jp1][kp1],
                                                   t->sw[ip1][jp2][k]))) {
                return true;
        }
        log_no_perp(t, 0x773, i, j, k, ip1, jp1, k);
        return false;
}

/*
 * 3D case 0x775:                           O
 *                                          .
 *  b0:                                     .
 *  b1: t->sw[i+1][j  ][k  ]                .
 *  b2:                                     .
 *  b3: t->sw[i+1][j+1][k  ]      O         .         O
 *  b4:                                     O
 *  b5:                                       .
 *  b6:                                         .
 *  b7: t->sw[i+1][j+1][k+1]                      .
 *                                          O       .
 *                                O                   O
 *
 *
 *
 *
 *                                          @
 */
static
bool handle_case_0x775(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int ip2 = canonicalize(i + 2, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (safe_x_perpendicular(t, ip1, jp1, k) &&
            install_tswitch(t, i, jp1, k,
                            tfind_3d_perpendicular(t->sw[ip1][j][k],
                                                   t->sw[ip1][jp1][k],
                                                   t->sw[ip1][jp1][kp1],
                                                   t->sw[ip2][jp1][k]))) {
                return true;
        }
        log_no_perp(t, 0x775, i, j, k, ip1, jp1, k);
        return false;
}

/*
 * 3D case 0x78f:                           O
 *
 *  b0:
 *  b1:
 *  b2:
 *  b3:                           O                   O
 *  b4: t->sw[i  ][j  ][k+1]        .       O       .
 *  b5: t->sw[i+1][j  ][k+1]          .           .
 *  b6: t->sw[i  ][j+1][k+1]            .       .
 *  b7:                                   .   .
 *                                          O
 *                                O                   O
 *
 *
 *
 *
 *                                          @
 */
static
bool handle_case_0x78f(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);
        int kp2 = canonicalize(k + 2, t->z_sz);

        if (safe_z_perpendicular(t, i, j, kp1) &&
            install_tswitch(t, i, j, k,
                            tfind_3d_perpendicular(t->sw[ip1][j][kp1],
                                                   t->sw[i][j][kp1],
                                                   t->sw[i][jp1][kp1],
                                                   t->sw[i][j][kp2]))) {
                return true;
        }
        log_no_perp(t, 0x78f, i, j, k, i, j, kp1);
        return false;
}

/*
 * 3D case 0x7ab:                           O
 *
 *  b0:
 *  b1:
 *  b2: t->sw[i  ][j+1][k  ]
 *  b3:                           O                   O
 *  b4: t->sw[i  ][j  ][k+1]      . .       O
 *  b5:                           .   .
 *  b6: t->sw[i  ][j+1][k+1]      .     .
 *  b7:                           .       .
 *                                .         O
 *                                O                   O
 *
 *
 *
 *
 *                                          @
 */
static
bool handle_case_0x7ab(struct torus *t, int i, int j, int k)
{
        int im1 = canonicalize(i - 1, t->x_sz);
        int ip1 = canonicalize(i + 1, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (safe_x_perpendicular(t, i, jp1, kp1) &&
            install_tswitch(t, ip1, jp1, kp1,
                            tfind_3d_perpendicular(t->sw[i][j][kp1],
                                                   t->sw[i][jp1][kp1],
                                                   t->sw[i][jp1][k],
                                                   t->sw[im1][jp1][kp1]))) {
                return true;
        }
        log_no_perp(t, 0x7ab, i, j, k, i, jp1, kp1);
        return false;
}

/*
 * 3D case 0x7ae:                           O
 *
 *  b0: t->sw[i  ][j  ][k  ]
 *  b1:
 *  b2:
 *  b3:                           O                   O
 *  b4: t->sw[i  ][j  ][k+1]        .       O
 *  b5:                               .
 *  b6: t->sw[i  ][j+1][k+1]            .
 *  b7:                                   .
 *                                          O
 *                                O         .         O
 *                                          .
 *                                          .
 *                                          .
 *                                          .
 *                                          @
 */
static
bool handle_case_0x7ae(struct torus *t, int i, int j, int k)
{
        int im1 = canonicalize(i - 1, t->x_sz);
        int ip1 = canonicalize(i + 1, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (safe_x_perpendicular(t, i, j, kp1) &&
            install_tswitch(t, ip1, j, kp1,
                            tfind_3d_perpendicular(t->sw[i][j][k],
                                                   t->sw[i][j][kp1],
                                                   t->sw[i][jp1][kp1],
                                                   t->sw[im1][j][kp1]))) {
                return true;
        }
        log_no_perp(t, 0x7ae, i, j, k, i, j, kp1);
        return false;
}

/*
 * 3D case 0x7b3:                           O
 *
 *  b0:
 *  b1:
 *  b2: t->sw[i  ][j+1][k  ]
 *  b3: t->sw[i+1][j+1][k  ]      O                   O
 *  b4:                           .         O
 *  b5:                           .       .
 *  b6: t->sw[i  ][j+1][k+1]      .     .
 *  b7:                           .   .
 *                                . .       O
 *                                O                   O
 *
 *
 *
 *
 *                                          @
 */
static
bool handle_case_0x7b3(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);
        int jp2 = canonicalize(j + 2, t->y_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (safe_y_perpendicular(t, i, jp1, k) &&
            install_tswitch(t, i, j, k,
                            tfind_3d_perpendicular(t->sw[i][jp1][kp1],
                                                   t->sw[i][jp1][k],
                                                   t->sw[ip1][jp1][k],
                                                   t->sw[i][jp2][k]))) {
                return true;
        }
        log_no_perp(t, 0x7b3, i, j, k, i, jp1, k);
        return false;
}

/*
 * 3D case 0x7ba:                           O
 *
 *  b0: t->sw[i  ][j  ][k  ]
 *  b1:
 *  b2: t->sw[i  ][j+1][k  ]
 *  b3:                           O                   O
 *  b4:                           .         O
 *  b5:                           .
 *  b6: t->sw[i  ][j+1][k+1]      .
 *  b7:                           .
 *                                .         O
 *                                O                   O
 *                                  .
 *                                    .
 *                                      .
 *                                        .
 *                                          @
 */
static
bool handle_case_0x7ba(struct torus *t, int i, int j, int k)
{
        int im1 = canonicalize(i - 1, t->x_sz);
        int ip1 = canonicalize(i + 1, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (safe_x_perpendicular(t, i, jp1, k) &&
            install_tswitch(t, ip1, jp1, k,
                            tfind_3d_perpendicular(t->sw[i][j][k],
                                                   t->sw[i][jp1][k],
                                                   t->sw[i][jp1][kp1],
                                                   t->sw[im1][jp1][k]))) {
                return true;
        }
        log_no_perp(t, 0x7ba, i, j, k, i, jp1, k);
        return false;
}

/*
 * 3D case 0x7cd:                           O
 *
 *  b0:
 *  b1: t->sw[i+1][j  ][k  ]
 *  b2:
 *  b3:                           O                   O
 *  b4: t->sw[i  ][j  ][k+1]                O       . .
 *  b5: t->sw[i+1][j  ][k+1]                      .   .
 *  b6:                                         .     .
 *  b7:                                       .       .
 *                                          O         .
 *                                O                   O
 *
 *
 *
 *
 *                                          @
 */
static
bool handle_case_0x7cd(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);
        int jm1 = canonicalize(j - 1, t->y_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (safe_y_perpendicular(t, ip1, j, kp1) &&
            install_tswitch(t, ip1, jp1, kp1,
                            tfind_3d_perpendicular(t->sw[i][j][kp1],
                                                   t->sw[ip1][j][kp1],
                                                   t->sw[ip1][j][k],
                                                   t->sw[ip1][jm1][kp1]))) {
                return true;
        }
        log_no_perp(t, 0x7cd, i, j, k, ip1, j, kp1);
        return false;
}

/*
 * 3D case 0x7ce:                           O
 *
 *  b0: t->sw[i  ][j  ][k  ]
 *  b1:
 *  b2:
 *  b3:                           O                   O
 *  b4: t->sw[i  ][j  ][k+1]                O       .
 *  b5: t->sw[i+1][j  ][k+1]                      .
 *  b6:                                         .
 *  b7:                                       .
 *                                          O
 *                                O         .         O
 *                                          .
 *                                          .
 *                                          .
 *                                          .
 *                                          @
 */
static
bool handle_case_0x7ce(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);
        int jm1 = canonicalize(j - 1, t->y_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (safe_y_perpendicular(t, i, j, kp1) &&
            install_tswitch(t, i, jp1, kp1,
                            tfind_3d_perpendicular(t->sw[i][j][k],
                                                   t->sw[i][j][kp1],
                                                   t->sw[ip1][j][kp1],
                                                   t->sw[i][jm1][kp1]))) {
                return true;
        }
        log_no_perp(t, 0x7ce, i, j, k, i, j, kp1);
        return false;
}

/*
 * 3D case 0x7d5:                           O
 *
 *  b0:
 *  b1: t->sw[i+1][j  ][k  ]
 *  b2:
 *  b3: t->sw[i+1][j+1][k  ]      O                   O
 *  b4:                                     O         .
 *  b5: t->sw[i+1][j  ][k+1]                  .       .
 *  b6:                                         .     .
 *  b7:                                           .   .
 *                                          O       . .
 *                                O                   O
 *
 *
 *
 *
 *                                          @
 */
static
bool handle_case_0x7d5(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int ip2 = canonicalize(i + 2, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (safe_x_perpendicular(t, ip1, j, k) &&
            install_tswitch(t, i, j, k,
                            tfind_3d_perpendicular(t->sw[ip1][j][kp1],
                                                   t->sw[ip1][j][k],
                                                   t->sw[ip1][jp1][k],
                                                   t->sw[ip2][j][k]))) {
                return true;
        }
        log_no_perp(t, 0x7d5, i, j, k, ip1, j, k);
        return false;
}

/*
 * 3D case 0x7dc:                           O
 *
 *  b0: t->sw[i  ][j  ][k  ]
 *  b1: t->sw[i+1][j  ][k  ]
 *  b2:
 *  b3:                           O                   O
 *  b4:                                     O         .
 *  b5: t->sw[i+1][j  ][k+1]                          .
 *  b6:                                               .
 *  b7:                                               .
 *                                          O         .
 *                                O                   O
 *                                                  .
 *                                                .
 *                                              .
 *                                            .
 *                                          @
 */
static
bool handle_case_0x7dc(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);
        int jm1 = canonicalize(j - 1, t->y_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (safe_y_perpendicular(t, ip1, j, k) &&
            install_tswitch(t, ip1, jp1, k,
                            tfind_3d_perpendicular(t->sw[i][j][k],
                                                   t->sw[ip1][j][k],
                                                   t->sw[ip1][j][kp1],
                                                   t->sw[ip1][jm1][k]))) {
                return true;
        }
        log_no_perp(t, 0x7dc, i, j, k, ip1, j, k);
        return false;
}

/*
 * 3D case 0x7ea:                           O
 *
 *  b0: t->sw[i  ][j  ][k  ]
 *  b1:
 *  b2: t->sw[i  ][j+1][k  ]
 *  b3:                            O                   O
 *  b4: t->sw[i  ][j  ][k+1]                 O
 *  b5:
 *  b6:
 *  b7:
 *                                          O
 *                                O         .         O
 *                                  .       .
 *                                    .     .
 *                                      .   .
 *                                        . .
 *                                          @
 */
static
bool handle_case_0x7ea(struct torus *t, int i, int j, int k)
{
        int im1 = canonicalize(i - 1, t->x_sz);
        int ip1 = canonicalize(i + 1, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (safe_x_perpendicular(t, i, j, k) &&
            install_tswitch(t, ip1, j, k,
                            tfind_3d_perpendicular(t->sw[i][j][kp1],
                                                   t->sw[i][j][k],
                                                   t->sw[i][jp1][k],
                                                   t->sw[im1][j][k]))) {
                return true;
        }
        log_no_perp(t, 0x7ea, i, j, k, i, j, k);
        return false;
}

/*
 * 3D case 0x7ec:                           O
 *
 *  b0: t->sw[i  ][j  ][k  ]
 *  b1: t->sw[i+1][j  ][k  ]
 *  b2:
 *  b3:                           O                   O
 *  b4: t->sw[i  ][j  ][k+1]                O
 *  b5:
 *  b6:
 *  b7:
 *                                          O
 *                                O         .         O
 *                                          .       .
 *                                          .     .
 *                                          .   .
 *                                          . .
 *                                          @
 */
static
bool handle_case_0x7ec(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);
        int jm1 = canonicalize(j - 1, t->y_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (safe_y_perpendicular(t, i, j, k) &&
            install_tswitch(t, i, jp1, k,
                            tfind_3d_perpendicular(t->sw[i][j][kp1],
                                                   t->sw[i][j][k],
                                                   t->sw[ip1][j][k],
                                                   t->sw[i][jm1][k]))) {
                return true;
        }
        log_no_perp(t, 0x7ec, i, j, k, i, j, k);
        return false;
}

/*
 * 3D case 0x7f1:                           O
 *
 *  b0:
 *  b1: t->sw[i+1][j  ][k  ]
 *  b2: t->sw[i  ][j+1][k  ]
 *  b3: t->sw[i+1][j+1][k  ]      O                   O
 *  b4:                                     O
 *  b5:                                   .   .
 *  b6:                                 .       .
 *  b7:                               .           .
 *                                  .       O       .
 *                                O                   O
 *
 *
 *
 *
 *                                          @
 */
static
bool handle_case_0x7f1(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);
        int km1 = canonicalize(k - 1, t->z_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (safe_z_perpendicular(t, ip1, jp1, k) &&
            install_tswitch(t, ip1, jp1, kp1,
                            tfind_3d_perpendicular(t->sw[ip1][j][k],
                                                   t->sw[ip1][jp1][k],
                                                   t->sw[i][jp1][k],
                                                   t->sw[ip1][jp1][km1]))) {
                return true;
        }
        log_no_perp(t, 0x7f1, i, j, k, ip1, jp1, k);
        return false;
}

/*
 * 3D case 0x7f2:                           O
 *
 *  b0: t->sw[i  ][j  ][k  ]
 *  b1:
 *  b2: t->sw[i  ][j+1][k  ]
 *  b3: t->sw[i+1][j+1][k  ]      O                   O
 *  b4:                                     O
 *  b5:                                   .
 *  b6:                                 .
 *  b7:                               .
 *                                  .       O
 *                                O                   O
 *                                  .
 *                                    .
 *                                      .
 *                                        .
 *                                          @
 */
static
bool handle_case_0x7f2(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);
        int km1 = canonicalize(k - 1, t->z_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (safe_z_perpendicular(t, i, jp1, k) &&
            install_tswitch(t, i, jp1, kp1,
                            tfind_3d_perpendicular(t->sw[i][j][k],
                                                   t->sw[i][jp1][k],
                                                   t->sw[ip1][jp1][k],
                                                   t->sw[i][jp1][km1]))) {
                return true;
        }
        log_no_perp(t, 0x7f2, i, j, k, i, jp1, k);
        return false;
}

/*
 * 3D case 0x7f4:                           O
 *
 *  b0: t->sw[i  ][j  ][k  ]
 *  b1: t->sw[i+1][j  ][k  ]
 *  b2:
 *  b3: t->sw[i+1][j+1][k  ]      O                   O
 *  b4:                                     O
 *  b5:                                       .
 *  b6:                                         .
 *  b7:                                           .
 *                                          O       .
 *                                O                   O
 *                                                  .
 *                                                .
 *                                              .
 *                                            .
 *                                          @
 */
static
bool handle_case_0x7f4(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);
        int km1 = canonicalize(k - 1, t->z_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (safe_z_perpendicular(t, ip1, j, k) &&
            install_tswitch(t, ip1, j, kp1,
                            tfind_3d_perpendicular(t->sw[i][j][k],
                                                   t->sw[ip1][j][k],
                                                   t->sw[ip1][jp1][k],
                                                   t->sw[ip1][j][km1]))) {
                return true;
        }
        log_no_perp(t, 0x7f4, i, j, k, ip1, j, k);
        return false;
}

/*
 * 3D case 0x7f8:                           O
 *
 *  b0: t->sw[i  ][j  ][k  ]
 *  b1: t->sw[i+1][j  ][k  ]
 *  b2: t->sw[i  ][j+1][k  ]
 *  b3:                           O                   O
 *  b4:                                     O
 *  b5:
 *  b6:
 *  b7:
 *                                          O
 *                                O                   O
 *                                  .               .
 *                                    .           .
 *                                      .       .
 *                                        .   .
 *                                          @
 */
static
bool handle_case_0x7f8(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);
        int km1 = canonicalize(k - 1, t->z_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (safe_z_perpendicular(t, i, j, k) &&
            install_tswitch(t, i, j, kp1,
                            tfind_3d_perpendicular(t->sw[ip1][j][k],
                                                   t->sw[i][j][k],
                                                   t->sw[i][jp1][k],
                                                   t->sw[i][j][km1]))) {
                return true;
        }
        log_no_perp(t, 0x7f8, i, j, k, i, j, k);
        return false;
}

/*
 * Handle the cases where three existing edges meet at a corner.
 */

/*
 * 3D case 0x717:                           O
 *                                        . . .
 *  b0:                                 .   .   .
 *  b1:                               .     .     .
 *  b2:                             .       .       .
 *  b3: t->sw[i+1][j+1][k  ]      O         .         O
 *  b4:                                     O
 *  b5: t->sw[i+1][j  ][k+1]
 *  b6: t->sw[i  ][j+1][k+1]
 *  b7: t->sw[i+1][j+1][k+1]
 *                                          O
 *                                O                   O
 *
 *
 *
 *
 *                                          @
 */
static
bool handle_case_0x717(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (install_tswitch(t, i, j, kp1,
                            tfind_face_corner(t->sw[i][jp1][kp1],
                                              t->sw[ip1][jp1][kp1],
                                              t->sw[ip1][j][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x717, i, j, k, i, j, kp1);

        if (install_tswitch(t, ip1, j, k,
                            tfind_face_corner(t->sw[ip1][jp1][k],
                                              t->sw[ip1][jp1][kp1],
                                              t->sw[ip1][j][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x717, i, j, k, ip1, j, k);

        if (install_tswitch(t, i, jp1, k,
                            tfind_face_corner(t->sw[ip1][jp1][k],
                                              t->sw[ip1][jp1][kp1],
                                              t->sw[i][jp1][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x717, i, j, k, i, jp1, k);
        return false;
}

/*
 * 3D case 0x72b:                           O
 *                                        .
 *  b0:                                 .
 *  b1:                               .
 *  b2: t->sw[i  ][j+1][k  ]        .
 *  b3:                           O                   O
 *  b4: t->sw[i  ][j  ][k+1]      . .       O
 *  b5:                           .   .
 *  b6: t->sw[i  ][j+1][k+1]      .     .
 *  b7: t->sw[i+1][j+1][k+1]      .       .
 *                                .         O
 *                                O                   O
 *
 *
 *
 *
 *                                          @
 */
static
bool handle_case_0x72b(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (install_tswitch(t, ip1, j, kp1,
                            tfind_face_corner(t->sw[i][j][kp1],
                                              t->sw[i][jp1][kp1],
                                              t->sw[ip1][jp1][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x72b, i, j, k, ip1, j, kp1);

        if (install_tswitch(t, i, j, k,
                            tfind_face_corner(t->sw[i][jp1][k],
                                              t->sw[i][jp1][kp1],
                                              t->sw[i][j][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x72b, i, j, k, i, j, k);

        if (install_tswitch(t, ip1, jp1, k,
                            tfind_face_corner(t->sw[i][jp1][k],
                                              t->sw[i][jp1][kp1],
                                              t->sw[ip1][jp1][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x72b, i, j, k, ip1, jp1, k);
        return false;
}

/*
 * 3D case 0x74d:                           O
 *                                            .
 *  b0:                                         .
 *  b1: t->sw[i+1][j  ][k  ]                      .
 *  b2:                                             .
 *  b3:                           O                   O
 *  b4: t->sw[i  ][j  ][k+1]                O       . .
 *  b5: t->sw[i+1][j  ][k+1]                      .   .
 *  b6:                                         .     .
 *  b7: t->sw[i+1][j+1][k+1]                  .       .
 *                                          O         .
 *                                O                   O
 *
 *
 *
 *
 *                                          @
 */
static
bool handle_case_0x74d(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (install_tswitch(t, i, jp1, kp1,
                            tfind_face_corner(t->sw[i][j][kp1],
                                              t->sw[ip1][j][kp1],
                                              t->sw[ip1][jp1][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x74d, i, j, k, i, jp1, kp1);

        if (install_tswitch(t, i, j, k,
                            tfind_face_corner(t->sw[ip1][j][k],
                                              t->sw[ip1][j][kp1],
                                              t->sw[i][j][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x74d, i, j, k, i, j, k);

        if (install_tswitch(t, ip1, jp1, k,
                            tfind_face_corner(t->sw[ip1][j][k],
                                              t->sw[ip1][j][kp1],
                                              t->sw[ip1][jp1][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x74d, i, j, k, ip1, jp1, k);
        return false;
}

/*
 * 3D case 0x771:                           O
 *                                          .
 *  b0:                                     .
 *  b1: t->sw[i+1][j  ][k  ]                .
 *  b2: t->sw[i  ][j+1][k  ]                .
 *  b3: t->sw[i+1][j+1][k  ]      O         .         O
 *  b4:                                     O
 *  b5:                                   .   .
 *  b6:                                 .       .
 *  b7: t->sw[i+1][j+1][k+1]          .           .
 *                                  .       O       .
 *                                O                   O
 *
 *
 *
 *
 *                                          @
 */
static
bool handle_case_0x771(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (install_tswitch(t, i, j, k,
                            tfind_face_corner(t->sw[i][jp1][k],
                                              t->sw[ip1][jp1][k],
                                              t->sw[ip1][j][k]))) {
                return true;
        }
        log_no_crnr(t, 0x771, i, j, k, i, j, k);

        if (install_tswitch(t, ip1, j, kp1,
                            tfind_face_corner(t->sw[ip1][jp1][kp1],
                                              t->sw[ip1][jp1][k],
                                              t->sw[ip1][j][k]))) {
                return true;
        }
        log_no_crnr(t, 0x771, i, j, k, ip1, j, kp1);

        if (install_tswitch(t, i, jp1, kp1,
                            tfind_face_corner(t->sw[ip1][jp1][kp1],
                                              t->sw[ip1][jp1][k],
                                              t->sw[i][jp1][k]))) {
                return true;
        }
        log_no_crnr(t, 0x771, i, j, k, i, jp1, kp1);
        return false;
}

/*
 * 3D case 0x78e:                           O
 *
 *  b0: t->sw[i  ][j  ][k  ]
 *  b1:
 *  b2:
 *  b3:                           O                   O
 *  b4: t->sw[i  ][j  ][k+1]        .       O       .
 *  b5: t->sw[i+1][j  ][k+1]          .           .
 *  b6: t->sw[i  ][j+1][k+1]            .       .
 *  b7:                                   .   .
 *                                          O
 *                                O         .         O
 *                                          .
 *                                          .
 *                                          .
 *                                          .
 *                                          @
 */
static
bool handle_case_0x78e(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (install_tswitch(t, ip1, jp1, kp1,
                            tfind_face_corner(t->sw[ip1][j][kp1],
                                              t->sw[i][j][kp1],
                                              t->sw[i][jp1][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x78e, i, j, k, ip1, jp1, kp1);

        if (install_tswitch(t, ip1, j, k,
                            tfind_face_corner(t->sw[i][j][k],
                                              t->sw[i][j][kp1],
                                              t->sw[ip1][j][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x78e, i, j, k, ip1, j, k);

        if (install_tswitch(t, i, jp1, k,
                            tfind_face_corner(t->sw[i][j][k],
                                              t->sw[i][j][kp1],
                                              t->sw[i][jp1][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x78e, i, j, k, i, jp1, k);
        return false;
}

/*
 * 3D case 0x7b2:                           O
 *
 *  b0: t->sw[i  ][j  ][k  ]
 *  b1:
 *  b2: t->sw[i  ][j+1][k  ]
 *  b3: t->sw[i+1][j+1][k  ]      O                   O
 *  b4:                           .         O
 *  b5:                           .       .
 *  b6: t->sw[i  ][j+1][k+1]      .     .
 *  b7:                           .   .
 *                                . .       O
 *                                O                   O
 *                                  .
 *                                    .
 *                                      .
 *                                        .
 *                                          @
 */
static
bool handle_case_0x7b2(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (install_tswitch(t, ip1, j, k,
                            tfind_face_corner(t->sw[i][j][k],
                                              t->sw[i][jp1][k],
                                              t->sw[ip1][jp1][k]))) {
                return true;
        }
        log_no_crnr(t, 0x7b2, i, j, k, ip1, j, k);

        if (install_tswitch(t, ip1, jp1, kp1,
                            tfind_face_corner(t->sw[i][jp1][kp1],
                                              t->sw[i][jp1][k],
                                              t->sw[ip1][jp1][k]))) {
                return true;
        }
        log_no_crnr(t, 0x7b2, i, j, k, ip1, jp1, kp1);

        if (install_tswitch(t, i, j, kp1,
                            tfind_face_corner(t->sw[i][jp1][kp1],
                                              t->sw[i][jp1][k],
                                              t->sw[i][j][k]))) {
                return true;
        }
        log_no_crnr(t, 0x7b2, i, j, k, i, j, kp1);
        return false;
}

/*
 * 3D case 0x7d4:                           O
 *
 *  b0: t->sw[i  ][j  ][k  ]
 *  b1: t->sw[i+1][j  ][k  ]
 *  b2:
 *  b3: t->sw[i+1][j+1][k  ]      O                   O
 *  b4:                                     O         .
 *  b5: t->sw[i+1][j  ][k+1]                  .       .
 *  b6:                                         .     .
 *  b7:                                           .   .
 *                                          O       . .
 *                                O                   O
 *                                                  .
 *                                                .
 *                                              .
 *                                            .
 *                                          @
 */
static
bool handle_case_0x7d4(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (install_tswitch(t, i, jp1, k,
                            tfind_face_corner(t->sw[i][j][k],
                                              t->sw[ip1][j][k],
                                              t->sw[ip1][jp1][k]))) {
                return true;
        }
        log_no_crnr(t, 0x7d4, i, j, k, i, jp1, k);

        if (install_tswitch(t, i, j, kp1,
                            tfind_face_corner(t->sw[ip1][j][kp1],
                                              t->sw[ip1][j][k],
                                              t->sw[i][j][k]))) {
                return true;
        }
        log_no_crnr(t, 0x7d4, i, j, k, i, j, kp1);

        if (install_tswitch(t, ip1, jp1, kp1,
                            tfind_face_corner(t->sw[ip1][j][kp1],
                                              t->sw[ip1][j][k],
                                              t->sw[ip1][jp1][k]))) {
                return true;
        }
        log_no_crnr(t, 0x7d4, i, j, k, ip1, jp1, kp1);
        return false;
}

/*
 * 3D case 0x7e8:                           O
 *
 *  b0: t->sw[i  ][j  ][k  ]
 *  b1: t->sw[i+1][j  ][k  ]
 *  b2: t->sw[i  ][j+1][k  ]
 *  b3:                           O                   O
 *  b4: t->sw[i  ][j  ][k+1]                O
 *  b5:
 *  b6:
 *  b7:
 *                                          O
 *                                O         .         O
 *                                  .       .       .
 *                                    .     .     .
 *                                      .   .   .
 *                                        . . .
 *                                          @
 */
static
bool handle_case_0x7e8(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (install_tswitch(t, ip1, jp1, k,
                            tfind_face_corner(t->sw[ip1][j][k],
                                              t->sw[i][j][k],
                                              t->sw[i][jp1][k]))) {
                return true;
        }
        log_no_crnr(t, 0x7e8, i, j, k, ip1, jp1, k);

        if (install_tswitch(t, ip1, j, kp1,
                            tfind_face_corner(t->sw[ip1][j][k],
                                              t->sw[i][j][k],
                                              t->sw[i][j][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x7e8, i, j, k, ip1, j, kp1);

        if (install_tswitch(t, i, jp1, kp1,
                            tfind_face_corner(t->sw[i][jp1][k],
                                              t->sw[i][j][k],
                                              t->sw[i][j][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x7e8, i, j, k, i, jp1, kp1);
        return false;
}

/*
 * Handle the cases where four corners on a single face are missing.
 */

/*
 * 3D case 0x70f:                           O
 *                                        .   .
 *  b0:                                 .       .
 *  b1:                               .           .
 *  b2:                             .               .
 *  b3:                           O                   O
 *  b4: t->sw[i  ][j  ][k+1]        .       O       .
 *  b5: t->sw[i+1][j  ][k+1]          .           .
 *  b6: t->sw[i  ][j+1][k+1]            .       .
 *  b7: t->sw[i+1][j+1][k+1]              .   .
 *                                          O
 *                                O                   O
 *
 *
 *
 *
 *                                          @
 */
static
bool handle_case_0x70f(struct torus *t, int i, int j, int k)
{
        if (handle_case_0x71f(t, i, j, k))
                return true;

        if (handle_case_0x72f(t, i, j, k))
                return true;

        if (handle_case_0x74f(t, i, j, k))
                return true;

        return handle_case_0x78f(t, i, j, k);
}

/*
 * 3D case 0x733:                           O
 *                                        . .
 *  b0:                                 .   .
 *  b1:                               .     .
 *  b2: t->sw[i  ][j+1][k  ]        .       .
 *  b3: t->sw[i+1][j+1][k  ]      O         .         O
 *  b4:                           .         O
 *  b5:                           .       .
 *  b6: t->sw[i  ][j+1][k+1]      .     .
 *  b7: t->sw[i+1][j+1][k+1]      .   .
 *                                . .       O
 *                                O                   O
 *
 *
 *
 *
 *                                          @
 */
static
bool handle_case_0x733(struct torus *t, int i, int j, int k)
{
        if (handle_case_0x737(t, i, j, k))
                return true;

        if (handle_case_0x73b(t, i, j, k))
                return true;

        if (handle_case_0x773(t, i, j, k))
                return true;

        return handle_case_0x7b3(t, i, j, k);
}

/*
 * 3D case 0x755:                           O
 *                                          . .
 *  b0:                                     .   .
 *  b1: t->sw[i+1][j  ][k  ]                .     .
 *  b2:                                     .       .
 *  b3: t->sw[i+1][j+1][k  ]      O         .         O
 *  b4:                                     O         .
 *  b5: t->sw[i+1][j  ][k+1]                  .       .
 *  b6:                                         .     .
 *  b7: t->sw[i+1][j+1][k+1]                      .   .
 *                                          O       . .
 *                                O                   O
 *
 *
 *
 *
 *                                          @
 */
static
bool handle_case_0x755(struct torus *t, int i, int j, int k)
{
        if (handle_case_0x757(t, i, j, k))
                return true;

        if (handle_case_0x75d(t, i, j, k))
                return true;

        if (handle_case_0x775(t, i, j, k))
                return true;

        return handle_case_0x7d5(t, i, j, k);
}

/*
 * 3D case 0x7aa:                           O
 *
 *  b0: t->sw[i  ][j  ][k  ]
 *  b1:
 *  b2: t->sw[i  ][j+1][k  ]
 *  b3:                           O                   O
 *  b4: t->sw[i  ][j  ][k+1]      . .       O
 *  b5:                           .   .
 *  b6: t->sw[i  ][j+1][k+1]      .     .
 *  b7:                           .       .
 *                                .         O
 *                                O         .         O
 *                                  .       .
 *                                    .     .
 *                                      .   .
 *                                        . .
 *                                          @
 */
static
bool handle_case_0x7aa(struct torus *t, int i, int j, int k)
{
        if (handle_case_0x7ab(t, i, j, k))
                return true;

        if (handle_case_0x7ae(t, i, j, k))
                return true;

        if (handle_case_0x7ba(t, i, j, k))
                return true;

        return handle_case_0x7ea(t, i, j, k);
}

/*
 * 3D case 0x7cc:                           O
 *
 *  b0: t->sw[i  ][j  ][k  ]
 *  b1: t->sw[i+1][j  ][k  ]
 *  b2:
 *  b3:                           O                   O
 *  b4: t->sw[i  ][j  ][k+1]                O       . .
 *  b5: t->sw[i+1][j  ][k+1]                      .   .
 *  b6:                                         .     .
 *  b7:                                       .       .
 *                                          O         .
 *                                O         .         O
 *                                          .       .
 *                                          .     .
 *                                          .   .
 *                                          . .
 *                                          @
 */
static
bool handle_case_0x7cc(struct torus *t, int i, int j, int k)
{
        if (handle_case_0x7cd(t, i, j, k))
                return true;

        if (handle_case_0x7ce(t, i, j, k))
                return true;

        if (handle_case_0x7dc(t, i, j, k))
                return true;

        return handle_case_0x7ec(t, i, j, k);
}

/*
 * 3D case 0x7f0:                           O
 *
 *  b0: t->sw[i  ][j  ][k  ]
 *  b1: t->sw[i+1][j  ][k  ]
 *  b2: t->sw[i  ][j+1][k  ]
 *  b3: t->sw[i+1][j+1][k  ]      O                   O
 *  b4:                                     O
 *  b5:                                   .   .
 *  b6:                                 .       .
 *  b7:                               .           .
 *                                  .       O       .
 *                                O                   O
 *                                  .               .
 *                                    .           .
 *                                      .       .
 *                                        .   .
 *                                          @
 */
static
bool handle_case_0x7f0(struct torus *t, int i, int j, int k)
{
        if (handle_case_0x7f1(t, i, j, k))
                return true;

        if (handle_case_0x7f2(t, i, j, k))
                return true;

        if (handle_case_0x7f4(t, i, j, k))
                return true;

        return handle_case_0x7f8(t, i, j, k);
}

/*
 * Handle the cases where three corners on a single face are missing.
 */


/*
 * 3D case 0x707:                           O
 *                                        . . .
 *  b0:                                 .   .   .
 *  b1:                               .     .     .
 *  b2:                             .       .       .
 *  b3: t->sw[i+1][j+1][k  ]      O         .         O
 *  b4: t->sw[i  ][j  ][k+1]        .       O       .
 *  b5: t->sw[i+1][j  ][k+1]          .           .
 *  b6: t->sw[i  ][j+1][k+1]            .       .
 *  b7: t->sw[i+1][j+1][k+1]              .   .
 *                                          O
 *                                O                   O
 *
 *
 *
 *
 *                                          @
 */
static
bool handle_case_0x707(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (install_tswitch(t, ip1, j, k,
                            tfind_face_corner(t->sw[ip1][jp1][k],
                                              t->sw[ip1][jp1][kp1],
                                              t->sw[ip1][j][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x707, i, j, k, ip1, j, k);

        if (install_tswitch(t, i, jp1, k,
                            tfind_face_corner(t->sw[ip1][jp1][k],
                                              t->sw[ip1][jp1][kp1],
                                              t->sw[i][jp1][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x707, i, j, k, i, jp1, k);
        return false;
}

/*
 * 3D case 0x70b:                           O
 *                                        .   .
 *  b0:                                 .       .
 *  b1:                               .           .
 *  b2: t->sw[i  ][j+1][k  ]        .               .
 *  b3:                           O                   O
 *  b4: t->sw[i  ][j  ][k+1]      . .       O       .
 *  b5: t->sw[i+1][j  ][k+1]      .   .           .
 *  b6: t->sw[i  ][j+1][k+1]      .     .       .
 *  b7: t->sw[i+1][j+1][k+1]      .       .   .
 *                                .         O
 *                                O                   O
 *
 *
 *
 *
 *                                          @
 */
static
bool handle_case_0x70b(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (install_tswitch(t, i, j, k,
                            tfind_face_corner(t->sw[i][jp1][k],
                                              t->sw[i][jp1][kp1],
                                              t->sw[i][j][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x70b, i, j, k, i, j, k);

        if (install_tswitch(t, ip1, jp1, k,
                            tfind_face_corner(t->sw[i][jp1][k],
                                              t->sw[i][jp1][kp1],
                                              t->sw[ip1][jp1][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x70b, i, j, k, ip1, jp1, k);
        return false;
}

/*
 * 3D case 0x70d:                           O
 *                                        .   .
 *  b0:                                 .       .
 *  b1: t->sw[i+1][j  ][k  ]          .           .
 *  b2:                             .               .
 *  b3:                           O                   O
 *  b4: t->sw[i  ][j  ][k+1]        .       O       . .
 *  b5: t->sw[i+1][j  ][k+1]          .           .   .
 *  b6: t->sw[i  ][j+1][k+1]            .       .     .
 *  b7: t->sw[i+1][j+1][k+1]              .   .       .
 *                                          O         .
 *                                O                   O
 *
 *
 *
 *
 *                                          @
 */
static
bool handle_case_0x70d(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (install_tswitch(t, i, j, k,
                            tfind_face_corner(t->sw[ip1][j][k],
                                              t->sw[ip1][j][kp1],
                                              t->sw[i][j][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x70d, i, j, k, i, j, k);

        if (install_tswitch(t, ip1, jp1, k,
                            tfind_face_corner(t->sw[ip1][j][k],
                                              t->sw[ip1][j][kp1],
                                              t->sw[ip1][jp1][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x70d, i, j, k, ip1, jp1, k);
        return false;
}

/*
 * 3D case 0x70e:                           O
 *                                        .   .
 *  b0: t->sw[i  ][j  ][k  ]            .       .
 *  b1:                               .           .
 *  b2:                             .               .
 *  b3:                           O                   O
 *  b4: t->sw[i  ][j  ][k+1]        .       O       .
 *  b5: t->sw[i+1][j  ][k+1]          .           .
 *  b6: t->sw[i  ][j+1][k+1]            .       .
 *  b7: t->sw[i+1][j+1][k+1]              .   .
 *                                          O
 *                                O         .         O
 *                                          .
 *                                          .
 *                                          .
 *                                          .
 *                                          @
 */
static
bool handle_case_0x70e(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (install_tswitch(t, ip1, j, k,
                            tfind_face_corner(t->sw[i][j][k],
                                              t->sw[i][j][kp1],
                                              t->sw[ip1][j][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x70e, i, j, k, ip1, j, k);

        if (install_tswitch(t, i, jp1, k,
                            tfind_face_corner(t->sw[i][j][k],
                                              t->sw[i][j][kp1],
                                              t->sw[i][jp1][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x70e, i, j, k, i, jp1, k);
        return false;
}

/*
 * 3D case 0x713:                           O
 *                                        . . .
 *  b0:                                 .   .   .
 *  b1:                               .     .     .
 *  b2: t->sw[i  ][j+1][k  ]        .       .       .
 *  b3: t->sw[i+1][j+1][k  ]      O         .         O
 *  b4:                           .         O
 *  b5: t->sw[i+1][j  ][k+1]      .       .
 *  b6: t->sw[i  ][j+1][k+1]      .     .
 *  b7: t->sw[i+1][j+1][k+1]      .   .
 *                                . .       O
 *                                O                   O
 *
 *
 *
 *
 *                                          @
 */
static
bool handle_case_0x713(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (install_tswitch(t, ip1, j, k,
                            tfind_face_corner(t->sw[ip1][jp1][k],
                                              t->sw[ip1][jp1][kp1],
                                              t->sw[ip1][j][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x713, i, j, k, ip1, j, k);

        if (install_tswitch(t, i, j, kp1,
                            tfind_face_corner(t->sw[ip1][j][kp1],
                                              t->sw[ip1][jp1][kp1],
                                              t->sw[i][jp1][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x713, i, j, k, i, j, kp1);
        return false;
}

/*
 * 3D case 0x715:                           O
 *                                        . . .
 *  b0:                                 .   .   .
 *  b1: t->sw[i+1][j  ][k  ]          .     .     .
 *  b2:                             .       .       .
 *  b3: t->sw[i+1][j+1][k  ]      O         .         O
 *  b4:                                     O         .
 *  b5: t->sw[i+1][j  ][k+1]                  .       .
 *  b6: t->sw[i  ][j+1][k+1]                    .     .
 *  b7: t->sw[i+1][j+1][k+1]                      .   .
 *                                          O       . .
 *                                O                   O
 *
 *
 *
 *
 *                                          @
 */
static
bool handle_case_0x715(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (install_tswitch(t, i, jp1, k,
                            tfind_face_corner(t->sw[ip1][jp1][k],
                                              t->sw[ip1][jp1][kp1],
                                              t->sw[i][jp1][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x715, i, j, k, i, jp1, k);

        if (install_tswitch(t, i, j, kp1,
                            tfind_face_corner(t->sw[ip1][j][kp1],
                                              t->sw[ip1][jp1][kp1],
                                              t->sw[i][jp1][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x715, i, j, k, i, j, kp1);
        return false;
}

/*
 * 3D case 0x723:                           O
 *                                        . .
 *  b0:                                 .   .
 *  b1:                               .     .
 *  b2: t->sw[i  ][j+1][k  ]        .       .
 *  b3: t->sw[i+1][j+1][k  ]      O         .         O
 *  b4: t->sw[i  ][j  ][k+1]      . .       O
 *  b5:                           .   .   .
 *  b6: t->sw[i  ][j+1][k+1]      .     .
 *  b7: t->sw[i+1][j+1][k+1]      .   .   .
 *                                . .       O
 *                                O                   O
 *
 *
 *
 *
 *                                          @
 */
static
bool handle_case_0x723(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (install_tswitch(t, i, j, k,
                            tfind_face_corner(t->sw[i][jp1][k],
                                              t->sw[i][jp1][kp1],
                                              t->sw[i][j][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x723, i, j, k, i, j, k);

        if (install_tswitch(t, ip1, j, kp1,
                            tfind_face_corner(t->sw[i][j][kp1],
                                              t->sw[i][jp1][kp1],
                                              t->sw[ip1][jp1][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x723, i, j, k, ip1, j, kp1);
        return false;
}

/*
 * 3D case 0x72a:                           O
 *                                        .
 *  b0: t->sw[i  ][j  ][k  ]            .
 *  b1:                               .
 *  b2: t->sw[i  ][j+1][k  ]        .
 *  b3:                           O                   O
 *  b4: t->sw[i  ][j  ][k+1]      . .       O
 *  b5:                           .   .
 *  b6: t->sw[i  ][j+1][k+1]      .     .
 *  b7: t->sw[i+1][j+1][k+1]      .       .
 *                                .         O
 *                                O         .         O
 *                                  .       .
 *                                    .     .
 *                                      .   .
 *                                        . .
 *                                          @
 */
static
bool handle_case_0x72a(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (install_tswitch(t, ip1, jp1, k,
                            tfind_face_corner(t->sw[i][jp1][k],
                                              t->sw[i][jp1][kp1],
                                              t->sw[ip1][jp1][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x72a, i, j, k, ip1, jp1, k);

        if (install_tswitch(t, ip1, j, kp1,
                            tfind_face_corner(t->sw[i][j][kp1],
                                              t->sw[i][jp1][kp1],
                                              t->sw[ip1][jp1][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x72a, i, j, k, ip1, j, kp1);
        return false;
}

/*
 * 3D case 0x731:                           O
 *                                        . .
 *  b0:                                 .   .
 *  b1: t->sw[i+1][j  ][k  ]          .     .
 *  b2: t->sw[i  ][j+1][k  ]        .       .
 *  b3: t->sw[i+1][j+1][k  ]      O         .         O
 *  b4:                           .         O
 *  b5:                           .       .   .
 *  b6: t->sw[i  ][j+1][k+1]      .     .       .
 *  b7: t->sw[i+1][j+1][k+1]      .   .           .
 *                                . .       O       .
 *                                O                   O
 *
 *
 *
 *
 *                                          @
 */
static
bool handle_case_0x731(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (install_tswitch(t, i, j, k,
                            tfind_face_corner(t->sw[ip1][j][k],
                                              t->sw[ip1][jp1][k],
                                              t->sw[i][jp1][k]))) {
                return true;
        }
        log_no_crnr(t, 0x731, i, j, k, i, j, k);

        if (install_tswitch(t, ip1, j, kp1,
                            tfind_face_corner(t->sw[ip1][j][k],
                                              t->sw[ip1][jp1][k],
                                              t->sw[ip1][jp1][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x731, i, j, k, ip1, j, kp1);
        return false;
}

/*
 * 3D case 0x732:                           O
 *                                        . .
 *  b0: t->sw[i  ][j  ][k  ]            .   .
 *  b1:                               .     .
 *  b2: t->sw[i  ][j+1][k  ]        .       .
 *  b3: t->sw[i+1][j+1][k  ]      O         .         O
 *  b4:                           .         O
 *  b5:                           .       .
 *  b6: t->sw[i  ][j+1][k+1]      .     .
 *  b7: t->sw[i+1][j+1][k+1]      .   .
 *                                . .       O
 *                                O                   O
 *                                  .
 *                                    .
 *                                      .
 *                                        .
 *                                          @
 */
static
bool handle_case_0x732(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (install_tswitch(t, ip1, j, k,
                            tfind_face_corner(t->sw[i][j][k],
                                              t->sw[i][jp1][k],
                                              t->sw[ip1][jp1][k]))) {
                return true;
        }
        log_no_crnr(t, 0x732, i, j, k, ip1, j, k);

        if (install_tswitch(t, i, j, kp1,
                            tfind_face_corner(t->sw[i][j][k],
                                              t->sw[i][jp1][k],
                                              t->sw[i][jp1][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x732, i, j, k, i, j, kp1);
        return false;
}

/*
 * 3D case 0x745:                           O
 *                                          . .
 *  b0:                                     .   .
 *  b1: t->sw[i+1][j  ][k  ]                .     .
 *  b2:                                     .       .
 *  b3: t->sw[i+1][j+1][k  ]      O         .         O
 *  b4: t->sw[i  ][j  ][k+1]                O       . .
 *  b5: t->sw[i+1][j  ][k+1]                  .   .   .
 *  b6:                                         .     .
 *  b7: t->sw[i+1][j+1][k+1]                  .   .   .
 *                                          O       . .
 *                                O                   O
 *
 *
 *
 *
 *                                          @
 */
static
bool handle_case_0x745(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (install_tswitch(t, i, j, k,
                            tfind_face_corner(t->sw[ip1][j][k],
                                              t->sw[ip1][j][kp1],
                                              t->sw[i][j][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x745, i, j, k, i, j, k);

        if (install_tswitch(t, i, jp1, kp1,
                            tfind_face_corner(t->sw[i][j][kp1],
                                              t->sw[ip1][j][kp1],
                                              t->sw[ip1][jp1][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x745, i, j, k, i, jp1, kp1);
        return false;
}

/*
 * 3D case 0x74c:                           O
 *                                            .
 *  b0: t->sw[i  ][j  ][k  ]                    .
 *  b1: t->sw[i+1][j  ][k  ]                      .
 *  b2:                                             .
 *  b3:                           O                   O
 *  b4: t->sw[i  ][j  ][k+1]                O       . .
 *  b5: t->sw[i+1][j  ][k+1]                      .   .
 *  b6:                                         .     .
 *  b7: t->sw[i+1][j+1][k+1]                  .       .
 *                                          O         .
 *                                O         .         O
 *                                          .       .
 *                                          .     .
 *                                          .   .
 *                                          . .
 *                                          @
 */
static
bool handle_case_0x74c(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (install_tswitch(t, ip1, jp1, k,
                            tfind_face_corner(t->sw[ip1][j][k],
                                              t->sw[ip1][j][kp1],
                                              t->sw[ip1][jp1][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x74c, i, j, k, ip1, jp1, k);

        if (install_tswitch(t, i, jp1, kp1,
                            tfind_face_corner(t->sw[i][j][kp1],
                                              t->sw[ip1][j][kp1],
                                              t->sw[ip1][jp1][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x74c, i, j, k, i, jp1, kp1);
        return false;
}

/*
 * 3D case 0x751:                           O
 *                                          . .
 *  b0:                                     .   .
 *  b1: t->sw[i+1][j  ][k  ]                .     .
 *  b2: t->sw[i  ][j+1][k  ]                .       .
 *  b3: t->sw[i+1][j+1][k  ]      O         .         O
 *  b4:                                     O         .
 *  b5: t->sw[i+1][j  ][k+1]              .   .       .
 *  b6:                                 .       .     .
 *  b7: t->sw[i+1][j+1][k+1]          .           .   .
 *                                  .       O       . .
 *                                O                   O
 *
 *
 *
 *
 *                                          @
 */
static
bool handle_case_0x751(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (install_tswitch(t, i, j, k,
                            tfind_face_corner(t->sw[ip1][j][k],
                                              t->sw[ip1][jp1][k],
                                              t->sw[i][jp1][k]))) {
                return true;
        }
        log_no_crnr(t, 0x751, i, j, k, i, j, k);

        if (install_tswitch(t, i, jp1, kp1,
                            tfind_face_corner(t->sw[i][jp1][k],
                                              t->sw[ip1][jp1][k],
                                              t->sw[ip1][jp1][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x751, i, j, k, i, jp1, kp1);
        return false;
}

/*
 * 3D case 0x754:                           O
 *                                          . .
 *  b0: t->sw[i  ][j  ][k  ]                .   .
 *  b1: t->sw[i+1][j  ][k  ]                .     .
 *  b2:                                     .       .
 *  b3: t->sw[i+1][j+1][k  ]      O         .         O
 *  b4:                                     O         .
 *  b5: t->sw[i+1][j  ][k+1]                  .       .
 *  b6:                                         .     .
 *  b7: t->sw[i+1][j+1][k+1]                      .   .
 *                                          O       . .
 *                                O                   O
 *                                                  .
 *                                                .
 *                                              .
 *                                            .
 *                                          @
 */
static
bool handle_case_0x754(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (install_tswitch(t, i, jp1, k,
                            tfind_face_corner(t->sw[i][j][k],
                                              t->sw[ip1][j][k],
                                              t->sw[ip1][jp1][k]))) {
                return true;
        }
        log_no_crnr(t, 0x754, i, j, k, i, jp1, k);

        if (install_tswitch(t, i, j, kp1,
                            tfind_face_corner(t->sw[i][j][k],
                                              t->sw[ip1][j][k],
                                              t->sw[ip1][j][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x754, i, j, k, i, j, kp1);
        return false;
}

/*
 * 3D case 0x770:                           O
 *                                          .
 *  b0: t->sw[i  ][j  ][k  ]                .
 *  b1: t->sw[i+1][j  ][k  ]                .
 *  b2: t->sw[i  ][j+1][k  ]                .
 *  b3: t->sw[i+1][j+1][k  ]      O         .         O
 *  b4:                                     O
 *  b5:                                   .   .
 *  b6:                                 .       .
 *  b7: t->sw[i+1][j+1][k+1]          .           .
 *                                  .       O       .
 *                                O                   O
 *                                  .               .
 *                                    .           .
 *                                      .       .
 *                                        .   .
 *                                          @
 */
static
bool handle_case_0x770(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (install_tswitch(t, ip1, j, kp1,
                            tfind_face_corner(t->sw[ip1][j][k],
                                              t->sw[ip1][jp1][k],
                                              t->sw[ip1][jp1][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x770, i, j, k, ip1, j, kp1);

        if (install_tswitch(t, i, jp1, kp1,
                            tfind_face_corner(t->sw[i][jp1][k],
                                              t->sw[ip1][jp1][k],
                                              t->sw[ip1][jp1][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x770, i, j, k, i, jp1, kp1);
        return false;
}

/*
 * 3D case 0x78a:                           O
 *
 *  b0: t->sw[i  ][j  ][k  ]
 *  b1:
 *  b2: t->sw[i  ][j+1][k  ]
 *  b3:                           O                   O
 *  b4: t->sw[i  ][j  ][k+1]      . .       O       .
 *  b5: t->sw[i+1][j  ][k+1]      .   .           .
 *  b6: t->sw[i  ][j+1][k+1]      .     .       .
 *  b7:                           .       .   .
 *                                .         O
 *                                O         .         O
 *                                  .       .
 *                                    .     .
 *                                      .   .
 *                                        . .
 *                                          @
 */
static
bool handle_case_0x78a(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (install_tswitch(t, ip1, j, k,
                            tfind_face_corner(t->sw[i][j][k],
                                              t->sw[i][j][kp1],
                                              t->sw[ip1][j][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x78a, i, j, k, ip1, j, k);

        if (install_tswitch(t, ip1, jp1, kp1,
                            tfind_face_corner(t->sw[ip1][j][kp1],
                                              t->sw[i][j][kp1],
                                              t->sw[i][jp1][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x78a, i, j, k, ip1, jp1, kp1);
        return false;
}

/*
 * 3D case 0x78c:                           O
 *
 *  b0: t->sw[i  ][j  ][k  ]
 *  b1: t->sw[i+1][j  ][k  ]
 *  b2:
 *  b3:                           O                   O
 *  b4: t->sw[i  ][j  ][k+1]        .       O       . .
 *  b5: t->sw[i+1][j  ][k+1]          .           .   .
 *  b6: t->sw[i  ][j+1][k+1]            .       .     .
 *  b7:                                   .   .       .
 *                                          O         .
 *                                O         .         O
 *                                          .       .
 *                                          .     .
 *                                          .   .
 *                                          . .
 *                                          @
 */
static
bool handle_case_0x78c(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (install_tswitch(t, i, jp1, k,
                            tfind_face_corner(t->sw[i][j][k],
                                              t->sw[i][j][kp1],
                                              t->sw[i][jp1][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x78c, i, j, k, i, jp1, k);

        if (install_tswitch(t, ip1, jp1, kp1,
                            tfind_face_corner(t->sw[ip1][j][kp1],
                                              t->sw[i][j][kp1],
                                              t->sw[i][jp1][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x78c, i, j, k, ip1, jp1, kp1);
        return false;
}

/*
 * 3D case 0x7a2:                           O
 *
 *  b0: t->sw[i  ][j  ][k  ]
 *  b1:
 *  b2: t->sw[i  ][j+1][k  ]
 *  b3: t->sw[i+1][j+1][k  ]      O                   O
 *  b4: t->sw[i  ][j  ][k+1]      . .       O
 *  b5:                           .   .   .
 *  b6: t->sw[i  ][j+1][k+1]      .     .
 *  b7:                           .   .   .
 *                                . .       O
 *                                O         .         O
 *                                  .       .
 *                                    .     .
 *                                      .   .
 *                                        . .
 *                                          @
 */
static
bool handle_case_0x7a2(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (install_tswitch(t, ip1, j, k,
                            tfind_face_corner(t->sw[i][j][k],
                                              t->sw[i][jp1][k],
                                              t->sw[ip1][jp1][k]))) {
                return true;
        }
        log_no_crnr(t, 0x7a2, i, j, k, ip1, j, k);

        if (install_tswitch(t, ip1, jp1, kp1,
                            tfind_face_corner(t->sw[i][jp1][kp1],
                                              t->sw[i][jp1][k],
                                              t->sw[ip1][jp1][k]))) {
                return true;
        }
        log_no_crnr(t, 0x7a2, i, j, k, ip1, jp1, kp1);
        return false;
}

/*
 * 3D case 0x7a8:                           O
 *
 *  b0: t->sw[i  ][j  ][k  ]
 *  b1: t->sw[ip1][j  ][k  ]
 *  b2: t->sw[i  ][j+1][k  ]
 *  b3:                           O                   O
 *  b4: t->sw[i  ][j  ][k+1]      . .       O
 *  b5:                           .   .
 *  b6: t->sw[i  ][j+1][k+1]      .     .
 *  b7:                           .       .
 *                                .         O
 *                                O         .         O
 *                                  .       .       .
 *                                    .     .     .
 *                                      .   .   .
 *                                        . . .
 *                                          @
 */
static
bool handle_case_0x7a8(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (install_tswitch(t, ip1, jp1, k,
                            tfind_face_corner(t->sw[ip1][j][k],
                                              t->sw[i][j][k],
                                              t->sw[i][jp1][k]))) {
                return true;
        }
        log_no_crnr(t, 0x7a8, i, j, k, ip1, jp1, k);

        if (install_tswitch(t, ip1, j, kp1,
                            tfind_face_corner(t->sw[i][j][kp1],
                                              t->sw[i][j][k],
                                              t->sw[ip1][j][k]))) {
                return true;
        }
        log_no_crnr(t, 0x7a8, i, j, k, ip1, j, kp1);
        return false;
}

/*
 * 3D case 0x7b0:                           O
 *
 *  b0: t->sw[i  ][j  ][k  ]
 *  b1: t->sw[i+1][j  ][k  ]
 *  b2: t->sw[i  ][j+1][k  ]
 *  b3: t->sw[i+1][j+1][k  ]      O                   O
 *  b4:                           .         O
 *  b5:                           .       .   .
 *  b6: t->sw[i  ][j+1][k+1]      .     .       .
 *  b7:                           .   .           .
 *                                . .       O       .
 *                                O                   O
 *                                  .               .
 *                                    .           .
 *                                      .       .
 *                                        .   .
 *                                          @
 */
static
bool handle_case_0x7b0(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (install_tswitch(t, i, j, kp1,
                            tfind_face_corner(t->sw[i][j][k],
                                              t->sw[i][jp1][k],
                                              t->sw[i][jp1][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x7b0, i, j, k, i, j, kp1);

        if (install_tswitch(t, ip1, jp1, kp1,
                            tfind_face_corner(t->sw[i][jp1][kp1],
                                              t->sw[i][jp1][k],
                                              t->sw[ip1][jp1][k]))) {
                return true;
        }
        log_no_crnr(t, 0x7b0, i, j, k, ip1, jp1, kp1);
        return false;
}

/*
 * 3D case 0x7c4:                           O
 *
 *  b0: t->sw[i  ][j  ][k  ]
 *  b1: t->sw[i+1][j  ][k  ]
 *  b2:
 *  b3: t->sw[i+1][j+1][k  ]      O                   O
 *  b4: t->sw[i  ][j  ][k+1]                O       . .
 *  b5: t->sw[i+1][j  ][k+1]                  .   .   .
 *  b6:                                         .     .
 *  b7:                                       .   .   .
 *                                          O       . .
 *                                O         .         O
 *                                          .       .
 *                                          .     .
 *                                          .   .
 *                                          . .
 *                                          @
 */
static
bool handle_case_0x7c4(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (install_tswitch(t, i, jp1, k,
                            tfind_face_corner(t->sw[i][j][k],
                                              t->sw[ip1][j][k],
                                              t->sw[ip1][jp1][k]))) {
                return true;
        }
        log_no_crnr(t, 0x7c4, i, j, k, i, jp1, k);

        if (install_tswitch(t, ip1, jp1, kp1,
                            tfind_face_corner(t->sw[ip1][j][kp1],
                                              t->sw[ip1][j][k],
                                              t->sw[ip1][jp1][k]))) {
                return true;
        }
        log_no_crnr(t, 0x7c4, i, j, k, ip1, jp1, kp1);
        return false;
}

/*
 * 3D case 0x7c8:                           O
 *
 *  b0: t->sw[i  ][j  ][k  ]
 *  b1: t->sw[i+1][j  ][k  ]
 *  b2: t->sw[i  ][j+1][k  ]
 *  b3:                           O                   O
 *  b4: t->sw[i  ][j  ][k+1]                O       . .
 *  b5: t->sw[i+1][j  ][k+1]                      .   .
 *  b6:                                         .     .
 *  b7:                                       .       .
 *                                          O         .
 *                                O         .         O
 *                                  .       .       .
 *                                    .     .     .
 *                                      .   .   .
 *                                        . . .
 *                                          @
 */
static
bool handle_case_0x7c8(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (install_tswitch(t, ip1, jp1, k,
                            tfind_face_corner(t->sw[ip1][j][k],
                                              t->sw[i][j][k],
                                              t->sw[i][jp1][k]))) {
                return true;
        }
        log_no_crnr(t, 0x7c8, i, j, k, ip1, jp1, k);

        if (install_tswitch(t, i, jp1, kp1,
                            tfind_face_corner(t->sw[i][j][kp1],
                                              t->sw[i][j][k],
                                              t->sw[i][jp1][k]))) {
                return true;
        }
        log_no_crnr(t, 0x7c8, i, j, k, i, jp1, kp1);
        return false;
}

/*
 * 3D case 0x7d0:                           O
 *
 *  b0: t->sw[i  ][j  ][k  ]
 *  b1: t->sw[i+1][j  ][k  ]
 *  b2: t->sw[i  ][j+1][k  ]
 *  b3: t->sw[i+1][j+1][k  ]      O                   O
 *  b4:                                     O         .
 *  b5: t->sw[i+1][j  ][k+1]              .   .       .
 *  b6:                                 .       .     .
 *  b7:                               .           .   .
 *                                  .       O       . .
 *                                O                   O
 *                                  .               .
 *                                    .           .
 *                                      .       .
 *                                        .   .
 *                                          @
 */
static
bool handle_case_0x7d0(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (install_tswitch(t, i, j, kp1,
                            tfind_face_corner(t->sw[i][j][k],
                                              t->sw[ip1][j][k],
                                              t->sw[ip1][j][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x7d0, i, j, k, i, j, kp1);

        if (install_tswitch(t, ip1, jp1, kp1,
                            tfind_face_corner(t->sw[ip1][j][kp1],
                                              t->sw[ip1][j][k],
                                              t->sw[ip1][jp1][k]))) {
                return true;
        }
        log_no_crnr(t, 0x7d0, i, j, k, ip1, jp1, kp1);
        return false;
}

/*
 * 3D case 0x7e0:                           O
 *
 *  b0: t->sw[i  ][j  ][k  ]
 *  b1: t->sw[i+1][j  ][k  ]
 *  b2: t->sw[i  ][j+1][k  ]
 *  b3: t->sw[i+1][j+1][k  ]      O                   O
 *  b4: t->sw[i  ][j  ][k+1]                O
 *  b5:                                   .   .
 *  b6:                                 .       .
 *  b7:                               .           .
 *                                  .       O       .
 *                                O         .         O
 *                                  .       .       .
 *                                    .     .     .
 *                                      .   .   .
 *                                        . . .
 *                                          @
 */
static
bool handle_case_0x7e0(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (install_tswitch(t, ip1, j, kp1,
                            tfind_face_corner(t->sw[i][j][kp1],
                                              t->sw[i][j][k],
                                              t->sw[ip1][j][k]))) {
                return true;
        }
        log_no_crnr(t, 0x7e0, i, j, k, ip1, j, kp1);

        if (install_tswitch(t, i, jp1, kp1,
                            tfind_face_corner(t->sw[i][j][kp1],
                                              t->sw[i][j][k],
                                              t->sw[i][jp1][k]))) {
                return true;
        }
        log_no_crnr(t, 0x7e0, i, j, k, i, jp1, kp1);
        return false;
}

/*
 * Handle the cases where two corners on a single edge are missing.
 */

/*
 * 3D case 0x703:                           O
 *                                        . . .
 *  b0:                                 .   .   .
 *  b1:                               .     .     .
 *  b2: t->sw[i  ][j+1][k  ]        .       .       .
 *  b3: t->sw[i+1][j+1][k  ]      O         .         O
 *  b4: t->sw[i  ][j  ][k+1]      . .       O       .
 *  b5: t->sw[i+1][j  ][k+1]      .   .   .       .
 *  b6: t->sw[i  ][j+1][k+1]      .     .       .
 *  b7: t->sw[i+1][j+1][k+1]      .   .   .   .
 *                                . .       O
 *                                O                   O
 *
 *
 *
 *
 *                                          @
 */
static
bool handle_case_0x703(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (install_tswitch(t, i, j, k,
                            tfind_face_corner(t->sw[i][jp1][k],
                                              t->sw[i][jp1][kp1],
                                              t->sw[i][j][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x703, i, j, k, i, j, k);

        if (install_tswitch(t, ip1, j, k,
                            tfind_face_corner(t->sw[ip1][jp1][k],
                                              t->sw[ip1][jp1][kp1],
                                              t->sw[ip1][j][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x703, i, j, k, ip1, j, k);
        return false;
}

/*
 * 3D case 0x705:                           O
 *                                        . . .
 *  b0:                                 .   .   .
 *  b1: t->sw[i+1][j  ][k  ]          .     .     .
 *  b2:                             .       .       .
 *  b3: t->sw[i+1][j+1][k  ]      O         .         O
 *  b4: t->sw[i  ][j  ][k+1]        .       O       . .
 *  b5: t->sw[i+1][j  ][k+1]          .       .   .   .
 *  b6: t->sw[i  ][j+1][k+1]            .       .     .
 *  b7: t->sw[i+1][j+1][k+1]              .   .   .   .
 *                                          O       . .
 *                                O                   O
 *
 *
 *
 *
 *                                          @
 */
static
bool handle_case_0x705(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (install_tswitch(t, i, j, k,
                            tfind_face_corner(t->sw[ip1][j][k],
                                              t->sw[ip1][j][kp1],
                                              t->sw[i][j][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x705, i, j, k, i, j, k);

        if (install_tswitch(t, i, jp1, k,
                            tfind_face_corner(t->sw[ip1][jp1][k],
                                              t->sw[ip1][jp1][kp1],
                                              t->sw[i][jp1][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x705, i, j, k, i, jp1, k);
        return false;
}

/*
 * 3D case 0x70a:                           O
 *                                        . . .
 *  b0: t->sw[i  ][j  ][k  ]            .       .
 *  b1:                               .           .
 *  b2: t->sw[i  ][j+1][k  ]        .               .
 *  b3:                           O                   O
 *  b4: t->sw[i  ][j  ][k+1]      . .       O       .
 *  b5: t->sw[i+1][j  ][k+1]      .   .           .
 *  b6: t->sw[i  ][j+1][k+1]      .     .       .
 *  b7: t->sw[i+1][j+1][k+1]      .       .   .
 *                                .         O
 *                                O         .         O
 *                                  .       .
 *                                    .     .
 *                                      .   .
 *                                        . .
 *                                          @
 */
static
bool handle_case_0x70a(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (install_tswitch(t, ip1, j, k,
                            tfind_face_corner(t->sw[i][j][k],
                                              t->sw[i][j][kp1],
                                              t->sw[ip1][j][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x70a, i, j, k, ip1, j, k);

        if (install_tswitch(t, ip1, jp1, k,
                            tfind_face_corner(t->sw[i][jp1][k],
                                              t->sw[i][jp1][kp1],
                                              t->sw[ip1][jp1][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x70a, i, j, k, ip1, jp1, k);
        return false;
}

/*
 * 3D case 0x70c:                           O
 *                                        .   .
 *  b0: t->sw[i  ][j  ][k  ]            .       .
 *  b1: t->sw[i+1][j  ][k  ]          .           .
 *  b2:                             .               .
 *  b3:                           O                   O
 *  b4: t->sw[i  ][j  ][k+1]        .       O       . .
 *  b5: t->sw[i+1][j  ][k+1]          .           .   .
 *  b6: t->sw[i  ][j+1][k+1]            .       .     .
 *  b7: t->sw[i+1][j+1][k+1]              .   .       .
 *                                          O         .
 *                                O         .         O
 *                                          .       .
 *                                          .     .
 *                                          .   .
 *                                          . .
 *                                          @
 */
static
bool handle_case_0x70c(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (install_tswitch(t, i, jp1, k,
                            tfind_face_corner(t->sw[i][j][k],
                                              t->sw[i][j][kp1],
                                              t->sw[i][jp1][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x70c, i, j, k, i, jp1, k);

        if (install_tswitch(t, ip1, jp1, k,
                            tfind_face_corner(t->sw[ip1][j][k],
                                              t->sw[ip1][j][kp1],
                                              t->sw[ip1][jp1][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x70c, i, j, k, ip1, jp1, k);
        return false;
}

/*
 * 3D case 0x711:                           O
 *                                        . . .
 *  b0:                                 .   .   .
 *  b1: t->sw[i+1][j  ][k  ]          .     .     .
 *  b2: t->sw[i  ][j+1][k  ]        .       .       .
 *  b3: t->sw[i+1][j+1][k  ]      O         .         O
 *  b4:                           .         O         .
 *  b5: t->sw[i+1][j  ][k+1]      .       .   .       .
 *  b6: t->sw[i  ][j+1][k+1]      .     .       .     .
 *  b7: t->sw[i+1][j+1][k+1]      .   .           .   .
 *                                . .       O       . .
 *                                O                   O
 *
 *
 *
 *
 *                                          @
 */
static
bool handle_case_0x711(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (install_tswitch(t, i, j, k,
                            tfind_face_corner(t->sw[ip1][j][k],
                                              t->sw[ip1][jp1][k],
                                              t->sw[i][jp1][k]))) {
                return true;
        }
        log_no_crnr(t, 0x711, i, j, k, i, j, k);

        if (install_tswitch(t, i, j, kp1,
                            tfind_face_corner(t->sw[ip1][j][kp1],
                                              t->sw[ip1][jp1][kp1],
                                              t->sw[i][jp1][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x711, i, j, k, i, j, kp1);
        return false;
}

/*
 * 3D case 0x722:                           O
 *                                        . .
 *  b0: t->sw[i  ][j  ][k  ]            .   .
 *  b1:                               .     .
 *  b2: t->sw[i  ][j+1][k  ]        .       .
 *  b3: t->sw[i+1][j+1][k  ]      O         .         O
 *  b4: t->sw[i  ][j  ][k+1]      . .       O
 *  b5:                           .   .   .
 *  b6: t->sw[i  ][j+1][k+1]      .     .
 *  b7: t->sw[i+1][j+1][k+1]      .   .   .
 *                                . .       O
 *                                O         .         O
 *                                  .       .
 *                                    .     .
 *                                      .   .
 *                                        . .
 *                                          @
 */
static
bool handle_case_0x722(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (install_tswitch(t, ip1, j, k,
                            tfind_face_corner(t->sw[i][j][k],
                                              t->sw[i][jp1][k],
                                              t->sw[ip1][jp1][k]))) {
                return true;
        }
        log_no_crnr(t, 0x722, i, j, k, ip1, j, k);

        if (install_tswitch(t, ip1, j, kp1,
                            tfind_face_corner(t->sw[i][j][kp1],
                                              t->sw[i][jp1][kp1],
                                              t->sw[ip1][jp1][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x722, i, j, k, ip1, j, kp1);
        return false;
}

/*
 * 3D case 0x730:                           O
 *                                        . .
 *  b0: t->sw[i  ][j  ][k  ]            .   .
 *  b1: t->sw[i+1][j  ][k  ]          .     .
 *  b2: t->sw[i  ][j+1][k  ]        .       .
 *  b3: t->sw[i+1][j+1][k  ]      O         .         O
 *  b4:                           .         O
 *  b5:                           .       .   .
 *  b6: t->sw[i  ][j+1][k+1]      .     .       .
 *  b7: t->sw[i+1][j+1][k+1]      .   .           .
 *                                . .       O       .
 *                                O                   O
 *                                  .               .
 *                                    .           .
 *                                      .       .
 *                                        .   .
 *                                          @
 */
static
bool handle_case_0x730(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (install_tswitch(t, i, j, kp1,
                            tfind_face_corner(t->sw[i][j][k],
                                              t->sw[i][jp1][k],
                                              t->sw[i][jp1][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x730, i, j, k, i, j, kp1);

        if (install_tswitch(t, ip1, j, kp1,
                            tfind_face_corner(t->sw[ip1][j][k],
                                              t->sw[ip1][jp1][k],
                                              t->sw[ip1][jp1][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x730, i, j, k, ip1, j, kp1);
        return false;
}

/*
 * 3D case 0x744:                           O
 *                                          . .
 *  b0: t->sw[i  ][j  ][k  ]                .   .
 *  b1: t->sw[i+1][j  ][k  ]                .     .
 *  b2:                                     .       .
 *  b3: t->sw[i+1][j+1][k  ]      O         .         O
 *  b4: t->sw[i  ][j  ][k+1]                O       . .
 *  b5: t->sw[i+1][j  ][k+1]                  .   .   .
 *  b6:                                         .     .
 *  b7: t->sw[i+1][j+1][k+1]                  .   .   .
 *                                          O       . .
 *                                O         .         O
 *                                          .       .
 *                                          .     .
 *                                          .   .
 *                                          . .
 *                                          @
 */
static
bool handle_case_0x744(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (install_tswitch(t, i, jp1, k,
                            tfind_face_corner(t->sw[i][j][k],
                                              t->sw[ip1][j][k],
                                              t->sw[ip1][jp1][k]))) {
                return true;
        }
        log_no_crnr(t, 0x744, i, j, k, i, jp1, k);

        if (install_tswitch(t, i, jp1, kp1,
                            tfind_face_corner(t->sw[i][j][kp1],
                                              t->sw[ip1][j][kp1],
                                              t->sw[ip1][jp1][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x744, i, j, k, i, jp1, kp1);
        return false;
}

/*
 * 3D case 0x750:                           O
 *                                          . .
 *  b0: t->sw[i  ][j  ][k  ]                .   .
 *  b1: t->sw[i+1][j  ][k  ]                .     .
 *  b2: t->sw[i  ][j+1][k  ]                .       .
 *  b3: t->sw[i+1][j+1][k  ]      O         .         O
 *  b4:                                     O         .
 *  b5: t->sw[i+1][j  ][k+1]              .   .       .
 *  b6:                                 .       .     .
 *  b7: t->sw[i+1][j+1][k+1]          .           .   .
 *                                  .       O       . .
 *                                O                   O
 *                                  .               .
 *                                    .           .
 *                                      .       .
 *                                        .   .
 *                                          @
 */
static
bool handle_case_0x750(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (install_tswitch(t, i, j, kp1,
                            tfind_face_corner(t->sw[i][j][k],
                                              t->sw[ip1][j][k],
                                              t->sw[ip1][j][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x750, i, j, k, i, j, kp1);

        if (install_tswitch(t, i, jp1, kp1,
                            tfind_face_corner(t->sw[i][jp1][k],
                                              t->sw[ip1][jp1][k],
                                              t->sw[ip1][jp1][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x750, i, j, k, i, jp1, kp1);
        return false;
}

/*
 * 3D case 0x788:                           O
 *
 *  b0: t->sw[i  ][j  ][k  ]
 *  b1: t->sw[ip1][j  ][k  ]
 *  b2: t->sw[i  ][j+1][k  ]
 *  b3:                           O                   O
 *  b4: t->sw[i  ][j  ][k+1]      . .       O       . .
 *  b5: t->sw[i+1][j  ][k+1]      .   .           .   .
 *  b6: t->sw[i  ][j+1][k+1]      .     .       .     .
 *  b7:                           .       .   .       .
 *                                .         O         .
 *                                O         .         O
 *                                  .       .       .
 *                                    .     .     .
 *                                      .   .   .
 *                                        . . .
 *                                          @
 */
static
bool handle_case_0x788(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (install_tswitch(t, ip1, jp1, k,
                            tfind_face_corner(t->sw[ip1][j][k],
                                              t->sw[i][j][k],
                                              t->sw[i][jp1][k]))) {
                return true;
        }
        log_no_crnr(t, 0x788, i, j, k, ip1, jp1, k);

        if (install_tswitch(t, ip1, jp1, kp1,
                            tfind_face_corner(t->sw[ip1][j][kp1],
                                              t->sw[i][j][kp1],
                                              t->sw[i][jp1][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x788, i, j, k, ip1, jp1, kp1);
        return false;
}

/*
 * 3D case 0x7a0:                           O
 *
 *  b0: t->sw[i  ][j  ][k  ]
 *  b1: t->sw[i+1][j  ][k  ]
 *  b2: t->sw[i  ][j+1][k  ]
 *  b3: t->sw[i+1][j+1][k  ]      O                   O
 *  b4: t->sw[i  ][j  ][k+1]      . .       O
 *  b5:                           .   .   .   .
 *  b6: t->sw[i  ][j+1][k+1]      .     .       .
 *  b7:                           .   .   .       .
 *                                . .       O       .
 *                                O         .         O
 *                                  .       .       .
 *                                    .     .     .
 *                                      .   .   .
 *                                        . . .
 *                                          @
 */
static
bool handle_case_0x7a0(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (install_tswitch(t, ip1, j, kp1,
                            tfind_face_corner(t->sw[i][j][kp1],
                                              t->sw[i][j][k],
                                              t->sw[ip1][j][k]))) {
                return true;
        }
        log_no_crnr(t, 0x7a0, i, j, k, ip1, j, kp1);

        if (install_tswitch(t, ip1, jp1, kp1,
                            tfind_face_corner(t->sw[i][jp1][kp1],
                                              t->sw[i][jp1][k],
                                              t->sw[ip1][jp1][k]))) {
                return true;
        }
        log_no_crnr(t, 0x7a0, i, j, k, ip1, jp1, kp1);
        return false;
}

/*
 * 3D case 0x7c0:                           O
 *
 *  b0: t->sw[i  ][j  ][k  ]
 *  b1: t->sw[i+1][j  ][k  ]
 *  b2: t->sw[i  ][j+1][k  ]
 *  b3: t->sw[i+1][j+1][k  ]      O                   O
 *  b4: t->sw[i  ][j  ][k+1]                O       . .
 *  b5: t->sw[i+1][j  ][k+1]              .   .   .   .
 *  b6:                                 .       .     .
 *  b7:                               .       .   .   .
 *                                  .       O       . .
 *                                O         .         O
 *                                  .       .       .
 *                                    .     .     .
 *                                      .   .   .
 *                                        . . .
 *                                          @
 */
static
bool handle_case_0x7c0(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (install_tswitch(t, i, jp1, kp1,
                            tfind_face_corner(t->sw[i][j][kp1],
                                              t->sw[i][j][k],
                                              t->sw[i][jp1][k]))) {
                return true;
        }
        log_no_crnr(t, 0x7c0, i, j, k, i, jp1, kp1);

        if (install_tswitch(t, ip1, jp1, kp1,
                            tfind_face_corner(t->sw[ip1][j][kp1],
                                              t->sw[ip1][j][k],
                                              t->sw[ip1][jp1][k]))) {
                return true;
        }
        log_no_crnr(t, 0x7c0, i, j, k, ip1, jp1, kp1);
        return false;
}

/*
 * Handle the cases where a single corner is missing.
 */

/*
 * 3D case 0x701:                           O
 *                                        . . .
 *  b0:                                     .   .   .
 *  b1: t->sw[i+1][j  ][k  ]          .     .     .
 *  b2: t->sw[i  ][j+1][k  ]        .       .       .
 *  b3: t->sw[i+1][j+1][k  ]      O         .         O
 *  b4: t->sw[i  ][j  ][k+1]      . .       O       . .
 *  b5: t->sw[i+1][j  ][k+1]      .   .   .   .   .   .
 *  b6: t->sw[i  ][j+1][k+1]      .     .       .     .
 *  b7: t->sw[i+1][j+1][k+1]      .   .   .   .   .   .
 *                                . .       O       . .
 *                                O                   O
 *
 *
 *
 *
 *                                          @
 */
static
bool handle_case_0x701(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);

        if (install_tswitch(t, i, j, k,
                            tfind_face_corner(t->sw[i][jp1][k],
                                              t->sw[ip1][jp1][k],
                                              t->sw[ip1][j][k]))) {
                return true;
        }
        log_no_crnr(t, 0x701, i, j, k, i, j, k);
        return false;
}

/*
 * 3D case 0x702:                           O
 *                                        . . .
 *  b0: t->sw[i  ][j  ][k  ]            .   .   .
 *  b1:                               .     .     .
 *  b2: t->sw[i  ][j+1][k  ]        .       .       .
 *  b3: t->sw[i+1][j+1][k  ]      O         .         O
 *  b4: t->sw[i  ][j  ][k+1]      . .       O       .
 *  b5: t->sw[i+1][j  ][k+1]      .   .   .       .
 *  b6: t->sw[i  ][j+1][k+1]      .     .       .
 *  b7: t->sw[i+1][j+1][k+1]      .   .   .   .
 *                                . .       O
 *                                O         .         O
 *                                  .       .
 *                                    .     .
 *                                      .   .
 *                                        . .
 *                                          @
 */
static
bool handle_case_0x702(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (install_tswitch(t, ip1, j, k,
                            tfind_face_corner(t->sw[i][j][k],
                                              t->sw[i][j][kp1],
                                              t->sw[ip1][j][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x702, i, j, k, ip1, j, k);
        return false;
}

/*
 * 3D case 0x704:                           O
 *                                        . . .
 *  b0: t->sw[i  ][j  ][k  ]            .   .   .
 *  b1: t->sw[i+1][j  ][k  ]          .     .     .
 *  b2:                             .       .       .
 *  b3: t->sw[i+1][j+1][k  ]      O         .         O
 *  b4: t->sw[i  ][j  ][k+1]        .       O       . .
 *  b5: t->sw[i+1][j  ][k+1]          .       .   .   .
 *  b6: t->sw[i  ][j+1][k+1]            .       .     .
 *  b7: t->sw[i+1][j+1][k+1]              .   .   .   .
 *                                          O       . .
 *                                O         .         O
 *                                          .       .
 *                                          .     .
 *                                          .   .
 *                                          . .
 *                                          @
 */
static
bool handle_case_0x704(struct torus *t, int i, int j, int k)
{
        int jp1 = canonicalize(j + 1, t->y_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (install_tswitch(t, i, jp1, k,
                            tfind_face_corner(t->sw[i][j][k],
                                              t->sw[i][j][kp1],
                                              t->sw[i][jp1][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x704, i, j, k, i, jp1, k);
        return false;
}

/*
 * 3D case 0x708:                           O
 *                                        .   .
 *  b0: t->sw[i  ][j  ][k  ]            .       .
 *  b1: t->sw[i+1][j  ][k  ]          .           .
 *  b2: t->sw[i  ][j+1][k  ]        .               .
 *  b3:                           O                   O
 *  b4: t->sw[i  ][j  ][k+1]      . .       O       . .
 *  b5: t->sw[i+1][j  ][k+1]      .   .           .   .
 *  b6: t->sw[i  ][j+1][k+1]      .     .       .     .
 *  b7: t->sw[i+1][j+1][k+1]      .       .   .       .
 *                                .         O         .
 *                                O         .         O
 *                                  .       .       .
 *                                    .     .     .
 *                                      .   .   .
 *                                        . . .
 *                                          @
 */
static
bool handle_case_0x708(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);

        if (install_tswitch(t, ip1, jp1, k,
                            tfind_face_corner(t->sw[i][jp1][k],
                                              t->sw[i][j][k],
                                              t->sw[ip1][j][k]))) {
                return true;
        }
        log_no_crnr(t, 0x708, i, j, k, ip1, jp1, k);
        return false;
}

/*
 * 3D case 0x710:                           O
 *                                        . . .
 *  b0: t->sw[i  ][j  ][k  ]            .   .   .
 *  b1: t->sw[i+1][j  ][k  ]          .     .     .
 *  b2: t->sw[i  ][j+1][k  ]        .       .       .
 *  b3: t->sw[i+1][j+1][k  ]      O         .         O
 *  b4:                           .         O         .
 *  b5: t->sw[i+1][j  ][k+1]      .       .   .       .
 *  b6: t->sw[i  ][j+1][k+1]      .     .       .     .
 *  b7: t->sw[i+1][j+1][k+1]      .   .           .   .
 *                                . .       O       . .
 *                                O                   O
 *                                  .               .
 *                                    .           .
 *                                      .       .
 *                                        .   .
 *                                          @
 */
static
bool handle_case_0x710(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (install_tswitch(t, i, j, kp1,
                            tfind_face_corner(t->sw[i][j][k],
                                              t->sw[ip1][j][k],
                                              t->sw[ip1][j][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x710, i, j, k, i, j, kp1);
        return false;
}

/*
 * 3D case 0x720:                           O
 *                                        . .
 *  b0: t->sw[i  ][j  ][k  ]            .   .
 *  b1: t->sw[i+1][j  ][k  ]          .     .
 *  b2: t->sw[i  ][j+1][k  ]        .       .
 *  b3: t->sw[i+1][j+1][k  ]      O         .         O
 *  b4: t->sw[i  ][j  ][k+1]      . .       O
 *  b5:                           .   .   .   .
 *  b6: t->sw[i  ][j+1][k+1]      .     .       .
 *  b7: t->sw[i+1][j+1][k+1]      .   .   .       .
 *                                . .       O       .
 *                                O         .         O
 *                                  .       .       .
 *                                    .     .     .
 *                                      .   .   .
 *                                        . . .
 *                                          @
 */
static
bool handle_case_0x720(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (install_tswitch(t, ip1, j, kp1,
                            tfind_face_corner(t->sw[ip1][j][k],
                                              t->sw[i][j][k],
                                              t->sw[i][j][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x720, i, j, k, ip1, j, kp1);
        return false;
}

/*
 * 3D case 0x740:                           O
 *                                          . .
 *  b0: t->sw[i  ][j  ][k  ]                .   .
 *  b1: t->sw[i+1][j  ][k  ]                .     .
 *  b2: t->sw[i  ][j+1][k  ]                .       .
 *  b3: t->sw[i+1][j+1][k  ]      O         .         O
 *  b4: t->sw[i  ][j  ][k+1]                O       . .
 *  b5: t->sw[i+1][j  ][k+1]              .   .   .   .
 *  b6:                                 .       .     .
 *  b7: t->sw[i+1][j+1][k+1]          .       .   .   .
 *                                  .       O       . .
 *                                O         .         O
 *                                  .       .       .
 *                                    .     .     .
 *                                      .   .   .
 *                                        . . .
 *                                          @
 */
static
bool handle_case_0x740(struct torus *t, int i, int j, int k)
{
        int jp1 = canonicalize(j + 1, t->y_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (install_tswitch(t, i, jp1, kp1,
                            tfind_face_corner(t->sw[i][jp1][k],
                                              t->sw[i][j][k],
                                              t->sw[i][j][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x740, i, j, k, i, jp1, kp1);
        return false;
}

/*
 * 3D case 0x780:                           O
 *
 *  b0: t->sw[i  ][j  ][k  ]
 *  b1: t->sw[i+1][j  ][k  ]
 *  b2: t->sw[i  ][j+1][k  ]
 *  b3: t->sw[i+1][j+1][k  ]      O                   O
 *  b4: t->sw[i  ][j  ][k+1]      . .       O       . .
 *  b5: t->sw[i+1][j  ][k+1]      .   .   .   .   .   .
 *  b6: t->sw[i  ][j+1][k+1]      .     .       .     .
 *  b7:                           .   .   .   .   .   .
 *                                . .       O       . .
 *                                O         .         O
 *                                  .       .       .
 *                                    .     .     .
 *                                      .   .   .
 *                                        . . .
 *                                          @
 */
static
bool handle_case_0x780(struct torus *t, int i, int j, int k)
{
        int ip1 = canonicalize(i + 1, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        if (install_tswitch(t, ip1, jp1, kp1,
                            tfind_face_corner(t->sw[i][jp1][kp1],
                                              t->sw[i][j][kp1],
                                              t->sw[ip1][j][kp1]))) {
                return true;
        }
        log_no_crnr(t, 0x780, i, j, k, ip1, jp1, kp1);
        return false;
}

/*
 * Make sure links between all known torus/mesh switches are installed.
 *
 * We don't have to worry about links that wrap on a mesh coordinate, as
 * there shouldn't be any; if there are it indicates an input error.
 */
static
void check_tlinks(struct torus *t, int i, int j, int k)
{
        struct t_switch ****sw = t->sw;
        int ip1 = canonicalize(i + 1, t->x_sz);
        int jp1 = canonicalize(j + 1, t->y_sz);
        int kp1 = canonicalize(k + 1, t->z_sz);

        /*
         * Don't waste time/code checking return status of link_tswitches()
         * here.  It is unlikely to fail, and the result of any failure here
         * will be caught elsewhere anyway.
         */
        if (sw[i][j][k] && sw[ip1][j][k])
                link_tswitches(t, 0, sw[i][j][k], sw[ip1][j][k]);

        if (sw[i][jp1][k] && sw[ip1][jp1][k])
                link_tswitches(t, 0, sw[i][jp1][k], sw[ip1][jp1][k]);

        if (sw[i][j][kp1] && sw[ip1][j][kp1])
                link_tswitches(t, 0, sw[i][j][kp1], sw[ip1][j][kp1]);

        if (sw[i][jp1][kp1] && sw[ip1][jp1][kp1])
                link_tswitches(t, 0, sw[i][jp1][kp1], sw[ip1][jp1][kp1]);


        if (sw[i][j][k] && sw[i][jp1][k])
                link_tswitches(t, 1, sw[i][j][k], sw[i][jp1][k]);

        if (sw[ip1][j][k] && sw[ip1][jp1][k])
                link_tswitches(t, 1, sw[ip1][j][k], sw[ip1][jp1][k]);

        if (sw[i][j][kp1] && sw[i][jp1][kp1])
                link_tswitches(t, 1, sw[i][j][kp1], sw[i][jp1][kp1]);

        if (sw[ip1][j][kp1] && sw[ip1][jp1][kp1])
                link_tswitches(t, 1, sw[ip1][j][kp1], sw[ip1][jp1][kp1]);


        if (sw[i][j][k] && sw[i][j][kp1])
                link_tswitches(t, 2, sw[i][j][k], sw[i][j][kp1]);

        if (sw[ip1][j][k] && sw[ip1][j][kp1])
                link_tswitches(t, 2, sw[ip1][j][k], sw[ip1][j][kp1]);

        if (sw[i][jp1][k] && sw[i][jp1][kp1])
                link_tswitches(t, 2, sw[i][jp1][k], sw[i][jp1][kp1]);

        if (sw[ip1][jp1][k] && sw[ip1][jp1][kp1])
                link_tswitches(t, 2, sw[ip1][jp1][k], sw[ip1][jp1][kp1]);
}

static
void locate_sw(struct torus *t, int i, int j, int k)
{
        unsigned fp;
        bool success;

        i = canonicalize(i, t->x_sz);
        j = canonicalize(j, t->y_sz);
        k = canonicalize(k, t->z_sz);

        /*
         * By definition, if a coordinate direction is meshed, we don't
         * allow it to wrap to zero.
         */
        if (t->flags & X_MESH) {
                int ip1 = canonicalize(i + 1, t->x_sz);
                if (ip1 < i)
                        goto out;
        }
        if (t->flags & Y_MESH) {
                int jp1 = canonicalize(j + 1, t->y_sz);
                if (jp1 < j)
                        goto out;
        }
        if (t->flags & Z_MESH) {
                int kp1 = canonicalize(k + 1, t->z_sz);
                if (kp1 < k)
                        goto out;
        }
        /*
         * There are various reasons that the links are not installed between
         * known torus switches.  These include cases where the search for
         * new switches only partially succeeds due to missing switches, and
         * cases where we haven't processed this position yet, but processing
         * of multiple independent neighbor positions has installed switches
         * into corners of our case.
         *
         * In any event, the topology assumptions made in handling the
         * fingerprint for this position require that all links be installed
         * between installed switches for this position.
         */
again:
        check_tlinks(t, i, j, k);
        fp = fingerprint(t, i, j, k);

        switch (fp) {
        /*
         * When all switches are present, we are done.  Otherwise, one of
         * the cases below will be unsuccessful, and we'll be done also.
         *
         * Note that check_tlinks() above will ensure all links that are
         * present are connected, in the event that all our switches are
         * present due to successful case handling in the surrounding
         * torus/mesh.
         */
        case 0x300:
        case 0x500:
        case 0x600:
        case 0x700:
                goto out;
        /*
         * Ignore the 2D cases where there isn't enough information to uniquely
         * locate/place a switch into the cube.
         */
        case 0x30f:     /* 0 corners available */
        case 0x533:     /* 0 corners available */
        case 0x655:     /* 0 corners available */
        case 0x30e:     /* 1 corner available */
        case 0x532:     /* 1 corner available */
        case 0x654:     /* 1 corner available */
        case 0x30d:     /* 1 corner available */
        case 0x531:     /* 1 corner available */
        case 0x651:     /* 1 corner available */
        case 0x30b:     /* 1 corner available */
        case 0x523:     /* 1 corner available */
        case 0x645:     /* 1 corner available */
        case 0x307:     /* 1 corner available */
        case 0x513:     /* 1 corner available */
        case 0x615:     /* 1 corner available */
                goto out;
        /*
         * Handle the 2D cases with a single existing edge.
         *
         */
        case 0x30c:
                success = handle_case_0x30c(t, i, j, k);
                break;
        case 0x303:
                success = handle_case_0x303(t, i, j, k);
                break;
        case 0x305:
                success = handle_case_0x305(t, i, j, k);
                break;
        case 0x30a:
                success = handle_case_0x30a(t, i, j, k);
                break;
        case 0x503:
                success = handle_case_0x503(t, i, j, k);
                break;
        case 0x511:
                success = handle_case_0x511(t, i, j, k);
                break;
        case 0x522:
                success = handle_case_0x522(t, i, j, k);
                break;
        case 0x530:
                success = handle_case_0x530(t, i, j, k);
                break;
        case 0x605:
                success = handle_case_0x605(t, i, j, k);
                break;
        case 0x611:
                success = handle_case_0x611(t, i, j, k);
                break;
        case 0x644:
                success = handle_case_0x644(t, i, j, k);
                break;
        case 0x650:
                success = handle_case_0x650(t, i, j, k);
                break;
        /*
         * Handle the 2D cases where two existing edges meet at a corner.
         */
        case 0x301:
                success = handle_case_0x301(t, i, j, k);
                break;
        case 0x302:
                success = handle_case_0x302(t, i, j, k);
                break;
        case 0x304:
                success = handle_case_0x304(t, i, j, k);
                break;
        case 0x308:
                success = handle_case_0x308(t, i, j, k);
                break;
        case 0x501:
                success = handle_case_0x501(t, i, j, k);
                break;
        case 0x502:
                success = handle_case_0x502(t, i, j, k);
                break;
        case 0x520:
                success = handle_case_0x520(t, i, j, k);
                break;
        case 0x510:
                success = handle_case_0x510(t, i, j, k);
                break;
        case 0x601:
                success = handle_case_0x601(t, i, j, k);
                break;
        case 0x604:
                success = handle_case_0x604(t, i, j, k);
                break;
        case 0x610:
                success = handle_case_0x610(t, i, j, k);
                break;
        case 0x640:
                success = handle_case_0x640(t, i, j, k);
                break;
        /*
         * Ignore the 3D cases where there isn't enough information to uniquely
         * locate/place a switch into the cube.
         */
        case 0x7ff:     /* 0 corners available */
        case 0x7fe:     /* 1 corner available */
        case 0x7fd:     /* 1 corner available */
        case 0x7fb:     /* 1 corner available */
        case 0x7f7:     /* 1 corner available */
        case 0x7ef:     /* 1 corner available */
        case 0x7df:     /* 1 corner available */
        case 0x7bf:     /* 1 corner available */
        case 0x77f:     /* 1 corner available */
        case 0x7fc:     /* 2 adj corners available */
        case 0x7fa:     /* 2 adj corners available */
        case 0x7f5:     /* 2 adj corners available */
        case 0x7f3:     /* 2 adj corners available */
        case 0x7cf:     /* 2 adj corners available */
        case 0x7af:     /* 2 adj corners available */
        case 0x75f:     /* 2 adj corners available */
        case 0x73f:     /* 2 adj corners available */
        case 0x7ee:     /* 2 adj corners available */
        case 0x7dd:     /* 2 adj corners available */
        case 0x7bb:     /* 2 adj corners available */
        case 0x777:     /* 2 adj corners available */
                goto out;
        /*
         * Handle the 3D cases where two existing edges meet at a corner.
         *
         */
        case 0x71f:
                success = handle_case_0x71f(t, i, j, k);
                break;
        case 0x72f:
                success = handle_case_0x72f(t, i, j, k);
                break;
        case 0x737:
                success = handle_case_0x737(t, i, j, k);
                break;
        case 0x73b:
                success = handle_case_0x73b(t, i, j, k);
                break;
        case 0x74f:
                success = handle_case_0x74f(t, i, j, k);
                break;
        case 0x757:
                success = handle_case_0x757(t, i, j, k);
                break;
        case 0x75d:
                success = handle_case_0x75d(t, i, j, k);
                break;
        case 0x773:
                success = handle_case_0x773(t, i, j, k);
                break;
        case 0x775:
                success = handle_case_0x775(t, i, j, k);
                break;
        case 0x78f:
                success = handle_case_0x78f(t, i, j, k);
                break;
        case 0x7ab:
                success = handle_case_0x7ab(t, i, j, k);
                break;
        case 0x7ae:
                success = handle_case_0x7ae(t, i, j, k);
                break;
        case 0x7b3:
                success = handle_case_0x7b3(t, i, j, k);
                break;
        case 0x7ba:
                success = handle_case_0x7ba(t, i, j, k);
                break;
        case 0x7cd:
                success = handle_case_0x7cd(t, i, j, k);
                break;
        case 0x7ce:
                success = handle_case_0x7ce(t, i, j, k);
                break;
        case 0x7d5:
                success = handle_case_0x7d5(t, i, j, k);
                break;
        case 0x7dc:
                success = handle_case_0x7dc(t, i, j, k);
                break;
        case 0x7ea:
                success = handle_case_0x7ea(t, i, j, k);
                break;
        case 0x7ec:
                success = handle_case_0x7ec(t, i, j, k);
                break;
        case 0x7f1:
                success = handle_case_0x7f1(t, i, j, k);
                break;
        case 0x7f2:
                success = handle_case_0x7f2(t, i, j, k);
                break;
        case 0x7f4:
                success = handle_case_0x7f4(t, i, j, k);
                break;
        case 0x7f8:
                success = handle_case_0x7f8(t, i, j, k);
                break;
        /*
         * Handle the cases where three existing edges meet at a corner.
         *
         */
        case 0x717:
                success = handle_case_0x717(t, i, j, k);
                break;
        case 0x72b:
                success = handle_case_0x72b(t, i, j, k);
                break;
        case 0x74d:
                success = handle_case_0x74d(t, i, j, k);
                break;
        case 0x771:
                success = handle_case_0x771(t, i, j, k);
                break;
        case 0x78e:
                success = handle_case_0x78e(t, i, j, k);
                break;
        case 0x7b2:
                success = handle_case_0x7b2(t, i, j, k);
                break;
        case 0x7d4:
                success = handle_case_0x7d4(t, i, j, k);
                break;
        case 0x7e8:
                success = handle_case_0x7e8(t, i, j, k);
                break;
        /*
         * Handle the cases where four corners on a single face are missing.
         */
        case 0x70f:
                success = handle_case_0x70f(t, i, j, k);
                break;
        case 0x733:
                success = handle_case_0x733(t, i, j, k);
                break;
        case 0x755:
                success = handle_case_0x755(t, i, j, k);
                break;
        case 0x7aa:
                success = handle_case_0x7aa(t, i, j, k);
                break;
        case 0x7cc:
                success = handle_case_0x7cc(t, i, j, k);
                break;
        case 0x7f0:
                success = handle_case_0x7f0(t, i, j, k);
                break;
        /*
         * Handle the cases where three corners on a single face are missing.
         */
        case 0x707:
                success = handle_case_0x707(t, i, j, k);
                break;
        case 0x70b:
                success = handle_case_0x70b(t, i, j, k);
                break;
        case 0x70d:
                success = handle_case_0x70d(t, i, j, k);
                break;
        case 0x70e:
                success = handle_case_0x70e(t, i, j, k);
                break;
        case 0x713:
                success = handle_case_0x713(t, i, j, k);
                break;
        case 0x715:
                success = handle_case_0x715(t, i, j, k);
                break;
        case 0x723:
                success = handle_case_0x723(t, i, j, k);
                break;
        case 0x72a:
                success = handle_case_0x72a(t, i, j, k);
                break;
        case 0x731:
                success = handle_case_0x731(t, i, j, k);
                break;
        case 0x732:
                success = handle_case_0x732(t, i, j, k);
                break;
        case 0x745:
                success = handle_case_0x745(t, i, j, k);
                break;
        case 0x74c:
                success = handle_case_0x74c(t, i, j, k);
                break;
        case 0x751:
                success = handle_case_0x751(t, i, j, k);
                break;
        case 0x754:
                success = handle_case_0x754(t, i, j, k);
                break;
        case 0x770:
                success = handle_case_0x770(t, i, j, k);
                break;
        case 0x78a:
                success = handle_case_0x78a(t, i, j, k);
                break;
        case 0x78c:
                success = handle_case_0x78c(t, i, j, k);
                break;
        case 0x7a2:
                success = handle_case_0x7a2(t, i, j, k);
                break;
        case 0x7a8:
                success = handle_case_0x7a8(t, i, j, k);
                break;
        case 0x7b0:
                success = handle_case_0x7b0(t, i, j, k);
                break;
        case 0x7c4:
                success = handle_case_0x7c4(t, i, j, k);
                break;
        case 0x7c8:
                success = handle_case_0x7c8(t, i, j, k);
                break;
        case 0x7d0:
                success = handle_case_0x7d0(t, i, j, k);
                break;
        case 0x7e0:
                success = handle_case_0x7e0(t, i, j, k);
                break;
        /*
         * Handle the cases where two corners on a single edge are missing.
         */
        case 0x703:
                success = handle_case_0x703(t, i, j, k);
                break;
        case 0x705:
                success = handle_case_0x705(t, i, j, k);
                break;
        case 0x70a:
                success = handle_case_0x70a(t, i, j, k);
                break;
        case 0x70c:
                success = handle_case_0x70c(t, i, j, k);
                break;
        case 0x711:
                success = handle_case_0x711(t, i, j, k);
                break;
        case 0x722:
                success = handle_case_0x722(t, i, j, k);
                break;
        case 0x730:
                success = handle_case_0x730(t, i, j, k);
                break;
        case 0x744:
                success = handle_case_0x744(t, i, j, k);
                break;
        case 0x750:
                success = handle_case_0x750(t, i, j, k);
                break;
        case 0x788:
                success = handle_case_0x788(t, i, j, k);
                break;
        case 0x7a0:
                success = handle_case_0x7a0(t, i, j, k);
                break;
        case 0x7c0:
                success = handle_case_0x7c0(t, i, j, k);
                break;
        /*
         * Handle the cases where a single corner is missing.
         */
        case 0x701:
                success = handle_case_0x701(t, i, j, k);
                break;
        case 0x702:
                success = handle_case_0x702(t, i, j, k);
                break;
        case 0x704:
                success = handle_case_0x704(t, i, j, k);
                break;
        case 0x708:
                success = handle_case_0x708(t, i, j, k);
                break;
        case 0x710:
                success = handle_case_0x710(t, i, j, k);
                break;
        case 0x720:
                success = handle_case_0x720(t, i, j, k);
                break;
        case 0x740:
                success = handle_case_0x740(t, i, j, k);
                break;
        case 0x780:
                success = handle_case_0x780(t, i, j, k);
                break;

        default:
                /*
                 * There's lots of unhandled cases still, but it's not clear
                 * we care.  Let debugging show us what they are so we can
                 * learn if we care.
                 */
                if (t->debug)
                        OSM_LOG(&t->osm->log, OSM_LOG_ERROR,
                                "Unhandled fingerprint 0x%03x @ %d %d %d\n",
                                fp, i, j, k);
                goto out;
        }
        /*
         * If we successfully handled a case, we may be able to make more
         * progress at this position, so try again.  Otherwise, even though
         * we didn't successfully handle a case, we may have installed a
         * switch into the torus/mesh, so try to install links as well.
         * Then we'll have another go at the next position.
         */
        if (success) {
                if (t->debug)
                        OSM_LOG(&t->osm->log, OSM_LOG_ERROR,
                                "Success on fingerprint 0x%03x @ %d %d %d\n",
                                fp, i, j, k);
                goto again;
        } else {
                check_tlinks(t, i, j, k);
                if (t->debug)
                        OSM_LOG(&t->osm->log, OSM_LOG_ERROR,
                                "Failed on fingerprint 0x%03x @ %d %d %d\n",
                                fp, i, j, k);
        }
out:
        return;
}

#define LINK_ERR_STR " direction link required for topology seed configuration since radix == 4! See torus-2QoS.conf(5).\n"
#define LINK_ERR2_STR " direction link required for topology seed configuration! See torus-2QoS.conf(5).\n"
#define SEED_ERR_STR " direction links for topology seed do not share a common switch! See torus-2QoS.conf(5).\n"

static
bool verify_setup(struct torus *t, struct fabric *f)
{
        struct coord_dirs *o;
        struct f_switch *sw;
        unsigned p, s, n = 0;
        bool success = false;
        bool all_sw_present, need_seed = true;

        if (!(t->x_sz && t->y_sz && t->z_sz)) {
                OSM_LOG(&t->osm->log, OSM_LOG_ERROR,
                        "ERR 4E20: missing required torus size specification!\n");
                goto out;
        }
        if (t->osm->subn.min_sw_data_vls < 2) {
                OSM_LOG(&t->osm->log, OSM_LOG_ERROR,
                        "ERR 4E48: Too few data VLs to support torus routing "
                        "without credit loops (have switchport %d need 2)\n",
                        (int)t->osm->subn.min_sw_data_vls);
                goto out;
        }
        if (t->osm->subn.min_sw_data_vls < 4)
                OSM_LOG(&t->osm->log, OSM_LOG_INFO,
                        "Warning: Too few data VLs to support torus routing "
                        "with a failed switch without credit loops "
                        "(have switchport %d need 4)\n",
                        (int)t->osm->subn.min_sw_data_vls);
        if (t->osm->subn.min_sw_data_vls < 8)
                OSM_LOG(&t->osm->log, OSM_LOG_INFO,
                        "Warning: Too few data VLs to support torus routing "
                        "with two QoS levels (have switchport %d need 8)\n",
                        (int)t->osm->subn.min_sw_data_vls);
        if (t->osm->subn.min_data_vls < 2)
                OSM_LOG(&t->osm->log, OSM_LOG_INFO,
                        "Warning: Too few data VLs to support torus routing "
                        "with two QoS levels (have endport %d need 2)\n",
                        (int)t->osm->subn.min_data_vls);
        /*
         * Be sure all the switches in the torus support the port
         * ordering that might have been configured.
         */
        for (s = 0; s < f->switch_cnt; s++) {
                sw = f->sw[s];
                for (p = 0; p < sw->port_cnt; p++) {
                        if (t->port_order[p] >= sw->port_cnt) {
                                OSM_LOG(&t->osm->log, OSM_LOG_ERROR,
                                        "ERR 4E21: port_order configured using "
                                        "port %u, but only %u ports in "
                                        "switch w/ GUID 0x%04"PRIx64"\n",
                                        t->port_order[p], sw->port_cnt - 1,
                                        cl_ntoh64(sw->n_id));
                                goto out;
                        }
                }
        }
        /*
         * Unfortunately, there is a problem with non-unique topology for any
         * torus dimension which has radix four.  This problem requires extra
         * input, in the form of specifying both the positive and negative
         * coordinate directions from a common switch, for any torus dimension
         * with radix four (see also build_torus()).
         *
         * Do the checking required to ensure that the required information
         * is present, but more than the needed information is not required.
         *
         * So, verify that we learned the coordinate directions correctly for
         * the fabric.  The coordinate direction links get an invalid port
         * set on their ends when parsed.
         */
again:
        all_sw_present = true;
        o = &t->seed[n];

        if (t->x_sz == 4 && !(t->flags & X_MESH)) {
                if (o->xp_link.end[0].port >= 0) {
                        OSM_LOG(&t->osm->log, OSM_LOG_ERROR,
                                "ERR 4E22: Positive x" LINK_ERR_STR);
                        goto out;
                }
                if (o->xm_link.end[0].port >= 0) {
                        OSM_LOG(&t->osm->log, OSM_LOG_ERROR,
                                "ERR 4E23: Negative x" LINK_ERR_STR);
                        goto out;
                }
                if (o->xp_link.end[0].n_id != o->xm_link.end[0].n_id) {
                        OSM_LOG(&t->osm->log, OSM_LOG_ERROR,
                                "ERR 4E24: Positive/negative x" SEED_ERR_STR);
                        goto out;
                }
        }
        if (t->y_sz == 4 && !(t->flags & Y_MESH)) {
                if (o->yp_link.end[0].port >= 0) {
                        OSM_LOG(&t->osm->log, OSM_LOG_ERROR,
                                "ERR 4E25: Positive y" LINK_ERR_STR);
                        goto out;
                }
                if (o->ym_link.end[0].port >= 0) {
                        OSM_LOG(&t->osm->log, OSM_LOG_ERROR,
                                "ERR 4E26: Negative y" LINK_ERR_STR);
                        goto out;
                }
                if (o->yp_link.end[0].n_id != o->ym_link.end[0].n_id) {
                        OSM_LOG(&t->osm->log, OSM_LOG_ERROR,
                                "ERR 4E27: Positive/negative y" SEED_ERR_STR);
                        goto out;
                }
        }
        if (t->z_sz == 4 && !(t->flags & Z_MESH)) {
                if (o->zp_link.end[0].port >= 0) {
                        OSM_LOG(&t->osm->log, OSM_LOG_ERROR,
                                "ERR 4E28: Positive z" LINK_ERR_STR);
                        goto out;
                }
                if (o->zm_link.end[0].port >= 0) {
                        OSM_LOG(&t->osm->log, OSM_LOG_ERROR,
                                "ERR 4E29: Negative z" LINK_ERR_STR);
                        goto out;
                }
                if (o->zp_link.end[0].n_id != o->zm_link.end[0].n_id) {
                        OSM_LOG(&t->osm->log, OSM_LOG_ERROR,
                                "ERR 4E2A: Positive/negative z" SEED_ERR_STR);
                        goto out;
                }
        }
        if (t->x_sz > 1) {
                if (o->xp_link.end[0].port >= 0 &&
                    o->xm_link.end[0].port >= 0) {
                        OSM_LOG(&t->osm->log, OSM_LOG_ERROR,
                                "ERR 4E2B: Positive or negative x" LINK_ERR2_STR);
                        goto out;
                }
                if (o->xp_link.end[0].port < 0 &&
                    !find_f_sw(f, o->xp_link.end[0].n_id))
                        all_sw_present = false;

                if (o->xp_link.end[1].port < 0 &&
                    !find_f_sw(f, o->xp_link.end[1].n_id))
                        all_sw_present = false;

                if (o->xm_link.end[0].port < 0 &&
                    !find_f_sw(f, o->xm_link.end[0].n_id))
                        all_sw_present = false;

                if (o->xm_link.end[1].port < 0 &&
                    !find_f_sw(f, o->xm_link.end[1].n_id))
                        all_sw_present = false;
        }
        if (t->z_sz > 1) {
                if (o->zp_link.end[0].port >= 0 &&
                    o->zm_link.end[0].port >= 0) {
                        OSM_LOG(&t->osm->log, OSM_LOG_ERROR,
                                "ERR 4E2C: Positive or negative z" LINK_ERR2_STR);
                        goto out;
                }
                if ((o->xp_link.end[0].port < 0 &&
                     o->zp_link.end[0].port < 0 &&
                     o->zp_link.end[0].n_id != o->xp_link.end[0].n_id) ||

                    (o->xp_link.end[0].port < 0 &&
                     o->zm_link.end[0].port < 0 &&
                     o->zm_link.end[0].n_id != o->xp_link.end[0].n_id) ||

                    (o->xm_link.end[0].port < 0 &&
                     o->zp_link.end[0].port < 0 &&
                     o->zp_link.end[0].n_id != o->xm_link.end[0].n_id) ||

                    (o->xm_link.end[0].port < 0 &&
                     o->zm_link.end[0].port < 0 &&
                     o->zm_link.end[0].n_id != o->xm_link.end[0].n_id)) {

                        OSM_LOG(&t->osm->log, OSM_LOG_ERROR,
                                "ERR 4E2D: x and z" SEED_ERR_STR);
                        goto out;
                }
                if (o->zp_link.end[0].port < 0 &&
                    !find_f_sw(f, o->zp_link.end[0].n_id))
                        all_sw_present = false;

                if (o->zp_link.end[1].port < 0 &&
                    !find_f_sw(f, o->zp_link.end[1].n_id))
                        all_sw_present = false;

                if (o->zm_link.end[0].port < 0 &&
                    !find_f_sw(f, o->zm_link.end[0].n_id))
                        all_sw_present = false;

                if (o->zm_link.end[1].port < 0 &&
                    !find_f_sw(f, o->zm_link.end[1].n_id))
                        all_sw_present = false;
        }
        if (t->y_sz > 1) {
                if (o->yp_link.end[0].port >= 0 &&
                    o->ym_link.end[0].port >= 0) {
                        OSM_LOG(&t->osm->log, OSM_LOG_ERROR,
                                "ERR 4E2E: Positive or negative y" LINK_ERR2_STR);
                        goto out;
                }
                if ((o->xp_link.end[0].port < 0 &&
                     o->yp_link.end[0].port < 0 &&
                     o->yp_link.end[0].n_id != o->xp_link.end[0].n_id) ||

                    (o->xp_link.end[0].port < 0 &&
                     o->ym_link.end[0].port < 0 &&
                     o->ym_link.end[0].n_id != o->xp_link.end[0].n_id) ||

                    (o->xm_link.end[0].port < 0 &&
                     o->yp_link.end[0].port < 0 &&
                     o->yp_link.end[0].n_id != o->xm_link.end[0].n_id) ||

                    (o->xm_link.end[0].port < 0 &&
                     o->ym_link.end[0].port < 0 &&
                     o->ym_link.end[0].n_id != o->xm_link.end[0].n_id)) {

                        OSM_LOG(&t->osm->log, OSM_LOG_ERROR,
                                "ERR 4E2F: x and y" SEED_ERR_STR);
                        goto out;
                }
                if (o->yp_link.end[0].port < 0 &&
                    !find_f_sw(f, o->yp_link.end[0].n_id))
                        all_sw_present = false;

                if (o->yp_link.end[1].port < 0 &&
                    !find_f_sw(f, o->yp_link.end[1].n_id))
                        all_sw_present = false;

                if (o->ym_link.end[0].port < 0 &&
                    !find_f_sw(f, o->ym_link.end[0].n_id))
                        all_sw_present = false;

                if (o->ym_link.end[1].port < 0 &&
                    !find_f_sw(f, o->ym_link.end[1].n_id))
                        all_sw_present = false;
        }
        if (all_sw_present && need_seed) {
                t->seed_idx = n;
                need_seed = false;
        }
        if (++n < t->seed_cnt)
                goto again;

        if (need_seed)
                OSM_LOG(&t->osm->log, OSM_LOG_ERROR,
                        "ERR 4E30: Every configured torus seed has at "
                        "least one switch missing in fabric! See "
                        "torus-2QoS.conf(5) and TORUS TOPOLOGY DISCOVERY "
                        "in torus-2QoS(8)\n");
        else
                success = true;
out:
        return success;
}

static
bool build_torus(struct fabric *f, struct torus *t)
{
        int i, j, k;
        int im1, jm1, km1;
        int ip1, jp1, kp1;
        unsigned nlink;
        struct coord_dirs *o;
        struct f_switch *fsw0, *fsw1;
        struct t_switch ****sw = t->sw;
        bool success = true;

        t->link_pool_sz = f->link_cnt;
        t->link_pool = calloc(1, t->link_pool_sz * sizeof(*t->link_pool));
        if (!t->link_pool) {
                OSM_LOG(&t->osm->log, OSM_LOG_ERROR,
                        "ERR 4E31: Allocating torus link pool: %s\n",
                        strerror(errno));
                goto out;
        }
        t->fabric = f;

        /*
         * Get things started by locating the up to seven switches that
         * define the torus "seed", coordinate directions, and datelines.
         */
        o = &t->seed[t->seed_idx];

        i = canonicalize(-o->x_dateline, t->x_sz);
        j = canonicalize(-o->y_dateline, t->y_sz);
        k = canonicalize(-o->z_dateline, t->z_sz);

        if (o->xp_link.end[0].port < 0) {
                ip1 = canonicalize(1 - o->x_dateline, t->x_sz);
                fsw0 = find_f_sw(f, o->xp_link.end[0].n_id);
                fsw1 = find_f_sw(f, o->xp_link.end[1].n_id);
                success =
                        install_tswitch(t, i, j, k, fsw0) &&
                        install_tswitch(t, ip1, j, k, fsw1) && success;
        }
        if (o->xm_link.end[0].port < 0) {
                im1 = canonicalize(-1 - o->x_dateline, t->x_sz);
                fsw0 = find_f_sw(f, o->xm_link.end[0].n_id);
                fsw1 = find_f_sw(f, o->xm_link.end[1].n_id);
                success =
                        install_tswitch(t, i, j, k, fsw0) &&
                        install_tswitch(t, im1, j, k, fsw1) && success;
        }
        if (o->yp_link.end[0].port < 0) {
                jp1 = canonicalize(1 - o->y_dateline, t->y_sz);
                fsw0 = find_f_sw(f, o->yp_link.end[0].n_id);
                fsw1 = find_f_sw(f, o->yp_link.end[1].n_id);
                success =
                        install_tswitch(t, i, j, k, fsw0) &&
                        install_tswitch(t, i, jp1, k, fsw1) && success;
        }
        if (o->ym_link.end[0].port < 0) {
                jm1 = canonicalize(-1 - o->y_dateline, t->y_sz);
                fsw0 = find_f_sw(f, o->ym_link.end[0].n_id);
                fsw1 = find_f_sw(f, o->ym_link.end[1].n_id);
                success =
                        install_tswitch(t, i, j, k, fsw0) &&
                        install_tswitch(t, i, jm1, k, fsw1) && success;
        }
        if (o->zp_link.end[0].port < 0) {
                kp1 = canonicalize(1 - o->z_dateline, t->z_sz);
                fsw0 = find_f_sw(f, o->zp_link.end[0].n_id);
                fsw1 = find_f_sw(f, o->zp_link.end[1].n_id);
                success =
                        install_tswitch(t, i, j, k, fsw0) &&
                        install_tswitch(t, i, j, kp1, fsw1) && success;
        }
        if (o->zm_link.end[0].port < 0) {
                km1 = canonicalize(-1 - o->z_dateline, t->z_sz);
                fsw0 = find_f_sw(f, o->zm_link.end[0].n_id);
                fsw1 = find_f_sw(f, o->zm_link.end[1].n_id);
                success =
                        install_tswitch(t, i, j, k, fsw0) &&
                        install_tswitch(t, i, j, km1, fsw1) && success;
        }
        if (!success)
                goto out;

        if (!t->seed_idx)
                OSM_LOG(&t->osm->log, OSM_LOG_INFO,
                        "Using torus seed configured as default "
                        "(seed sw %d,%d,%d GUID 0x%04"PRIx64").\n",
                        i, j, k, cl_ntoh64(sw[i][j][k]->n_id));
        else
                OSM_LOG(&t->osm->log, OSM_LOG_INFO,
                        "Using torus seed configured as backup #%u "
                        "(seed sw %d,%d,%d GUID 0x%04"PRIx64").\n",
                        t->seed_idx, i, j, k, cl_ntoh64(sw[i][j][k]->n_id));

        /*
         * Search the fabric and construct the expected torus topology.
         *
         * The algorithm is to consider the "cube" formed by eight switch
         * locations bounded by the corners i, j, k and i+1, j+1, k+1.
         * For each such cube look at the topology of the switches already
         * placed in the torus, and deduce which new switches can be placed
         * into their proper locations in the torus.  Examine each cube
         * multiple times, until the number of links moved into the torus
         * topology does not change.
         */
again:
        nlink = t->link_cnt;

        for (k = 0; k < (int)t->z_sz; k++)
                for (j = 0; j < (int)t->y_sz; j++)
                        for (i = 0; i < (int)t->x_sz; i++)
                                locate_sw(t, i, j, k);

        if (t->link_cnt != nlink)
                goto again;

        /*
         * Move all other endpoints into torus/mesh.
         */
        for (k = 0; k < (int)t->z_sz; k++)
                for (j = 0; j < (int)t->y_sz; j++)
                        for (i = 0; i < (int)t->x_sz; i++)
                                if (!link_srcsink(t, i, j, k)) {
                                        success = false;
                                        goto out;
                                }
out:
        return success;
}

/*
 * Returns a count of differences between old and new switches.
 */
static
unsigned tsw_changes(struct t_switch *nsw, struct t_switch *osw)
{
        unsigned p, cnt = 0, port_cnt;
        struct endpoint *npt, *opt;
        struct endpoint *rnpt, *ropt;

        if (nsw && !osw) {
                cnt++;
                OSM_LOG(&nsw->torus->osm->log, OSM_LOG_INFO,
                        "New torus switch %d,%d,%d GUID 0x%04"PRIx64"\n",
                        nsw->i, nsw->j, nsw->k, cl_ntoh64(nsw->n_id));
                goto out;
        }
        if (osw && !nsw) {
                cnt++;
                OSM_LOG(&osw->torus->osm->log, OSM_LOG_INFO,
                        "Lost torus switch %d,%d,%d GUID 0x%04"PRIx64"\n",
                        osw->i, osw->j, osw->k, cl_ntoh64(osw->n_id));
                goto out;
        }
        if (!(nsw && osw))
                goto out;

        if (nsw->n_id != osw->n_id) {
                cnt++;
                OSM_LOG(&nsw->torus->osm->log, OSM_LOG_INFO,
                        "Torus switch %d,%d,%d GUID "
                        "was 0x%04"PRIx64", now 0x%04"PRIx64"\n",
                        nsw->i, nsw->j, nsw->k,
                        cl_ntoh64(osw->n_id), cl_ntoh64(nsw->n_id));
        }

        if (nsw->port_cnt != osw->port_cnt) {
                cnt++;
                OSM_LOG(&nsw->torus->osm->log, OSM_LOG_INFO,
                        "Torus switch %d,%d,%d GUID 0x%04"PRIx64" "
                        "had %d ports, now has %d\n",
                        nsw->i, nsw->j, nsw->k, cl_ntoh64(nsw->n_id),
                        osw->port_cnt, nsw->port_cnt);
        }
        port_cnt = nsw->port_cnt;
        if (port_cnt > osw->port_cnt)
                port_cnt = osw->port_cnt;

        for (p = 0; p < port_cnt; p++) {
                npt = nsw->port[p];
                opt = osw->port[p];

                if (npt && npt->link) {
                        if (&npt->link->end[0] == npt)
                                rnpt = &npt->link->end[1];
                        else
                                rnpt = &npt->link->end[0];
                } else
                        rnpt = NULL;

                if (opt && opt->link) {
                        if (&opt->link->end[0] == opt)
                                ropt = &opt->link->end[1];
                        else
                                ropt = &opt->link->end[0];
                } else
                        ropt = NULL;

                if (rnpt && !ropt) {
                        ++cnt;
                        OSM_LOG(&nsw->torus->osm->log, OSM_LOG_INFO,
                                "Torus switch %d,%d,%d GUID 0x%04"PRIx64"[%d] "
                                "remote now %s GUID 0x%04"PRIx64"[%d], "
                                "was missing\n",
                                nsw->i, nsw->j, nsw->k, cl_ntoh64(nsw->n_id),
                                p, rnpt->type == PASSTHRU ? "sw" : "node",
                                cl_ntoh64(rnpt->n_id), rnpt->port);
                        continue;
                }
                if (ropt && !rnpt) {
                        ++cnt;
                        OSM_LOG(&nsw->torus->osm->log, OSM_LOG_INFO,
                                "Torus switch %d,%d,%d GUID 0x%04"PRIx64"[%d] "
                                "remote now missing, "
                                "was %s GUID 0x%04"PRIx64"[%d]\n",
                                osw->i, osw->j, osw->k, cl_ntoh64(nsw->n_id),
                                p, ropt->type == PASSTHRU ? "sw" : "node",
                                cl_ntoh64(ropt->n_id), ropt->port);
                        continue;
                }
                if (!(rnpt && ropt))
                        continue;

                if (rnpt->n_id != ropt->n_id) {
                        ++cnt;
                        OSM_LOG(&nsw->torus->osm->log, OSM_LOG_INFO,
                                "Torus switch %d,%d,%d GUID 0x%04"PRIx64"[%d] "
                                "remote now %s GUID 0x%04"PRIx64"[%d], "
                                "was %s GUID 0x%04"PRIx64"[%d]\n",
                                nsw->i, nsw->j, nsw->k, cl_ntoh64(nsw->n_id),
                                p, rnpt->type == PASSTHRU ? "sw" : "node",
                                cl_ntoh64(rnpt->n_id), rnpt->port,
                                ropt->type == PASSTHRU ? "sw" : "node",
                                cl_ntoh64(ropt->n_id), ropt->port);
                        continue;
                }
        }
out:
        return cnt;
}

static
void dump_torus(struct torus *t)
{
        unsigned i, j, k;
        unsigned x_sz = t->x_sz;
        unsigned y_sz = t->y_sz;
        unsigned z_sz = t->z_sz;
        char path[1024];
        FILE *file;

        snprintf(path, sizeof(path), "%s/%s", t->osm->subn.opt.dump_files_dir,
                 "opensm-torus.dump");
        file = fopen(path, "w");
        if (!file) {
                OSM_LOG(&t->osm->log, OSM_LOG_ERROR,
                        "ERR 4E47: cannot create file \'%s\'\n", path);
                return;
        }

        for (k = 0; k < z_sz; k++)
                for (j = 0; j < y_sz; j++)
                        for (i = 0; i < x_sz; i++)
                                if (t->sw[i][j][k])
                                        fprintf(file, "switch %u,%u,%u GUID 0x%04"
                                                PRIx64 " (%s)\n",
                                                i, j, k,
                                                cl_ntoh64(t->sw[i][j][k]->n_id),
                                                t->sw[i][j][k]->osm_switch->p_node->print_desc);
        fclose(file);
}

static
void report_torus_changes(struct torus *nt, struct torus *ot)
{
        unsigned cnt = 0;
        unsigned i, j, k;
        unsigned x_sz = nt->x_sz;
        unsigned y_sz = nt->y_sz;
        unsigned z_sz = nt->z_sz;
        unsigned max_changes = nt->max_changes;

        if (OSM_LOG_IS_ACTIVE_V2(&nt->osm->log, OSM_LOG_ROUTING))
                dump_torus(nt);

        if (!ot)
                return;

        if (x_sz != ot->x_sz) {
                cnt++;
                OSM_LOG(&nt->osm->log, OSM_LOG_INFO,
                        "Torus x radix was %d now %d\n",
                        ot->x_sz, nt->x_sz);
                if (x_sz > ot->x_sz)
                        x_sz = ot->x_sz;
        }
        if (y_sz != ot->y_sz) {
                cnt++;
                OSM_LOG(&nt->osm->log, OSM_LOG_INFO,
                        "Torus y radix was %d now %d\n",
                        ot->y_sz, nt->y_sz);
                if (y_sz > ot->y_sz)
                        y_sz = ot->y_sz;
        }
        if (z_sz != ot->z_sz) {
                cnt++;
                OSM_LOG(&nt->osm->log, OSM_LOG_INFO,
                        "Torus z radix was %d now %d\n",
                        ot->z_sz, nt->z_sz);
                if (z_sz > ot->z_sz)
                        z_sz = ot->z_sz;
        }

        for (k = 0; k < z_sz; k++)
                for (j = 0; j < y_sz; j++)
                        for (i = 0; i < x_sz; i++) {
                                cnt += tsw_changes(nt->sw[i][j][k],
                                                   ot->sw[i][j][k]);
                                /*
                                 * Booting a big fabric will cause lots of
                                 * changes as hosts come up, so don't spew.
                                 * We want to log changes to learn more about
                                 * bouncing links, etc, so they can be fixed.
                                 */
                                if (cnt > max_changes) {
                                        OSM_LOG(&nt->osm->log, OSM_LOG_INFO,
                                                "Too many torus changes; "
                                                "stopping reporting early\n");
                                        return;
                                }
                        }
}

static
void rpt_torus_missing(struct torus *t, int i, int j, int k,
                       struct t_switch *sw, int *missing_z)
{
        uint64_t guid_ho;

        if (!sw) {
                /*
                 * We can have multiple missing switches without deadlock
                 * if and only if they are adajacent in the Z direction.
                 */
                if ((t->switch_cnt + 1) < t->sw_pool_sz) {
                        if (t->sw[i][j][canonicalize(k - 1, t->z_sz)] &&
                            t->sw[i][j][canonicalize(k + 1, t->z_sz)])
                                t->flags |= MSG_DEADLOCK;
                }
                /*
                 * There can be only one such Z-column of missing switches.
                 */
                if (*missing_z < 0)
                        *missing_z = i + j * t->x_sz;
                else if (*missing_z != i + j * t->x_sz)
                        t->flags |= MSG_DEADLOCK;

                OSM_LOG(&t->osm->log, OSM_LOG_INFO,
                        "Missing torus switch at %d,%d,%d\n", i, j, k);
                return;
        }
        guid_ho = cl_ntoh64(sw->n_id);

        if (!(sw->ptgrp[0].port_cnt || (t->x_sz == 1) ||
              ((t->flags & X_MESH) && i == 0)))
                OSM_LOG(&t->osm->log, OSM_LOG_INFO,
                        "Missing torus -x link on "
                        "switch %d,%d,%d GUID 0x%04"PRIx64"\n",
                        i, j, k, guid_ho);
        if (!(sw->ptgrp[1].port_cnt || (t->x_sz == 1) ||
              ((t->flags & X_MESH) && (i + 1) == t->x_sz)))
                OSM_LOG(&t->osm->log, OSM_LOG_INFO,
                        "Missing torus +x link on "
                        "switch %d,%d,%d GUID 0x%04"PRIx64"\n",
                        i, j, k, guid_ho);
        if (!(sw->ptgrp[2].port_cnt || (t->y_sz == 1) ||
              ((t->flags & Y_MESH) && j == 0)))
                OSM_LOG(&t->osm->log, OSM_LOG_INFO,
                        "Missing torus -y link on "
                        "switch %d,%d,%d GUID 0x%04"PRIx64"\n",
                        i, j, k, guid_ho);
        if (!(sw->ptgrp[3].port_cnt || (t->y_sz == 1) ||
              ((t->flags & Y_MESH) && (j + 1) == t->y_sz)))
                OSM_LOG(&t->osm->log, OSM_LOG_INFO,
                        "Missing torus +y link on "
                        "switch %d,%d,%d GUID 0x%04"PRIx64"\n",
                        i, j, k, guid_ho);
        if (!(sw->ptgrp[4].port_cnt || (t->z_sz == 1) ||
              ((t->flags & Z_MESH) && k == 0)))
                OSM_LOG(&t->osm->log, OSM_LOG_INFO,
                        "Missing torus -z link on "
                        "switch %d,%d,%d GUID 0x%04"PRIx64"\n",
                        i, j, k, guid_ho);
        if (!(sw->ptgrp[5].port_cnt || (t->z_sz == 1) ||
              ((t->flags & Z_MESH) && (k + 1) == t->z_sz)))
                OSM_LOG(&t->osm->log, OSM_LOG_INFO,
                        "Missing torus +z link on "
                        "switch %d,%d,%d GUID 0x%04"PRIx64"\n",
                        i, j, k, guid_ho);
}

/*
 * Returns true if the torus can be successfully routed, false otherwise.
 */
static
bool routable_torus(struct torus *t, struct fabric *f)
{
        int i, j, k, tmp = -1;
        unsigned b2g_cnt, g2b_cnt;
        bool success = true;

        t->flags &= ~MSG_DEADLOCK;

        if (t->link_cnt != f->link_cnt || t->switch_cnt != f->switch_cnt)
                OSM_LOG(&t->osm->log, OSM_LOG_INFO,
                        "Warning: Could not construct torus using all "
                        "known fabric switches and/or links.\n");

        for (k = 0; k < (int)t->z_sz; k++)
                for (j = 0; j < (int)t->y_sz; j++)
                        for (i = 0; i < (int)t->x_sz; i++)
                                rpt_torus_missing(t, i, j, k,
                                                  t->sw[i][j][k], &tmp);
        /*
         * Check for multiple failures that create disjoint regions on a ring.
         */
        for (k = 0; k < (int)t->z_sz; k++)
                for (j = 0; j < (int)t->y_sz; j++) {
                        b2g_cnt = 0;
                        g2b_cnt = 0;
                        for (i = 0; i < (int)t->x_sz; i++) {

                                if (!t->sw[i][j][k])
                                        continue;

                                if (!t->sw[i][j][k]->ptgrp[0].port_cnt)
                                        b2g_cnt++;
                                if (!t->sw[i][j][k]->ptgrp[1].port_cnt)
                                        g2b_cnt++;
                        }
                        if (b2g_cnt != g2b_cnt) {
                                OSM_LOG(&t->osm->log, OSM_LOG_ERROR,
                                        "ERR 4E32: strange failures in "
                                        "x ring at y=%d  z=%d"
                                        " b2g_cnt %u g2b_cnt %u\n",
                                        j, k, b2g_cnt, g2b_cnt);
                                success = false;
                        }
                        if (b2g_cnt > 1) {
                                OSM_LOG(&t->osm->log, OSM_LOG_ERROR,
                                        "ERR 4E33: disjoint failures in "
                                        "x ring at y=%d  z=%d\n", j, k);
                                success = false;
                        }
                }

        for (i = 0; i < (int)t->x_sz; i++)
                for (k = 0; k < (int)t->z_sz; k++) {
                        b2g_cnt = 0;
                        g2b_cnt = 0;
                        for (j = 0; j < (int)t->y_sz; j++) {

                                if (!t->sw[i][j][k])
                                        continue;

                                if (!t->sw[i][j][k]->ptgrp[2].port_cnt)
                                        b2g_cnt++;
                                if (!t->sw[i][j][k]->ptgrp[3].port_cnt)
                                        g2b_cnt++;
                        }
                        if (b2g_cnt != g2b_cnt) {
                                OSM_LOG(&t->osm->log, OSM_LOG_ERROR,
                                        "ERR 4E34: strange failures in "
                                        "y ring at x=%d  z=%d"
                                        " b2g_cnt %u g2b_cnt %u\n",
                                        i, k, b2g_cnt, g2b_cnt);
                                success = false;
                        }
                        if (b2g_cnt > 1) {
                                OSM_LOG(&t->osm->log, OSM_LOG_ERROR,
                                        "ERR 4E35: disjoint failures in "
                                        "y ring at x=%d  z=%d\n", i, k);
                                success = false;
                        }
                }

        for (j = 0; j < (int)t->y_sz; j++)
                for (i = 0; i < (int)t->x_sz; i++) {
                        b2g_cnt = 0;
                        g2b_cnt = 0;
                        for (k = 0; k < (int)t->z_sz; k++) {

                                if (!t->sw[i][j][k])
                                        continue;

                                if (!t->sw[i][j][k]->ptgrp[4].port_cnt)
                                        b2g_cnt++;
                                if (!t->sw[i][j][k]->ptgrp[5].port_cnt)
                                        g2b_cnt++;
                        }
                        if (b2g_cnt != g2b_cnt) {
                                OSM_LOG(&t->osm->log, OSM_LOG_ERROR,
                                        "ERR 4E36: strange failures in "
                                        "z ring at x=%d  y=%d"
                                        " b2g_cnt %u g2b_cnt %u\n",
                                        i, j, b2g_cnt, g2b_cnt);
                                success = false;
                        }
                        if (b2g_cnt > 1) {
                                OSM_LOG(&t->osm->log, OSM_LOG_ERROR,
                                        "ERR 4E37: disjoint failures in "
                                        "z ring at x=%d  y=%d\n", i, j);
                                success = false;
                        }
                }

        if (t->flags & MSG_DEADLOCK) {
                OSM_LOG(&t->osm->log, OSM_LOG_ERROR,
                        "ERR 4E38: missing switch topology "
                        "==> message deadlock!\n");
                success = false;
        }
        return success;
}

/*
 * Use this function to re-establish the pointers between a torus endpoint
 * and an opensm osm_port_t.
 *
 * Typically this is only needed when "opensm --ucast-cache" is used, and
 * a CA link bounces.  When the CA port goes away, the osm_port_t object
 * is destroyed, invalidating the endpoint osm_port_t pointer.  When the
 * link comes back, a new osm_port_t object is created with a NULL priv
 * member.  Thus, when osm_get_torus_sl() is called it is missing the data
 * needed to do its work.  Use this function to fix things up.
 */
static
struct endpoint *osm_port_relink_endpoint(const osm_port_t *osm_port)
{
        guid_t node_guid;
        uint8_t port_num, r_port_num;
        struct t_switch *sw;
        struct endpoint *ep = NULL;
        osm_switch_t *osm_sw;
        osm_physp_t *osm_physp;
        osm_node_t *osm_node, *r_osm_node;

        /*
         * We need to find the torus endpoint that has the same GUID as
         * the osm_port.  Rather than search the entire set of endpoints,
         * we'll try to follow pointers.
         */
        osm_physp = osm_port->p_physp;
        osm_node = osm_port->p_node;
        port_num = osm_physp_get_port_num(osm_physp);
        node_guid = osm_node_get_node_guid(osm_node);
        /*
         * Switch management port?
         */
        if (port_num == 0 &&
            osm_node_get_type(osm_node) == IB_NODE_TYPE_SWITCH) {

                osm_sw = osm_node->sw;
                if (osm_sw && osm_sw->priv) {
                        sw = osm_sw->priv;
                        if (sw->osm_switch == osm_sw &&
                            sw->port[0]->n_id == node_guid) {

                                ep = sw->port[0];
                                goto relink_priv;
                        }
                }
        }
        /*
         * CA port?  Try other end of link.  This should also catch a
         * router port if it is connected to a switch.
         */
        r_osm_node = osm_node_get_remote_node(osm_node, port_num, &r_port_num);
        if (!r_osm_node)
                goto out;

        osm_sw = r_osm_node->sw;
        if (!osm_sw)
                goto out;

        sw = osm_sw->priv;
        if (!(sw && sw->osm_switch == osm_sw))
                goto out;

        ep = sw->port[r_port_num];
        if (!(ep && ep->link))
                goto out;

        if (ep->link->end[0].n_id == node_guid) {
                ep = &ep->link->end[0];
                goto relink_priv;
        }
        if (ep->link->end[1].n_id == node_guid) {
                ep = &ep->link->end[1];
                goto relink_priv;
        }
        ep = NULL;
        goto out;

relink_priv:
        /* FIXME:
         * Unfortunately, we need to cast away const to rebuild the links
         * between the torus endpoint and the osm_port_t.
         *
         * What is really needed is to check whether pr_rcv_get_path_parms()
         * needs its port objects to be const.  If so, why, and whether
         * anything can be done about it.
         */
        ((osm_port_t *)osm_port)->priv = ep;
        ep->osm_port = (osm_port_t *)osm_port;
out:
        return ep;
}

/*
 * Computing LFT entries and path SL values:
 *
 * For a pristine torus, we compute LFT entries using XYZ DOR, and select
 * which direction to route on a ring (i.e., the 1-D torus for the coordinate
 * in question) based on shortest path.  We compute the SL to use for the
 * path based on whether we crossed a dateline (where a ring coordinate
 * wraps to zero) for each coordinate.
 *
 * When there is a link/switch failure, we want to compute LFT entries
 * to route around the failure, without changing the path SL.  I.e., we
 * want the SL to reach a given destination from a given source to be
 * independent of the presence or number of failed components in the fabric.
 *
 * In order to make this feasible, we will assume that no ring is broken
 * into disjoint pieces by multiple failures
 *
 * We handle failure by attempting to take the long way around any ring
 * with connectivity interrupted by failed components, unless the path
 * requires a turn on a failed switch.
 *
 * For paths that require a turn on a failed switch, we head towards the
 * failed switch, then turn when progress is blocked by a failure, using a
 * turn allowed under XYZ DOR.  However, such a path will also require a turn
 * that is not a legal XYZ DOR turn, so we construct the SL2VL mapping tables
 * such that XYZ DOR turns use one set of VLs and ZYX DOR turns use a
 * separate set of VLs.
 *
 * Under these rules the algorithm guarantees credit-loop-free routing for a
 * single failed switch, without any change in path SL values.  We can also
 * guarantee credit-loop-free routing for failures of multiple switches, if
 * they are adjacent in the last DOR direction.  Since we use XYZ-DOR,
 * that means failed switches at i,j,k and i,j,k+1 will not cause credit
 * loops.
 *
 * These failure routing rules are intended to prevent paths that cross any
 * coordinate dateline twice (over and back), so we don't need to worry about
 * any ambiguity over which SL to use for such a case.  Also, we cannot have
 * a ring deadlock when a ring is broken by failure and we route the long
 * way around, so we don't need to worry about the impact of such routing
 * on SL choice.
 */

/*
 * Functions to set our SL bit encoding for routing/QoS info.  Combine the
 * resuts of these functions with bitwise or to get final SL.
 *
 * SL bits 0-2 encode whether we "looped" in a given direction
 * on the torus on the path from source to destination.
 *
 * SL bit 3 encodes the QoS level.  We only support two QoS levels.
 *
 * Below we assume TORUS_MAX_DIM == 3 and 0 <= coord_dir < TORUS_MAX_DIM.
 */
static inline
unsigned sl_set_use_loop_vl(bool use_loop_vl, unsigned coord_dir)
{
        return (coord_dir < TORUS_MAX_DIM)
                ? ((unsigned)use_loop_vl << coord_dir) : 0;
}

static inline
unsigned sl_set_qos(unsigned qos)
{
        return (unsigned)(!!qos) << TORUS_MAX_DIM;
}

/*
 * Functions to crack our SL bit encoding for routing/QoS info.
 */
static inline
bool sl_get_use_loop_vl(unsigned sl, unsigned coord_dir)
{
        return (coord_dir < TORUS_MAX_DIM)
                ? (sl >> coord_dir) & 0x1 : false;
}

static inline
unsigned sl_get_qos(unsigned sl)
{
        return (sl >> TORUS_MAX_DIM) & 0x1;
}

/*
 * Functions to encode routing/QoS info into VL bits.  Combine the resuts of
 * these functions with bitwise or to get final VL.
 *
 * For interswitch links:
 * VL bit 0 encodes whether we need to leave on the "loop" VL.
 *
 * VL bit 1 encodes whether turn is XYZ DOR or ZYX DOR. A 3d mesh/torus
 * has 6 turn types: x-y, y-z, x-z, y-x, z-y, z-x.  The first three are
 * legal XYZ DOR turns, and the second three are legal ZYX DOR turns.
 * Straight-through (x-x, y-y, z-z) paths are legal in both DOR variants,
 * so we'll assign them to XYZ DOR VLs.
 *
 * Note that delivery to switch-local ports (i.e. those that source/sink
 * traffic, rather than forwarding it) cannot cause a deadlock, so that
 * can also use either XYZ or ZYX DOR.
 *
 * VL bit 2 encodes QoS level.
 *
 * For end port links:
 * VL bit 0 encodes QoS level.
 *
 * Note that if VL bit encodings are changed here, the available fabric VL
 * verification in verify_setup() needs to be updated as well.
 */
static inline
unsigned vl_set_loop_vl(bool use_loop_vl)
{
        return use_loop_vl;
}

static inline
unsigned vl_set_qos_vl(unsigned qos)
{
        return (qos & 0x1) << 2;
}

static inline
unsigned vl_set_ca_qos_vl(unsigned qos)
{
        return qos & 0x1;
}

static inline
unsigned vl_set_turn_vl(unsigned in_coord_dir, unsigned out_coord_dir)
{
        unsigned vl = 0;

        if (in_coord_dir != TORUS_MAX_DIM &&
            out_coord_dir != TORUS_MAX_DIM)
                vl = (in_coord_dir > out_coord_dir)
                        ? 0x1 << 1 : 0;

        return vl;
}

static
unsigned sl2vl_entry(struct torus *t, struct t_switch *sw,
                     int input_pt, int output_pt, unsigned sl)
{
        unsigned id, od, vl, data_vls;

        if (sw && sw->port[input_pt])
                id = sw->port[input_pt]->pgrp->port_grp / 2;
        else
                id = TORUS_MAX_DIM;

        if (sw && sw->port[output_pt])
                od = sw->port[output_pt]->pgrp->port_grp / 2;
        else
                od = TORUS_MAX_DIM;

        if (sw)
                data_vls = t->osm->subn.min_sw_data_vls;
        else
                data_vls = t->osm->subn.min_data_vls;

        vl = 0;
        if (sw && od != TORUS_MAX_DIM) {
                if (data_vls >= 2)
                        vl |= vl_set_loop_vl(sl_get_use_loop_vl(sl, od));
                if (data_vls >= 4)
                        vl |= vl_set_turn_vl(id, od);
                if (data_vls >= 8)
                        vl |= vl_set_qos_vl(sl_get_qos(sl));
        } else {
                if (data_vls >= 2)
                        vl |= vl_set_ca_qos_vl(sl_get_qos(sl));
        }
        return vl;
}

static
void torus_update_osm_sl2vl(void *context, osm_physp_t *osm_phys_port,
                            uint8_t iport_num, uint8_t oport_num,
                            ib_slvl_table_t *osm_oport_sl2vl)
{
        osm_node_t *node = osm_physp_get_node_ptr(osm_phys_port);
        struct torus_context *ctx = context;
        struct t_switch *sw = NULL;
        int sl, vl;

        if (node->sw) {
                sw = node->sw->priv;
                if (sw && sw->osm_switch != node->sw) {
                        osm_log_t *log = &ctx->osm->log;
                        guid_t guid;

                        guid = osm_node_get_node_guid(node);
                        OSM_LOG(log, OSM_LOG_INFO,
                                "Note: osm_switch (GUID 0x%04"PRIx64") "
                                "not in torus fabric description\n",
                                cl_ntoh64(guid));
                        return;
                }
        }
        for (sl = 0; sl < 16; sl++) {
                vl = sl2vl_entry(ctx->torus, sw, iport_num, oport_num, sl);
                ib_slvl_table_set(osm_oport_sl2vl, sl, vl);
        }
}

static
void torus_update_osm_vlarb(void *context, osm_physp_t *osm_phys_port,
                            uint8_t port_num, ib_vl_arb_table_t *block,
                            unsigned block_length, unsigned block_num)
{
        osm_node_t *node = osm_physp_get_node_ptr(osm_phys_port);
        struct torus_context *ctx = context;
        struct t_switch *sw = NULL;
        unsigned i, next;

        if (node->sw) {
                sw = node->sw->priv;
                if (sw && sw->osm_switch != node->sw) {
                        osm_log_t *log = &ctx->osm->log;
                        guid_t guid;

                        guid = osm_node_get_node_guid(node);
                        OSM_LOG(log, OSM_LOG_INFO,
                                "Note: osm_switch (GUID 0x%04"PRIx64") "
                                "not in torus fabric description\n",
                                cl_ntoh64(guid));
                        return;
                }
        }

        /*
         * If osm_phys_port is a switch port that connects to a CA, then
         * we're using at most VL 0 (for QoS level 0) and VL 1 (for QoS
         * level 1).  We've been passed the VLarb values for a switch
         * external port, so we need to fix them up to avoid unexpected
         * results depending on how the switch handles VLarb values for
         * unprogrammed VLs.
         *
         * For inter-switch links torus-2QoS uses VLs 0-3 to implement
         * QoS level 0, and VLs 4-7 to implement QoS level 1.
         *
         * So, leave VL 0 alone, remap VL 4 to VL 1, zero out the rest,
         * and compress out the zero entries to the end.
         */
        if (!sw || !port_num || !sw->port[port_num] ||
            sw->port[port_num]->pgrp->port_grp != 2 * TORUS_MAX_DIM)
                return;

        next = 0;
        for (i = 0; i < block_length; i++) {
                switch (block->vl_entry[i].vl) {
                case 4:
                        block->vl_entry[i].vl = 1;
                        /* fall through */
                case 0:
                        block->vl_entry[next].vl = block->vl_entry[i].vl;
                        block->vl_entry[next].weight = block->vl_entry[i].weight;
                        next++;
                        /*
                         * If we didn't update vl_entry[i] in place,
                         * fall through to zero it out.
                         */
                        if (next > i)
                                break;
                default:
                        block->vl_entry[i].vl = 0;
                        block->vl_entry[i].weight = 0;
                        break;
                }
        }
}

/*
 * Computes the path lengths *vl0_len and *vl1_len to get from src
 * to dst on a ring with count switches.
 *
 * *vl0_len is the path length for a direct path; it corresponds to a path
 * that should be assigned to use VL0 in a switch.  *vl1_len is the path
 * length for a path that wraps aroung the ring, i.e. where the ring index
 * goes from count to zero or from zero to count.  It corresponds to the path
 * that should be assigned to use VL1 in a switch.
 */
static
void get_pathlen(unsigned src, unsigned dst, unsigned count,
                 unsigned *vl0_len, unsigned *vl1_len)
{
        unsigned s, l;          /* assume s < l */

        if (dst > src) {
                s = src;
                l = dst;
        } else {
                s = dst;
                l = src;
        }
        *vl0_len = l - s;
        *vl1_len = s + count - l;
}

/*
 * Returns a positive number if we should take the "positive" ring direction
 * to reach dst from src, a negative number if we should take the "negative"
 * ring direction, and 0 if src and dst are the same.  The choice is strictly
 * based on which path is shorter.
 */
static
int ring_dir_idx(unsigned src, unsigned dst, unsigned count)
{
        int r;
        unsigned vl0_len, vl1_len;

        if (dst == src)
                return 0;

        get_pathlen(src, dst, count, &vl0_len, &vl1_len);

        if (dst > src)
                r = vl0_len <= vl1_len ? 1 : -1;
        else
                r = vl0_len <= vl1_len ? -1 : 1;

        return r;
}

/*
 * Returns true if the VL1 path should be used to reach src from dst on a
 * ring, based on which path is shorter.
 */
static
bool use_vl1(unsigned src, unsigned dst, unsigned count)
{
        unsigned vl0_len, vl1_len;

        get_pathlen(src, dst, count, &vl0_len, &vl1_len);

        return vl0_len <= vl1_len ? false : true;
}

/*
 * Returns the next switch in the ring of switches along coordinate direction
 * cdir, in the positive ring direction if rdir is positive, and in the
 * negative ring direction if rdir is negative.
 *
 * Returns NULL if rdir is zero, or there is no next switch.
 */
static
struct t_switch *ring_next_sw(struct t_switch *sw, unsigned cdir, int rdir)
{
        unsigned pt_grp, far_end = 0;

        if (!rdir)
                return NULL;
        /*
         * Recall that links are installed into the torus so that their 1 end
         * is in the "positive" coordinate direction relative to their 0 end
         * (see link_tswitches() and connect_tlink()).  Recall also that for
         * interswitch links, all links in a given switch port group have the
         * same endpoints, so we just need to look at the first link.
         */
        pt_grp = 2 * cdir;
        if (rdir > 0) {
                pt_grp++;
                far_end = 1;
        }

        if (!sw->ptgrp[pt_grp].port_cnt)
                return NULL;

        return sw->ptgrp[pt_grp].port[0]->link->end[far_end].sw;
}

/*
 * Returns a positive number if we should take the "positive" ring direction
 * to reach dsw from ssw, a negative number if we should take the "negative"
 * ring direction, and 0 if src and dst are the same, or if dsw is not
 * reachable from ssw because the path is interrupted by failure.
 */
static
int ring_dir_path(struct torus *t, unsigned cdir,
                  struct t_switch *ssw, struct t_switch *dsw)
{
        int d = 0;
        struct t_switch *sw;

        switch (cdir) {
        case 0:
                d = ring_dir_idx(ssw->i, dsw->i, t->x_sz);
                break;
        case 1:
                d = ring_dir_idx(ssw->j, dsw->j, t->y_sz);
                break;
        case 2:
                d = ring_dir_idx(ssw->k, dsw->k, t->z_sz);
                break;
        default:
                break;
        }
        if (!d)
                goto out;

        sw = ssw;
        while (sw) {
                sw = ring_next_sw(sw, cdir, d);
                if (sw == dsw)
                        goto out;
        }
        d *= -1;
        sw = ssw;
        while (sw) {
                sw = ring_next_sw(sw, cdir, d);
                if (sw == dsw)
                        goto out;
        }
        d = 0;
out:
        return d;
}

/*
 * Returns true, and sets *pt_grp to the port group index to use for the
 * next hop, if it is possible to make progress from ssw to dsw along the
 * coordinate direction cdir, taking into account whether there are
 * interruptions in the path.
 *
 * This next hop result can be used without worrying about ring deadlocks -
 * if we don't choose the shortest path it is because there is a failure in
 * the ring, which removes the possibilility of a ring deadlock on that ring.
 */
static
bool next_hop_path(struct torus *t, unsigned cdir,
                   struct t_switch *ssw, struct t_switch *dsw,
                   unsigned *pt_grp)
{
        struct t_switch *tsw = NULL;
        bool success = false;
        int d;

        /*
         * If the path from ssw to dsw turns, this is the switch where the
         * turn happens.
         */
        switch (cdir) {
        case 0:
                tsw = t->sw[dsw->i][ssw->j][ssw->k];
                break;
        case 1:
                tsw = t->sw[ssw->i][dsw->j][ssw->k];
                break;
        case 2:
                tsw = t->sw[ssw->i][ssw->j][dsw->k];
                break;
        default:
                goto out;
        }
        if (tsw) {
                d = ring_dir_path(t, cdir, ssw, tsw);
                cdir *= 2;
                if (d > 0)
                        *pt_grp = cdir + 1;
                else if (d < 0)
                        *pt_grp = cdir;
                else
                        goto out;
                success = true;
        }
out:
        return success;
}

/*
 * Returns true, and sets *pt_grp to the port group index to use for the
 * next hop, if it is possible to make progress from ssw to dsw along the
 * coordinate direction cdir.  This decision is made strictly on a
 * shortest-path basis without regard for path availability.
 */
static
bool next_hop_idx(struct torus *t, unsigned cdir,
                  struct t_switch *ssw, struct t_switch *dsw,
                  unsigned *pt_grp)
{
        int d;
        unsigned g;
        bool success = false;

        switch (cdir) {
        case 0:
                d = ring_dir_idx(ssw->i, dsw->i, t->x_sz);
                break;
        case 1:
                d = ring_dir_idx(ssw->j, dsw->j, t->y_sz);
                break;
        case 2:
                d = ring_dir_idx(ssw->k, dsw->k, t->z_sz);
                break;
        default:
                goto out;
        }

        cdir *= 2;
        if (d > 0)
                g = cdir + 1;
        else if (d < 0)
                g = cdir;
        else
                goto out;

        if (!ssw->ptgrp[g].port_cnt)
                goto out;

        *pt_grp = g;
        success = true;
out:
        return success;
}

static
void warn_on_routing(const char *msg,
                     struct t_switch *sw, struct t_switch *dsw)
{
        OSM_LOG(&sw->torus->osm->log, OSM_LOG_ERROR,
                "%s from sw 0x%04"PRIx64" (%d,%d,%d) "
                "to sw 0x%04"PRIx64" (%d,%d,%d)\n",
                msg, cl_ntoh64(sw->n_id), sw->i, sw->j, sw->k,
                cl_ntoh64(dsw->n_id), dsw->i, dsw->j, dsw->k);
}

static
bool next_hop_x(struct torus *t,
                struct t_switch *ssw, struct t_switch *dsw, unsigned *pt_grp)
{
        if (t->sw[dsw->i][ssw->j][ssw->k])
                /*
                 * The next turning switch on this path is available,
                 * so head towards it by the shortest available path.
                 */
                return next_hop_path(t, 0, ssw, dsw, pt_grp);
        else
                /*
                 * The next turning switch on this path is not
                 * available, so head towards it in the shortest
                 * path direction.
                 */
                return next_hop_idx(t, 0, ssw, dsw, pt_grp);
}

static
bool next_hop_y(struct torus *t,
                struct t_switch *ssw, struct t_switch *dsw, unsigned *pt_grp)
{
        if (t->sw[ssw->i][dsw->j][ssw->k])
                /*
                 * The next turning switch on this path is available,
                 * so head towards it by the shortest available path.
                 */
                return next_hop_path(t, 1, ssw, dsw, pt_grp);
        else
                /*
                 * The next turning switch on this path is not
                 * available, so head towards it in the shortest
                 * path direction.
                 */
                return next_hop_idx(t, 1, ssw, dsw, pt_grp);
}

static
bool next_hop_z(struct torus *t,
                struct t_switch *ssw, struct t_switch *dsw, unsigned *pt_grp)
{
        return next_hop_path(t, 2, ssw, dsw, pt_grp);
}

/*
 * Returns the port number on *sw to use to reach *dsw, or -1 if unable to
 * route.
 */
static
int lft_port(struct torus *t,
             struct t_switch *sw, struct t_switch *dsw,
             bool update_port_cnt, bool ca)
{
        unsigned g, p;
        struct port_grp *pg;

        /*
         * The IBA does not provide a way to preserve path history for
         * routing decisions and VL assignment, and the only mechanism to
         * provide global fabric knowledge to the routing engine is via
         * the four SL bits.  This severely constrains the ability to deal
         * with missing/dead switches.
         *
         * Also, if routing a torus with XYZ-DOR, the only way to route
         * around a missing/dead switch is to introduce a turn that is
         * illegal under XYZ-DOR.
         *
         * But here's what we can do:
         *
         * We have a VL bit we use to flag illegal turns, thus putting the
         * hop directly after an illegal turn on a separate set of VLs.
         * Unfortunately, since there is no path history,  the _second_
         * and subsequent hops after an illegal turn use the standard
         * XYZ-DOR VL set.  This is enough to introduce credit loops in
         * many cases.
         *
         * To minimize the number of cases such illegal turns can introduce
         * credit loops, we try to introduce the illegal turn as late in a
         * path as possible.
         *
         * Define a turning switch as a switch where a path turns from one
         * coordinate direction onto another.  If a turning switch in a path
         * is missing, construct the LFT entries so that the path progresses
         * as far as possible on the shortest path to the turning switch.
         * When progress is not possible, turn onto the next coordinate
         * direction.
         *
         * The next turn after that will be an illegal turn, after which
         * point the path will continue to use a standard XYZ-DOR path.
         */
        if (dsw->i != sw->i) {

                if (next_hop_x(t, sw, dsw, &g))
                        goto done;
                /*
                 * This path has made as much progress in this direction as
                 * is possible, so turn it now.
                 */
                if (dsw->j != sw->j && next_hop_y(t, sw, dsw, &g))
                        goto done;

                if (dsw->k != sw->k && next_hop_z(t, sw, dsw, &g))
                        goto done;

                warn_on_routing("Error: unable to route", sw, dsw);
                goto no_route;
        } else if (dsw->j != sw->j) {

                if (next_hop_y(t, sw, dsw, &g))
                        goto done;

                if (dsw->k != sw->k && next_hop_z(t, sw, dsw, &g))
                        goto done;

                warn_on_routing("Error: unable to route", sw, dsw);
                goto no_route;
        } else {
                if (dsw->k == sw->k)
                        warn_on_routing("Warning: bad routing", sw, dsw);

                if (next_hop_z(t, sw, dsw, &g))
                        goto done;

                warn_on_routing("Error: unable to route", sw, dsw);
                goto no_route;
        }
done:
        pg = &sw->ptgrp[g];
        if (!pg->port_cnt)
                goto no_route;

        if (update_port_cnt) {
                if (ca)
                        p = pg->ca_dlid_cnt++ % pg->port_cnt;
                else
                        p = pg->sw_dlid_cnt++ % pg->port_cnt;
        } else {
                /*
                 * If we're not updating port counts, then we're just running
                 * routes for SL path checking, and it doesn't matter which
                 * of several parallel links we use.  Use the first one.
                 */
                p = 0;
        }
        p = pg->port[p]->port;

        return p;

no_route:
        /*
         * We can't get there from here.
         */
        OSM_LOG(&t->osm->log, OSM_LOG_ERROR,
                "ERR 4E39: routing on sw 0x%04"PRIx64": sending "
                "traffic for dest sw 0x%04"PRIx64" to port %u\n",
                cl_ntoh64(sw->n_id), cl_ntoh64(dsw->n_id), OSM_NO_PATH);
        return -1;
}

static
bool get_lid(struct port_grp *pg, unsigned p,
             uint16_t *dlid_base, uint8_t *dlid_lmc, bool *ca)
{
        struct endpoint *ep;
        osm_port_t *osm_port;

        if (p >= pg->port_cnt) {
                OSM_LOG(&pg->sw->torus->osm->log, OSM_LOG_ERROR,
                        "ERR 4E3A: Port group index %u too large: sw "
                        "0x%04"PRIx64" pt_grp %u pt_grp_cnt %u\n",
                        p, cl_ntoh64(pg->sw->n_id),
                        (unsigned)pg->port_grp, (unsigned)pg->port_cnt);
                return false;
        }
        if (pg->port[p]->type == SRCSINK) {
                ep = pg->port[p];
                if (ca)
                        *ca = false;
        } else if (pg->port[p]->type == PASSTHRU &&
                   pg->port[p]->link->end[1].type == SRCSINK) {
                /*
                 * If this port is connected via a link to a CA, then we
                 * know link->end[0] is the switch end and link->end[1] is
                 * the CA end; see build_ca_link() and link_srcsink().
                 */
                ep = &pg->port[p]->link->end[1];
                if (ca)
                        *ca = true;
        } else {
                OSM_LOG(&pg->sw->torus->osm->log, OSM_LOG_ERROR,
                        "ERR 4E3B: Switch 0x%04"PRIx64" port %d improperly connected\n",
                        cl_ntoh64(pg->sw->n_id), pg->port[p]->port);
                return false;
        }
        osm_port = ep->osm_port;
        if (!(osm_port && osm_port->priv == ep)) {
                OSM_LOG(&pg->sw->torus->osm->log, OSM_LOG_ERROR,
                        "ERR 4E3C: ep->osm_port->priv != ep "
                        "for sw 0x%04"PRIx64" port %d\n",
                        cl_ntoh64(((struct t_switch *)(ep->sw))->n_id), ep->port);
                return false;
        }
        *dlid_base = cl_ntoh16(osm_physp_get_base_lid(osm_port->p_physp));
        *dlid_lmc = osm_physp_get_lmc(osm_port->p_physp);

        return true;
}

static
bool torus_lft(struct torus *t, struct t_switch *sw)
{
        bool success = true;
        int dp;
        unsigned p, s;
        uint16_t l, dlid_base;
        uint8_t dlid_lmc;
        bool ca;
        struct port_grp *pgrp;
        struct t_switch *dsw;
        osm_switch_t *osm_sw;
        uint8_t order[IB_NODE_NUM_PORTS_MAX+1];

        if (!(sw->osm_switch && sw->osm_switch->priv == sw)) {
                OSM_LOG(&t->osm->log, OSM_LOG_ERROR,
                        "ERR 4E3D: sw->osm_switch->priv != sw "
                        "for sw 0x%04"PRIx64"\n", cl_ntoh64(sw->n_id));
                return false;
        }
        osm_sw = sw->osm_switch;
        memset(osm_sw->new_lft, OSM_NO_PATH, osm_sw->lft_size);

        for (s = 0; s < t->switch_cnt; s++) {

                dsw = t->sw_pool[s];
                pgrp = &dsw->ptgrp[2 * TORUS_MAX_DIM];

                memset(order, IB_INVALID_PORT_NUM, sizeof(order));
                for (p = 0; p < pgrp->port_cnt; p++)
                        order[pgrp->port[p]->port] = p;

                for (p = 0; p < ARRAY_SIZE(order); p++) {

                        uint8_t px = order[t->port_order[p]];

                        if (px == IB_INVALID_PORT_NUM)
                                continue;

                        if (!get_lid(pgrp, px, &dlid_base, &dlid_lmc, &ca))
                                return false;

                        if (sw->n_id == dsw->n_id)
                                dp = pgrp->port[px]->port;
                        else
                                dp = lft_port(t, sw, dsw, true, ca);
                        /*
                         * LMC > 0 doesn't really make sense for torus-2QoS.
                         * So, just make sure traffic gets delivered if
                         * non-zero LMC is used.
                         */
                        if (dp >= 0)
                                for (l = 0; l < (1U << dlid_lmc); l++)
                                        osm_sw->new_lft[dlid_base + l] = dp;
                        else
                                success = false;
                }
        }
        return success;
}

static
osm_mtree_node_t *mcast_stree_branch(struct t_switch *sw, osm_switch_t *osm_sw,
                                     osm_mgrp_box_t *mgb, unsigned depth,
                                     unsigned *port_cnt, unsigned *max_depth)
{
        osm_mtree_node_t *mtn = NULL;
        osm_mcast_tbl_t *mcast_tbl, *ds_mcast_tbl;
        osm_node_t *ds_node;
        struct t_switch *ds_sw;
        struct port_grp *ptgrp;
        struct link *link;
        struct endpoint *port;
        unsigned g, p;
        unsigned mcast_fwd_ports = 0, mcast_end_ports = 0;

        depth++;

        if (osm_sw->priv != sw) {
                OSM_LOG(&sw->torus->osm->log, OSM_LOG_ERROR,
                        "ERR 4E3E: osm_sw (GUID 0x%04"PRIx64") "
                        "not in torus fabric description\n",
                        cl_ntoh64(osm_node_get_node_guid(osm_sw->p_node)));
                goto out;
        }
        if (!osm_switch_supports_mcast(osm_sw)) {
                OSM_LOG(&sw->torus->osm->log, OSM_LOG_ERROR,
                        "ERR 4E3F: osm_sw (GUID 0x%04"PRIx64") "
                        "does not support multicast\n",
                        cl_ntoh64(osm_node_get_node_guid(osm_sw->p_node)));
                goto out;
        }
        mtn = osm_mtree_node_new(osm_sw);
        if (!mtn) {
                OSM_LOG(&sw->torus->osm->log, OSM_LOG_ERROR,
                        "ERR 4E46: Insufficient memory to build multicast tree\n");
                goto out;
        }
        mcast_tbl = osm_switch_get_mcast_tbl_ptr(osm_sw);
        /*
         * Recurse to downstream switches, i.e. those closer to master
         * spanning tree branch tips.
         *
         * Note that if there are multiple ports in this port group, i.e.,
         * multiple parallel links, we can pick any one of them to use for
         * any individual MLID without causing loops.  Pick one based on MLID
         * for now, until someone turns up evidence we need to be smarter.
         *
         * Also, it might be we got called in a window between a switch getting
         * removed from the fabric, and torus-2QoS getting to rebuild its
         * fabric representation.  If that were to happen, our next hop
         * osm_switch pointer might be stale.  Look it up via opensm's fabric
         * description to be sure it's not.
         */
        for (g = 0; g < 2 * TORUS_MAX_DIM; g++) {
                ptgrp = &sw->ptgrp[g];
                if (!ptgrp->to_stree_tip)
                        continue;

                p = mgb->mlid % ptgrp->port_cnt;/* port # in port group */
                p = ptgrp->port[p]->port;       /* now port # in switch */

                ds_node = osm_node_get_remote_node(osm_sw->p_node, p, NULL);
                ds_sw = ptgrp->to_stree_tip->sw;

                if (!(ds_node && ds_node->sw &&
                      ds_sw->osm_switch == ds_node->sw)) {
                        OSM_LOG(&sw->torus->osm->log, OSM_LOG_ERROR,
                                "ERR 4E40: stale pointer to osm_sw "
                                "(GUID 0x%04"PRIx64")\n", cl_ntoh64(ds_sw->n_id));
                        continue;
                }
                mtn->child_array[p] =
                        mcast_stree_branch(ds_sw, ds_node->sw, mgb,
                                           depth, port_cnt, max_depth);
                if (!mtn->child_array[p])
                        continue;

                osm_mcast_tbl_set(mcast_tbl, mgb->mlid, p);
                mcast_fwd_ports++;
                /*
                 * Since we forward traffic for this multicast group on this
                 * port, cause the switch on the other end of the link
                 * to forward traffic back to us.  Do it now since have at
                 * hand the link used; otherwise it'll be hard to figure out
                 * later, and if we get it wrong we get a MC routing loop.
                 */
                link = sw->port[p]->link;
                ds_mcast_tbl = osm_switch_get_mcast_tbl_ptr(ds_node->sw);

                if (&link->end[0] == sw->port[p])
                        osm_mcast_tbl_set(ds_mcast_tbl, mgb->mlid,
                                          link->end[1].port);
                else
                        osm_mcast_tbl_set(ds_mcast_tbl, mgb->mlid,
                                          link->end[0].port);
        }
        /*
         * Add any host ports marked as in mcast group into spanning tree.
         */
        ptgrp = &sw->ptgrp[2 * TORUS_MAX_DIM];
        for (p = 0; p < ptgrp->port_cnt; p++) {
                port = ptgrp->port[p];
                if (port->tmp) {
                        port->tmp = NULL;
                        mtn->child_array[port->port] = OSM_MTREE_LEAF;
                        osm_mcast_tbl_set(mcast_tbl, mgb->mlid, port->port);
                        mcast_end_ports++;
                }
        }
        if (!(mcast_end_ports || mcast_fwd_ports)) {
                osm_mtree_destroy(mtn);
                mtn = NULL;
        } else if (depth > *max_depth)
                *max_depth = depth;

        *port_cnt += mcast_end_ports;
out:
        return mtn;
}

static
osm_port_t *next_mgrp_box_port(osm_mgrp_box_t *mgb,
                               cl_list_item_t **list_iterator,
                               cl_map_item_t **map_iterator)
{
        osm_mgrp_t *mgrp;
        osm_mcm_port_t *mcm_port;
        osm_port_t *osm_port = NULL;
        cl_map_item_t *m_item = *map_iterator;
        cl_list_item_t *l_item = *list_iterator;

next_mgrp:
        if (!l_item)
                l_item = cl_qlist_head(&mgb->mgrp_list);
        if (l_item == cl_qlist_end(&mgb->mgrp_list)) {
                l_item = NULL;
                goto out;
        }
        mgrp = cl_item_obj(l_item, mgrp, list_item);

        if (!m_item)
                m_item = cl_qmap_head(&mgrp->mcm_port_tbl);
        if (m_item == cl_qmap_end(&mgrp->mcm_port_tbl)) {
                m_item = NULL;
                l_item = cl_qlist_next(l_item);
                goto next_mgrp;
        }
        mcm_port = cl_item_obj(m_item, mcm_port, map_item);
        m_item = cl_qmap_next(m_item);
        osm_port = mcm_port->port;
out:
        *list_iterator = l_item;
        *map_iterator = m_item;
        return osm_port;
}

static
ib_api_status_t torus_mcast_stree(void *context, osm_mgrp_box_t *mgb)
{
        struct torus_context *ctx = context;
        struct torus *t = ctx->torus;
        cl_map_item_t *m_item = NULL;
        cl_list_item_t *l_item = NULL;
        osm_port_t *osm_port;
        osm_switch_t *osm_sw;
        struct endpoint *port;
        unsigned port_cnt = 0, max_depth = 0;

        osm_purge_mtree(&ctx->osm->sm, mgb);

        /*
         * Build a spanning tree for a multicast group by first marking
         * the torus endpoints that are participating in the group.
         * Then do a depth-first search of the torus master spanning
         * tree to build up the spanning tree specific to this group.
         *
         * Since the torus master spanning tree is constructed specifically
         * to guarantee that multicast will not deadlock against unicast
         * when they share VLs, we can be sure that any multicast group
         * spanning tree constructed this way has the same property.
         */
        while ((osm_port = next_mgrp_box_port(mgb, &l_item, &m_item))) {
                port = osm_port->priv;
                if (!(port && port->osm_port == osm_port)) {
                        port = osm_port_relink_endpoint(osm_port);
                        if (!port) {
                                guid_t id;
                                id = osm_node_get_node_guid(osm_port->p_node);
                                OSM_LOG(&ctx->osm->log, OSM_LOG_ERROR,
                                        "ERR 4E41: osm_port (GUID 0x%04"PRIx64") "
                                        "not in torus fabric description\n",
                                        cl_ntoh64(id));
                                continue;
                        }
                }
                /*
                 * If this is a CA port, mark the switch port at the
                 * other end of this port's link.
                 *
                 * By definition, a CA port is connected to end[1] of a link,
                 * and the switch port is end[0].  See build_ca_link() and
                 * link_srcsink().
                 */
                if (port->link)
                        port = &port->link->end[0];
                port->tmp = osm_port;
        }
        /*
         * It might be we got called in a window between a switch getting
         * removed from the fabric, and torus-2QoS getting to rebuild its
         * fabric representation.  If that were to happen, our
         * master_stree_root->osm_switch pointer might be stale.  Look up
         * the osm_switch by GUID to be sure it's not.
         *
         * Also, call into mcast_stree_branch with depth = -1, because
         * depth at root switch needs to be 0.
         */
        osm_sw = (osm_switch_t *)cl_qmap_get(&ctx->osm->subn.sw_guid_tbl,
                                             t->master_stree_root->n_id);
        if (!(osm_sw && t->master_stree_root->osm_switch == osm_sw)) {
                OSM_LOG(&ctx->osm->log, OSM_LOG_ERROR,
                        "ERR 4E42: stale pointer to osm_sw (GUID 0x%04"PRIx64")\n",
                        cl_ntoh64(t->master_stree_root->n_id));
                return IB_ERROR;
        }
        mgb->root = mcast_stree_branch(t->master_stree_root, osm_sw,
                                       mgb, -1, &port_cnt, &max_depth);

        OSM_LOG(&ctx->osm->log, OSM_LOG_VERBOSE,
                "Configured MLID 0x%X for %u ports, max tree depth = %u\n",
                mgb->mlid, port_cnt, max_depth);

        return IB_SUCCESS;
}

static
bool good_xy_ring(struct torus *t, const int x, const int y, const int z)
{
        struct t_switch ****sw = t->sw;
        bool good_ring = true;
        int x_tst, y_tst;

        for (x_tst = 0; x_tst < t->x_sz && good_ring; x_tst++)
                good_ring = sw[x_tst][y][z];

        for (y_tst = 0; y_tst < t->y_sz && good_ring; y_tst++)
                good_ring = sw[x][y_tst][z];

        return good_ring;
}

static
struct t_switch *find_plane_mid(struct torus *t, const int z)
{
        int x, dx, xm = t->x_sz / 2;
        int y, dy, ym = t->y_sz / 2;
        struct t_switch ****sw = t->sw;

        if (good_xy_ring(t, xm, ym, z))
                return sw[xm][ym][z];

        for (dx = 1, dy = 1; dx <= xm && dy <= ym; dx++, dy++) {

                x = canonicalize(xm - dx, t->x_sz);
                y = canonicalize(ym - dy, t->y_sz);
                if (good_xy_ring(t, x, y, z))
                        return sw[x][y][z];

                x = canonicalize(xm + dx, t->x_sz);
                y = canonicalize(ym + dy, t->y_sz);
                if (good_xy_ring(t, x, y, z))
                        return sw[x][y][z];
        }
        return NULL;
}

static
struct t_switch *find_stree_root(struct torus *t)
{
        int x, y, z, dz, zm = t->z_sz / 2;
        struct t_switch ****sw = t->sw;
        struct t_switch *root;
        bool good_plane;

        /*
         * Look for a switch near the "center" (wrt. the datelines) of the
         * torus, as that will be the most optimum spanning tree root.  Use
         * a search that is not exhaustive, on the theory that this routing
         * engine isn't useful anyway if too many switches are missing.
         *
         * Also, want to pick an x-y plane with no missing switches, so that
         * the master spanning tree construction algorithm doesn't have to
         * deal with needing a turn on a missing switch.
         */
        for (dz = 0; dz <= zm; dz++) {

                z = canonicalize(zm - dz, t->z_sz);
                good_plane = true;
                for (y = 0; y < t->y_sz && good_plane; y++)
                        for (x = 0; x < t->x_sz && good_plane; x++)
                                good_plane = sw[x][y][z];

                if (good_plane) {
                        root = find_plane_mid(t, z);
                        if (root)
                                goto out;
                }
                if (!dz)
                        continue;

                z = canonicalize(zm + dz, t->z_sz);
                good_plane = true;
                for (y = 0; y < t->y_sz && good_plane; y++)
                        for (x = 0; x < t->x_sz && good_plane; x++)
                                good_plane = sw[x][y][z];

                if (good_plane) {
                        root = find_plane_mid(t, z);
                        if (root)
                                goto out;
                }
        }
        /*
         * Note that torus-2QoS can route a torus that is missing an entire
         * column (switches with x,y constant, for all z values) without
         * deadlocks.
         *
         * if we've reached this point, we must have a column of missing
         * switches, as routable_torus() would have returned false for
         * any other configuration of missing switches that made it through
         * the above.
         *
         * So any switch in the mid-z plane will do as the root.
         */
        root = find_plane_mid(t, zm);
out:
        return root;
}

static
bool sw_in_master_stree(struct t_switch *sw)
{
        int g;
        bool connected;

        connected = sw == sw->torus->master_stree_root;
        for (g = 0; g < 2 * TORUS_MAX_DIM; g++)
                connected = connected || sw->ptgrp[g].to_stree_root;

        return connected;
}

static
void grow_master_stree_branch(struct t_switch *root, struct t_switch *tip,
                              unsigned to_root_pg, unsigned to_tip_pg)
{
        root->ptgrp[to_tip_pg].to_stree_tip = &tip->ptgrp[to_root_pg];
        tip->ptgrp[to_root_pg].to_stree_root = &root->ptgrp[to_tip_pg];
}

static
void build_master_stree_branch(struct t_switch *branch_root, int cdir)
{
        struct t_switch *sw, *n_sw, *p_sw;
        unsigned l, idx, cnt, pg, ng;

        switch (cdir) {
        case 0:
                idx = branch_root->i;
                cnt = branch_root->torus->x_sz;
                break;
        case 1:
                idx = branch_root->j;
                cnt = branch_root->torus->y_sz;
                break;
        case 2:
                idx = branch_root->k;
                cnt = branch_root->torus->z_sz;
                break;
        default:
                goto out;
        }
        /*
         * This algorithm intends that a spanning tree branch never crosses
         * a dateline unless the 1-D ring for which we're building the branch
         * is interrupted by failure.  We need that guarantee to prevent
         * multicast/unicast credit loops.
         */
        n_sw = branch_root;             /* tip of negative cdir branch */
        ng = 2 * cdir;                  /* negative cdir port group index */
        p_sw = branch_root;             /* tip of positive cdir branch */
        pg = 2 * cdir + 1;              /* positive cdir port group index */

        for (l = idx; n_sw && l >= 1; l--) {
                sw = ring_next_sw(n_sw, cdir, -1);
                if (sw && !sw_in_master_stree(sw)) {
                        grow_master_stree_branch(n_sw, sw, pg, ng);
                        n_sw = sw;
                } else
                        n_sw = NULL;
        }
        for (l = idx; p_sw && l < (cnt - 1); l++) {
                sw = ring_next_sw(p_sw, cdir, 1);
                if (sw && !sw_in_master_stree(sw)) {
                        grow_master_stree_branch(p_sw, sw, ng, pg);
                        p_sw = sw;
                } else
                        p_sw = NULL;
        }
        if (n_sw && p_sw)
                goto out;
        /*
         * At least one branch couldn't grow to the dateline for this ring.
         * That means it is acceptable to grow the branch by crossing the
         * dateline.
         */
        for (l = 0; l < cnt; l++) {
                if (n_sw) {
                        sw = ring_next_sw(n_sw, cdir, -1);
                        if (sw && !sw_in_master_stree(sw)) {
                                grow_master_stree_branch(n_sw, sw, pg, ng);
                                n_sw = sw;
                        } else
                                n_sw = NULL;
                }
                if (p_sw) {
                        sw = ring_next_sw(p_sw, cdir, 1);
                        if (sw && !sw_in_master_stree(sw)) {
                                grow_master_stree_branch(p_sw, sw, ng, pg);
                                p_sw = sw;
                        } else
                                p_sw = NULL;
                }
                if (!(n_sw || p_sw))
                        break;
        }
out:
        return;
}

static
bool torus_master_stree(struct torus *t)
{
        int i, j, k;
        bool success = false;
        struct t_switch *stree_root = find_stree_root(t);

        if (stree_root)
                build_master_stree_branch(stree_root, 0);
        else
                goto out;

        k = stree_root->k;
        for (i = 0; i < t->x_sz; i++) {
                j = stree_root->j;
                if (t->sw[i][j][k])
                        build_master_stree_branch(t->sw[i][j][k], 1);

                for (j = 0; j < t->y_sz; j++)
                        if (t->sw[i][j][k])
                                build_master_stree_branch(t->sw[i][j][k], 2);
        }
        t->master_stree_root = stree_root;
        /*
         * At this point we should have a master spanning tree that contains
         * every present switch, for all fabrics that torus-2QoS can route
         * without deadlocks.  Make sure this is the case; otherwise warn
         * and return failure so we get bug reports.
         */
        success = true;
        for (i = 0; i < t->x_sz; i++)
                for (j = 0; j < t->y_sz; j++)
                        for (k = 0; k < t->z_sz; k++) {
                                struct t_switch *sw = t->sw[i][j][k];
                                if (!sw || sw_in_master_stree(sw))
                                        continue;

                                success = false;
                                OSM_LOG(&t->osm->log, OSM_LOG_ERROR,
                                        "ERR 4E43: sw 0x%04"PRIx64" (%d,%d,%d) not in "
                                        "torus multicast master spanning tree\n",
                                        cl_ntoh64(sw->n_id), i, j, k);
                        }
out:
        return success;
}

int route_torus(struct torus *t)
{
        int s;
        bool success = true;

        for (s = 0; s < (int)t->switch_cnt; s++)
                success = torus_lft(t, t->sw_pool[s]) && success;

        success = success && torus_master_stree(t);

        return success ? 0 : -1;
}

uint8_t torus_path_sl(void *context, uint8_t path_sl_hint,
                      const ib_net16_t slid, const ib_net16_t dlid)
{
        struct torus_context *ctx = context;
        osm_opensm_t *p_osm = ctx->osm;
        osm_log_t *log = &p_osm->log;
        osm_port_t *osm_sport, *osm_dport;
        struct endpoint *sport, *dport;
        struct t_switch *ssw, *dsw;
        struct torus *t;
        guid_t guid;
        unsigned sl = 0;

        osm_sport = osm_get_port_by_lid(&p_osm->subn, slid);
        if (!osm_sport)
                goto out;

        osm_dport = osm_get_port_by_lid(&p_osm->subn, dlid);
        if (!osm_dport)
                goto out;

        sport = osm_sport->priv;
        if (!(sport && sport->osm_port == osm_sport)) {
                sport = osm_port_relink_endpoint(osm_sport);
                if (!sport) {
                        guid = osm_node_get_node_guid(osm_sport->p_node);
                        OSM_LOG(log, OSM_LOG_INFO,
                                "Note: osm_sport (GUID 0x%04"PRIx64") "
                                "not in torus fabric description\n",
                                cl_ntoh64(guid));
                        goto out;
                }
        }
        dport = osm_dport->priv;
        if (!(dport && dport->osm_port == osm_dport)) {
                dport = osm_port_relink_endpoint(osm_dport);
                if (!dport) {
                        guid = osm_node_get_node_guid(osm_dport->p_node);
                        OSM_LOG(log, OSM_LOG_INFO,
                                "Note: osm_dport (GUID 0x%04"PRIx64") "
                                "not in torus fabric description\n",
                                cl_ntoh64(guid));
                        goto out;
                }
        }
        /*
         * We're only supposed to be called for CA ports, and maybe
         * switch management ports.
         */
        if (sport->type != SRCSINK) {
                guid = osm_node_get_node_guid(osm_sport->p_node);
                OSM_LOG(log, OSM_LOG_INFO,
                        "Error: osm_sport (GUID 0x%04"PRIx64") "
                        "not a data src/sink port\n", cl_ntoh64(guid));
                goto out;
        }
        if (dport->type != SRCSINK) {
                guid = osm_node_get_node_guid(osm_dport->p_node);
                OSM_LOG(log, OSM_LOG_INFO,
                        "Error: osm_dport (GUID 0x%04"PRIx64") "
                        "not a data src/sink port\n", cl_ntoh64(guid));
                goto out;
        }
        /*
         * By definition, a CA port is connected to end[1] of a link, and
         * the switch port is end[0].  See build_ca_link() and link_srcsink().
         */
        if (sport->link) {
                ssw = sport->link->end[0].sw;
        } else {
                ssw = sport->sw;
        }
        if (dport->link)
                dsw = dport->link->end[0].sw;
        else
                dsw = dport->sw;

        t = ssw->torus;

        sl  = sl_set_use_loop_vl(use_vl1(ssw->i, dsw->i, t->x_sz), 0);
        sl |= sl_set_use_loop_vl(use_vl1(ssw->j, dsw->j, t->y_sz), 1);
        sl |= sl_set_use_loop_vl(use_vl1(ssw->k, dsw->k, t->z_sz), 2);
        sl |= sl_set_qos(sl_get_qos(path_sl_hint));
out:
        return sl;
}

static
void sum_vlarb_weights(const char *vlarb_str,
                       unsigned total_weight[IB_MAX_NUM_VLS])
{
        unsigned i = 0, v, vl = 0;
        char *end;

        while (*vlarb_str && i++ < 2 * IB_NUM_VL_ARB_ELEMENTS_IN_BLOCK) {
                v = strtoul(vlarb_str, &end, 0);
                if (*end)
                        end++;
                vlarb_str = end;
                if (i & 0x1)
                        vl = v & 0xf;
                else
                        total_weight[vl] += v & 0xff;
        }
}

static
int uniform_vlarb_weight_value(unsigned *weight, unsigned count)
{
        int i, v = weight[0];

        for (i = 1; i < count; i++) {
                if (v != weight[i])
                        return -1;
        }
        return v;
}

static
void check_vlarb_config(const char *vlarb_str, bool is_default,
                        const char *str, const char *pri, osm_log_t *log)
{
        unsigned total_weight[IB_MAX_NUM_VLS] = {0,};

        sum_vlarb_weights(vlarb_str, total_weight);
        if (!(uniform_vlarb_weight_value(&total_weight[0], 4) >= 0 &&
              uniform_vlarb_weight_value(&total_weight[4], 4) >= 0))
                OSM_LOG(log, OSM_LOG_INFO,
                        "Warning: torus-2QoS requires same VLarb weights for "
                        "VLs 0-3; also for VLs 4-7: not true for %s "
                        "%s_vlarb_%s\n",
                        (is_default ? "default" : "configured"), str, pri);
}

/*
 * Use this to check the qos_config for switch external ports.
 */
static
void check_qos_swe_config(osm_qos_options_t *opt,
                          osm_qos_options_t *def, osm_log_t *log)
{
        const char *vlarb_str, *tstr;
        bool is_default;
        unsigned max_vls;

        max_vls = def->max_vls;
        if (opt->max_vls > 0)
                max_vls = opt->max_vls;

        if (max_vls > 0 && max_vls < 8)
                OSM_LOG(log, OSM_LOG_INFO,
                        "Warning: full torus-2QoS functionality not available "
                        "for configured %s_max_vls = %d\n",
                        (opt->max_vls > 0 ? "qos_swe" : "qos"), opt->max_vls);

        vlarb_str = opt->vlarb_high;
        is_default = false;
        tstr = "qos_swe";
        if (!vlarb_str) {
                vlarb_str = def->vlarb_high;
                tstr = "qos";
        }
        if (!vlarb_str) {
                vlarb_str = OSM_DEFAULT_QOS_VLARB_HIGH;
                is_default = true;
        }
        check_vlarb_config(vlarb_str, is_default, tstr, "high", log);

        vlarb_str = opt->vlarb_low;
        is_default = false;
        tstr = "qos_swe";
        if (!vlarb_str) {
                vlarb_str = def->vlarb_low;
                tstr = "qos";
        }
        if (!vlarb_str) {
                vlarb_str = OSM_DEFAULT_QOS_VLARB_LOW;
                is_default = true;
        }
        check_vlarb_config(vlarb_str, is_default, tstr, "low", log);

        if (opt->sl2vl)
                OSM_LOG(log, OSM_LOG_INFO,
                        "Warning: torus-2QoS must override configured "
                        "qos_swe_sl2vl to generate deadlock-free routes\n");
}

static
void check_ep_vlarb_config(const char *vlarb_str,
                           bool is_default, bool is_specific,
                           const char *str, const char *pri, osm_log_t *log)
{
        unsigned i, total_weight[IB_MAX_NUM_VLS] = {0,};
        int val = 0;

        sum_vlarb_weights(vlarb_str, total_weight);
        for (i = 2; i < 8; i++) {
                val += total_weight[i];
        }
        if (!val)
                return;

        if (is_specific)
                OSM_LOG(log, OSM_LOG_INFO,
                        "Warning: torus-2QoS recommends 0 VLarb weights"
                        " for VLs 2-7 on endpoint links; not true for "
                        " configured %s_vlarb_%s\n", str, pri);
        else
                OSM_LOG(log, OSM_LOG_INFO,
                        "Warning: torus-2QoS recommends 0 VLarb weights "
                        "for VLs 2-7 on endpoint links; not true for %s "
                        "qos_vlarb_%s values used for %s_vlarb_%s\n",
                        (is_default ? "default" : "configured"), pri, str, pri);
}

/*
 * Use this to check the qos_config for endports
 */
static
void check_qos_ep_config(osm_qos_options_t *opt, osm_qos_options_t *def,
                         const char *str, osm_log_t *log)
{
        const char *vlarb_str;
        bool is_default, is_specific;
        unsigned max_vls;

        max_vls = def->max_vls;
        if (opt->max_vls > 0)
                max_vls = opt->max_vls;

        if (max_vls > 0 && max_vls < 2)
                OSM_LOG(log, OSM_LOG_INFO,
                        "Warning: full torus-2QoS functionality not available "
                        "for configured %s_max_vls = %d\n",
                        (opt->max_vls > 0 ? str : "qos"), opt->max_vls);

        vlarb_str = opt->vlarb_high;
        is_default = false;
        is_specific = true;
        if (!vlarb_str) {
                vlarb_str = def->vlarb_high;
                is_specific = false;
        }
        if (!vlarb_str) {
                vlarb_str = OSM_DEFAULT_QOS_VLARB_HIGH;
                is_default = true;
        }
        check_ep_vlarb_config(vlarb_str, is_default, is_specific,
                              str, "high", log);

        vlarb_str = opt->vlarb_low;
        is_default = false;
        is_specific = true;
        if (!vlarb_str) {
                vlarb_str = def->vlarb_low;
                is_specific = false;
        }
        if (!vlarb_str) {
                vlarb_str = OSM_DEFAULT_QOS_VLARB_LOW;
                is_default = true;
        }
        check_ep_vlarb_config(vlarb_str, is_default, is_specific,
                              str, "low", log);

        if (opt->sl2vl)
                OSM_LOG(log, OSM_LOG_INFO,
                        "Warning: torus-2QoS must override configured "
                        "%s_sl2vl to generate deadlock-free routes\n", str);
}

static
int torus_build_lfts(void *context)
{
        int status = -1;
        struct torus_context *ctx = context;
        struct fabric *fabric;
        struct torus *torus;

        if (!ctx->osm->subn.opt.qos) {
                OSM_LOG(&ctx->osm->log, OSM_LOG_ERROR,
                        "ERR 4E44: Routing engine list contains torus-2QoS. "
                        "Enable QoS for correct operation "
                        "(-Q or 'qos TRUE' in opensm.conf).\n");
                return status;
        }

        fabric = &ctx->fabric;
        teardown_fabric(fabric);

        torus = calloc(1, sizeof(*torus));
        if (!torus) {
                OSM_LOG(&ctx->osm->log, OSM_LOG_ERROR,
                        "ERR 4E45: allocating torus: %s\n", strerror(errno));
                goto out;
        }
        torus->osm = ctx->osm;
        fabric->osm = ctx->osm;

        if (!parse_config(ctx->osm->subn.opt.torus_conf_file,
                          fabric, torus))
                goto out;

        if (!capture_fabric(fabric))
                goto out;

        OSM_LOG(&torus->osm->log, OSM_LOG_INFO,
                "Found fabric w/ %d links, %d switches, %d CA ports, "
                "minimum data VLs: endport %d, switchport %d\n",
                (int)fabric->link_cnt, (int)fabric->switch_cnt,
                (int)fabric->ca_cnt, (int)ctx->osm->subn.min_data_vls,
                (int)ctx->osm->subn.min_sw_data_vls);

        if (!verify_setup(torus, fabric))
                goto out;

        OSM_LOG(&torus->osm->log, OSM_LOG_INFO,
                "Looking for %d x %d x %d %s\n",
                (int)torus->x_sz, (int)torus->y_sz, (int)torus->z_sz,
                (ALL_MESH(torus->flags) ? "mesh" : "torus"));

        if (!build_torus(fabric, torus)) {
                OSM_LOG(&torus->osm->log, OSM_LOG_ERROR, "ERR 4E57: "
                        "build_torus finished with errors\n");
                goto out;
        }

        OSM_LOG(&torus->osm->log, OSM_LOG_INFO,
                "Built %d x %d x %d %s w/ %d links, %d switches, %d CA ports\n",
                (int)torus->x_sz, (int)torus->y_sz, (int)torus->z_sz,
                (ALL_MESH(torus->flags) ? "mesh" : "torus"),
                (int)torus->link_cnt, (int)torus->switch_cnt,
                (int)torus->ca_cnt);

        diagnose_fabric(fabric);
        /*
         * Since we found some sort of torus fabric, report on any topology
         * changes vs. the last torus we found.
         */
        if (torus->flags & NOTIFY_CHANGES)
                report_torus_changes(torus, ctx->torus);

        if (routable_torus(torus, fabric))
                status = route_torus(torus);

out:
        if (status) {           /* bad torus!! */
                if (torus)
                        teardown_torus(torus);
        } else {
                osm_subn_opt_t *opt = &torus->osm->subn.opt;
                osm_log_t *log = &torus->osm->log;

                if (ctx->torus)
                        teardown_torus(ctx->torus);
                ctx->torus = torus;

                check_qos_swe_config(&opt->qos_swe_options, &opt->qos_options,
                                     log);

                check_qos_ep_config(&opt->qos_ca_options,
                                    &opt->qos_options, "qos_ca", log);
                check_qos_ep_config(&opt->qos_sw0_options,
                                    &opt->qos_options, "qos_sw0", log);
                check_qos_ep_config(&opt->qos_rtr_options,
                                    &opt->qos_options, "qos_rtr", log);
        }
        teardown_fabric(fabric);
        return status;
}

int osm_ucast_torus2QoS_setup(struct osm_routing_engine *r,
                              osm_opensm_t *osm)
{
        struct torus_context *ctx;

        ctx = torus_context_create(osm);
        if (!ctx)
                return -1;

        r->context = ctx;
        r->ucast_build_fwd_tables = torus_build_lfts;
        r->build_lid_matrices = ucast_dummy_build_lid_matrices;
        r->update_sl2vl = torus_update_osm_sl2vl;
        r->update_vlarb = torus_update_osm_vlarb;
        r->path_sl = torus_path_sl;
        r->mcast_build_stree = torus_mcast_stree;
        r->destroy = torus_context_delete;
        return 0;
}