* MDC element is no longer created in config. The MDC UUIDS are generated

  by lconf when a client is started. This required some Big Ugly Hacks that
  I hope to clean up in the near future.

* LOVs and OSC are treated uniformly. --osc lov1 will now work as expected.

These changes require config files to be recreated to work properly with lconf. No
changes were made to the lmc interface, so the config scripts are unchanged.

diff --git a/lustre/utils/lconf b/lustre/utils/lconf
index b3408e5..2133794 100755 (executable)
--- a/lustre/utils/lconf
+++ b/lustre/utils/lconf
@@ -33,6 +33,7 @@ import xml.dom.minidom
 # Global parameters
 TCP_ACCEPTOR = ''
 MAXTCPBUF = 1048576
+DEFAULT_TCPBUF = 1048576
 #
 # Maximum number of devices to search for.
 # (the /dev/loop* nodes need to be created beforehand)
@@ -662,8 +663,8 @@ class Network(Module):
         self.net_type = get_attr(dom_node,'type')
         self.nid = get_text(dom_node, 'server', '*')
         self.port = get_text_int(dom_node, 'port', 0)
-        self.send_mem = get_text_int(dom_node, 'send_mem', 65536)
-        self.recv_mem = get_text_int(dom_node, 'recv_mem', 65536)
+        self.send_mem = get_text_int(dom_node, 'send_mem', DEFAULT_TCPBUF)
+        self.recv_mem = get_text_int(dom_node, 'recv_mem', DEFAULT_TCPBUF)
         if self.nid == '*':
             self.nid = get_local_address(self.net_type)
             if not self.nid:
@@ -755,9 +756,9 @@ class LDLM(Module):
 class LOV(Module):
     def __init__(self,dom_node):
         Module.__init__(self, 'LOV', dom_node)
-        self.mdsuuid = get_first_ref(dom_node, 'mds')
-        mds= lookup(dom_node.parentNode, self.mdsuuid)
-        self.mdsname = getName(mds)
+        self.mds_uuid = get_first_ref(dom_node, 'mds')
+        mds= lookup(dom_node.parentNode, self.mds_uuid)
+        self.mds_name = getName(mds)
         devs = dom_node.getElementsByTagName('devices')
         if len(devs) > 0:
             dev_node = devs[0]
@@ -766,13 +767,72 @@ class LOV(Module):
             self.pattern = get_attr_int(dev_node, 'pattern', 0)
             self.devlist = get_all_refs(dev_node, 'osc')
             self.stripe_cnt = len(self.devlist)
+        self.add_module('lustre/mdc', 'mdc')
+        self.add_module('lustre/lov', 'lov')
+
+    def prepare(self):
+        for osc_uuid in self.devlist:
+            osc = lookup(self.dom_node.parentNode, osc_uuid)
+            if osc:
+                n = OSC(osc)
+                n.prepare()
+            else:
+                panic('osc not found:', osc_uuid)
+        mdc_uuid = prepare_mdc(self.dom_node.parentNode, self.mds_uuid)
+        self.info(self.mds_uuid, self.stripe_cnt, self.stripe_sz, self.stripe_off, self.pattern,
+        self.devlist, self.mds_name)
+        lctl.newdev(attach="lov %s %s" % (self.name, self.uuid),
+                    setup ="%s" % (mdc_uuid))
+
+    def cleanup(self):
+        for osc_uuid in self.devlist:
+            osc = lookup(self.dom_node.parentNode, osc_uuid)
+            if osc:
+                n = OSC(osc)
+                n.cleanup()
+            else:
+                panic('osc not found:', osc_uuid)
+        Module.cleanup(self)
+        cleanup_mdc(self.dom_node.parentNode, self.mds_uuid)
+    def load_module(self):
+        for osc_uuid in self.devlist:
+            osc = lookup(self.dom_node.parentNode, osc_uuid)
+            if osc:
+                n = OSC(osc)
+                n.load_module()
+                break
+            else:
+                panic('osc not found:', osc_uuid)
+        Module.load_module(self)
+    def cleanup_module(self):
+        Module.cleanup_module(self)
+        for osc_uuid in self.devlist:
+            osc = lookup(self.dom_node.parentNode, osc_uuid)
+            if osc:
+                n = OSC(osc)
+                n.cleanup_module()
+                break
+            else:
+                panic('osc not found:', osc_uuid)
 
+class LOVConfig(Module):
+    def __init__(self,dom_node):
+        Module.__init__(self, 'LOVConfig', dom_node)
+        self.lov_uuid = get_first_ref(dom_node, 'lov')
+        l = lookup(dom_node.parentNode, self.lov_uuid)
+        self.lov = LOV(l)
+        
     def prepare(self):
-        self.info(self.mdsuuid, self.stripe_cnt, self.stripe_sz, self.stripe_off, self.pattern,
-        self.devlist, self.mdsname)
-        lctl.lovconfig(self.uuid, self.mdsname, self.stripe_cnt,
-                       self.stripe_sz, self.stripe_off, self.pattern,
-                       string.join(self.devlist))
+        lov = self.lov
+        self.info(lov.mds_uuid, lov.stripe_cnt, lov.stripe_sz, lov.stripe_off, lov.pattern,
+        lov.devlist, lov.mds_name)
+        lctl.lovconfig(lov.uuid, lov.mds_name, lov.stripe_cnt,
+                       lov.stripe_sz, lov.stripe_off, lov.pattern,
+                       string.join(lov.devlist))
+
+    def cleanup(self):
+        #nothing to do here
+        pass
 
 
 class MDS(Module):
@@ -795,19 +855,30 @@ class MDS(Module):
         Module.cleanup(self)
         clean_loop(self.devname)
 
+# Very unusual case, as there is no MDC element in the XML anymore
+# Builds itself from an MDS node
 class MDC(Module):
     def __init__(self,dom_node):
-        Module.__init__(self, 'MDC', dom_node)
-        self.mds_uuid = get_first_ref(dom_node, 'mds')
-        self.lookup_server(self.mds_uuid)
+        self.mds = MDS(dom_node)
+        self.dom_node = dom_node
+        self.module_name = 'MDC'
+        self.kmodule_list = []
+        self._server = None
+        self._connected = 0
+
+        host = socket.gethostname()
+        self.name = 'MDC_'+host
+        self.uuid = self.name+'_UUID'
+
+        self.lookup_server(self.mds.uuid)
         self.add_module('lustre/mdc', 'mdc')
 
     def prepare(self):
-        self.info(self.mds_uuid)
+        self.info(self.mds.uuid)
         srv = self.get_server()
         lctl.connect(srv.net_type, srv.nid, srv.port, srv.uuid, srv.send_mem, srv.recv_mem)
         lctl.newdev(attach="mdc %s %s" % (self.name, self.uuid),
-                        setup ="%s %s" %(self.mds_uuid, srv.uuid))
+                        setup ="%s %s" %(self.mds.uuid, srv.uuid))
             
 class OBD(Module):
     def __init__(self, dom_node):
@@ -847,6 +918,25 @@ class OST(Module):
         lctl.newdev(attach="ost %s %s" % (self.name, self.uuid),
                     setup ="%s" % (self.obd_uuid))
 
+
+# virtual interface for  OSC and LOV
+class VOSC(Module):
+    def __init__(self,dom_node):
+        Module.__init__(self, 'VOSC', dom_node)
+        if dom_node.nodeName == 'lov':
+            self.osc = LOV(dom_node)
+        else:
+            self.osc = OSC(dom_node)
+    def prepare(self):
+        self.osc.prepare()
+    def cleanup(self):
+        self.osc.cleanup()
+    def load_module(self):
+        self.osc.load_module()
+    def cleanup_module(self):
+        self.osc.cleanup_module()
+        
+
 class OSC(Module):
     def __init__(self,dom_node):
         Module.__init__(self, 'OSC', dom_node)
@@ -875,57 +965,41 @@ class Mountpoint(Module):
     def __init__(self,dom_node):
         Module.__init__(self, 'MTPT', dom_node)
         self.path = get_text(dom_node, 'path')
-        self.mdc_uuid = get_first_ref(dom_node, 'mdc')
+        self.mds_uuid = get_first_ref(dom_node, 'mds')
         self.lov_uuid = get_first_ref(dom_node, 'osc')
-        self.add_module('lustre/osc', 'osc')
-       # should add lov only if needed
-        self.add_module('lustre/lov', 'lov')
+        self.add_module('lustre/mdc', 'mdc')
         self.add_module('lustre/llite', 'llite')
+        l = lookup(self.dom_node.parentNode, self.lov_uuid)
+        self.osc = VOSC(l)
 
     def prepare(self):
-        l = lookup(self.dom_node.parentNode, self.lov_uuid)
-        if l.nodeName == 'lov':
-            lov = LOV(l)
-            for osc_uuid in lov.devlist:
-                osc = lookup(self.dom_node.parentNode, osc_uuid)
-                if osc:
-                    n = OSC(osc)
-                    n.prepare()
-                else:
-                    panic('osc not found:', osc_uuid)
-            lctl.newdev(attach="lov %s %s" % (lov.name, lov.uuid),
-                        setup ="%s" % (self.mdc_uuid))
-        else:
-            osc = OSC(l)
-            osc.prepare()
-            
-        self.info(self.path, self.mdc_uuid,self.lov_uuid)
+        self.osc.prepare()
+        mdc_uuid = prepare_mdc(self.dom_node.parentNode, self.mds_uuid)
+
+        self.info(self.path, self.mds_uuid,self.lov_uuid)
         cmd = "mount -t lustre_lite -o osc=%s,mdc=%s none %s" % \
-              (self.lov_uuid, self.mdc_uuid, self.path)
+              (self.lov_uuid, mdc_uuid, self.path)
         run("mkdir", self.path)
         ret, val = run(cmd)
         if ret:
             panic("mount failed:", self.path)
+
     def cleanup(self):
-        self.info(self.path, self.mdc_uuid,self.lov_uuid)
+        self.info(self.path, self.mds_uuid,self.lov_uuid)
         (rc, out) = run("umount", self.path)
         if rc:
             log("umount failed, cleanup will most likely not work.")
         l = lookup(self.dom_node.parentNode, self.lov_uuid)
-        if l.nodeName == 'lov':
-            lov = LOV(l)
-            for osc_uuid in lov.devlist:
-                osc = lookup(self.dom_node.parentNode, osc_uuid)
-                if osc:
-                    n = OSC(osc)
-                    n.cleanup()
-                else:
-                    panic('osc not found:', osc_uuid)
-            lov.cleanup()
-        else:
-            osc = OSC(l)
-            osc.cleanup()
-            
+        self.osc.cleanup()
+        cleanup_mdc(self.dom_node.parentNode, self.mds_uuid)
+
+    def load_module(self):
+        self.osc.load_module()
+        Module.load_module(self)
+    def cleanup_module(self):
+        Module.cleanup_module(self)
+        self.osc.cleanup_module()
+
 
 # ============================================================
 # XML processing and query
@@ -1060,7 +1134,7 @@ def getServiceLevel(dom_node):
         return 40
     elif type in ('mdc','osc'):
         return 50
-    elif type in ('lov',):
+    elif type in ('lov', 'lovconfig'):
         return 60
     elif type in ('mountpoint',):
         return 70
@@ -1090,7 +1164,35 @@ def getByName(lustreNode, name, tag):
     return None
     
 
-
+############################################################
+# MDC UUID hack - 
+# FIXME: clean this mess up!
+#
+mdc_uuid = None
+def prepare_mdc(dom_node, mds_uuid):
+    global mdc_uuid
+    mds_node = lookup(dom_node, mds_uuid);
+    if not mds_node:
+        panic("no mds:", mds_uuid)
+    if mdc_uuid:
+        return mdc_uuid
+    mdc = MDC(mds_node)
+    mdc.prepare()
+    mdc_uuid = mdc.uuid
+    return mdc_uuid
+
+mdc_cleaned = None
+def cleanup_mdc(dom_node, mds_uuid):
+    global mdc_cleaned
+    mds_node = lookup(dom_node, mds_uuid);
+    if not mds_node:
+        panic("no mds:", mds_uuid)
+    if not mdc_cleaned:
+        mdc = MDC(mds_node)
+        mdc.cleanup()
+        mdc_uuid = None
+        mdc_cleaned = 'yes'
+        
 
 ############################################################
 # routing ("rooting")
@@ -1181,6 +1283,8 @@ def startService(dom_node, module_flag):
         n = LDLM(dom_node)
     elif type == 'lov':
         n = LOV(dom_node)
+    elif type == 'lovconfig':
+        n = LOVConfig(dom_node)
     elif type == 'network':
         n = Network(dom_node)
     elif type == 'obd':
@@ -1190,7 +1294,7 @@ def startService(dom_node, module_flag):
     elif type == 'mds':
         n = MDS(dom_node)
     elif type == 'osc':
-        n = OSC(dom_node)
+        n = VOSC(dom_node)
     elif type == 'mdc':
         n = MDC(dom_node)
     elif type == 'mountpoint':

diff --git a/lustre/utils/lmc b/lustre/utils/lmc
index c376b99..c53a210 100755 (executable)
--- a/lustre/utils/lmc
+++ b/lustre/utils/lmc
@@ -78,14 +78,10 @@ Commands:
    Create a MDS using the device
    Requires --node 
 
---lov lov_name [mdc_name stripe_sz stripe_off pattern]
+--lov lov_name [mds_name stripe_sz stripe_off pattern]
    Creates a logical volume
    When used with other commands, it specifics the lov to modify
 
---mdc mdc_name
-   Configures a MDC for a node.
-   Requires --node 
-
 --ost device [size]
    Creates an OBD/OST/OSC configuration triplet for a new device.
    When used on "host", the device will be initialized and the OST
@@ -267,6 +263,11 @@ class GenConfig:
         devs.setAttribute("pattern", pattern)
         return lov
 
+    def lovconfig(self, name, uuid, lov_uuid):
+        lovconfig = self.newService("lovconfig", name, uuid)
+        lovconfig.appendChild(self.ref("lov", lov_uuid))
+        return lovconfig
+
     def mds(self, name, uuid, fs, devname, format, net_uuid, node_uuid,
             failover_uuid = "", dev_size=0 ):
         mds = self.newService("mds", name, uuid)
@@ -281,14 +282,9 @@ class GenConfig:
             mds.appendChild(self.ref("failover", failover_uuid))
         return mds
 
-    def mdc(self, name, uuid, mds_uuid):
-        mdc = self.newService("mdc", name, uuid)
-        mdc.appendChild(self.ref("mds", mds_uuid))
-        return mdc
-
-    def mountpoint(self, name, uuid, mdc_uuid, osc_uuid, path):
+    def mountpoint(self, name, uuid, mds_uuid, osc_uuid, path):
         mtpt = self.newService("mountpoint", name, uuid)
-        mtpt.appendChild(self.ref("mdc", mdc_uuid))
+        mtpt.appendChild(self.ref("mds", mds_uuid))
         mtpt.appendChild(self.ref("osc", osc_uuid))
         self.addElement(mtpt, "path", path)
         return mtpt
@@ -490,9 +486,7 @@ def add_mds(gen, lustre, options, args):
     else:
         size = 0
 
-    mdc_name = 'MDC_' + mds_name
     mds_uuid = new_uuid(mds_name)
-    mdc_uuid = new_uuid(mdc_name)
 
     node_uuid = name2uuid(lustre, node_name)
 
@@ -505,30 +499,9 @@ def add_mds(gen, lustre, options, args):
 
     mds = gen.mds(mds_name, mds_uuid, "extN", devname, get_format_flag(options),
                   net_uuid, node_uuid, dev_size=size)
-    mdc = gen.mdc(mdc_name, mdc_uuid, mds_uuid)
     lustre.appendChild(mds)
-    lustre.appendChild(mdc)
                    
 
-def add_mdc(gen, lustre, options, args):
-    """ create mtpt on a node """
-    if len(args) < 1:
-        usage()
-
-    if options.has_key('node'):
-        node_name = options['node']
-    else:
-        error("--mdc requires a --node argument")
-
-    mdc_name = args[0]
-    mdc_uuid = name2uuid(lustre, mdc_name)
-
-    node = findByName(lustre, node_name, "node")
-    if not node:
-            error('node:',  node_name, "not found.")
-    node_add_profile(gen, node, "mdc", mdc_uuid)
-
-
 def add_ost(gen, lustre, options, args):
     lovname = ''
     obdtype = 'obdfilter'
@@ -618,11 +591,17 @@ def add_lov(gen, lustre, options, args):
         error("LOV: ", name, " already exists.")
 
     mds_uuid = name2uuid(lustre, mds_name)
-
-    node = mds2node(lustre, mds_name)
-    node_add_profile(gen, node, "lov", uuid)
     lov = gen.lov(name, uuid, mds_uuid, stripe_sz, stripe_off, pattern)
     lustre.appendChild(lov)
+    
+    # add an lovconfig entry to the mds profile
+    lovconfig_name = new_name('LVCFG_' + name)
+    lovconfig_uuid = new_uuid(lovconfig_name)
+    node = mds2node(lustre, mds_name)
+    node_add_profile(gen, node, "lovconfig", lovconfig_uuid)
+    lovconfig = gen.lovconfig(lovconfig_name, lovconfig_uuid, uuid)
+    lustre.appendChild(lovconfig)
+
 
 
 def add_mtpt(gen, lustre, options, args):
@@ -638,7 +617,6 @@ def add_mtpt(gen, lustre, options, args):
     path = args[0]
     mds_name = args[1]
     lov_name = args[2]
-    mdc_name = 'MDC_' + mds_name
 
     name = new_name('MNT_'+ node_name)
 
@@ -646,18 +624,17 @@ def add_mtpt(gen, lustre, options, args):
     if ret:
         error("MOUNTPOINT: ", name, " already exists.")
 
-    mdc_uuid = name2uuid(lustre, mdc_name)
+    mds_uuid = name2uuid(lustre, mds_name)
     lov_uuid = name2uuid(lustre, lov_name, tag='lov', fatal=0)
     if not lov_uuid:
         lov_uuid = name2uuid(lustre, lov_name, tag='osc', fatal=1)
 
     uuid = new_uuid(name)
-    mtpt = gen.mountpoint(name, uuid, mdc_uuid, lov_uuid, path)
+    mtpt = gen.mountpoint(name, uuid, mds_uuid, lov_uuid, path)
     node = findByName(lustre, node_name, "node")
     if not node:
             error('node:',  node_name, "not found.")
     node_add_profile(gen, node, "mountpoint", uuid)
-    node_add_profile(gen, node, "mdc", mdc_uuid)
     lustre.appendChild(mtpt)
 
 
@@ -667,7 +644,7 @@ def add_mtpt(gen, lustre, options, args):
 def parse_cmdline(argv):
     short_opts = "ho:i:m:"
     long_opts = ["ost", "osc", "mtpt", "lov=", "node=", "mds=", "net", "tcpbuf=",
-                 "mdc", "route", "router", "merge=", "format", "reformat", "output=",
+                 "route", "router", "merge=", "format", "reformat", "output=",
                  "obdtype=", "in=", "help"]
     opts = []
     args = []
@@ -689,8 +666,6 @@ def parse_cmdline(argv):
             options['osc'] = 1
         if o == "--mds":
             options['mds'] = a
-        if o == "--mdc":
-            options['mdc'] = 1
         if o == "--net":
             options['net'] = 1
         if o == "--mtpt":
@@ -774,8 +749,6 @@ def main():
         add_mtpt(gen, lustre, options, args)
     elif options.has_key('mds'):
         add_mds(gen, lustre, options, args)
-    elif options.has_key('mdc'):
-        add_mdc(gen, lustre, options, args)
     elif options.has_key('net'):
         add_net(gen, lustre, options, args)
     elif options.has_key('lov'):