Example #1
0
static void lockMountServers(gdb_sNode* np)
{
  pwr_tStatus sts;
  pool_sQlink* msl;
  pool_sQlink* vl;
  gdb_sVolume* vp;
  gdb_sMountServer* msp;
  gdb_sObject* op;

  gdb_AssumeLocked;

  for (vl = pool_Qsucc(NULL, gdbroot->pool, &np->own_lh); vl != &np->own_lh;
       vl = pool_Qsucc(NULL, gdbroot->pool, vl)) {
    vp = pool_Qitem(vl, gdb_sVolume, l.own_ll);

    if (vl->self == vl->flink) {
      /* Connection lost and volume removed from own list */
      errh_Error("Volume not owned any more, %s", vp->g.name.orig);
      return;
    }
    if (!vp->l.flags.b.isConnected) {
      /* !!! Todo !!! How do we make this known ?  */
      errh_Error("Volume not connected, %s", vp->g.name.orig);
      continue;
    }

    for (msl = pool_Qsucc(NULL, gdbroot->pool, &vp->l.volms_lh);
         msl != &vp->l.volms_lh; msl = pool_Qsucc(NULL, gdbroot->pool, msl)) {
      msp = pool_Qitem(msl, gdb_sMountServer, volms_ll);
      op = hash_Search(&sts, gdbroot->oid_ht, &msp->oid);
      if (op == NULL) {
        op = cvolc_OidToObject(
            &sts, vp, msp->oid, vol_mTrans_none, cvol_eHint_none);
        if (op == NULL) {
          errh_Error("Can't fetch the mount server's object, %s",
              cdh_ObjidToString(msp->oid, 0));
          /* !!! Todo !!! How do we make this error known ?  */
          continue;
        }
      }
      msp->msor = pool_ItemReference(NULL, gdbroot->pool, op);
      op->l.flags.b.isMountServer = 1;
      if (msp->nodms_ll.self == msp->nodms_ll.flink
          && msp->nodms_ll.self == msp->nodms_ll.blink)
        pool_QinsertPred(NULL, gdbroot->pool, &msp->nodms_ll, &np->nodms_lh);

      /* if (0)
        errh_Info("Locking object %s", op->g.f.name.orig); */
      cvolc_LockObject(&sts, op);
    }
  }
}
Example #2
0
dl_sLink *
dl_Create (
  pwr_tStatus		*sts,
  mvol_sAttribute	*ap,
  pwr_sAttrRef		*arp
)
{
  pwr_tStatus		lsts;
  dl_sLink		*dp;
  dl_sLink		*rdp;

  gdb_AssumeLocked;

  pwr_Assert(ap != NULL);
  pwr_Assert(ap->op != NULL);
  pwr_Assert(arp != NULL);

  dp = pool_Alloc(NULL, gdbroot->pool, sizeof(dl_sLink));

  do {
    gdbroot->db->dlid.rix++;
    dp->dlid = gdbroot->db->dlid;

    rdp = hash_Insert(&lsts, gdbroot->subc_ht, dp);
    if (rdp != dp && lsts != HASH__DUPLICATE)
      errh_Bugcheck(lsts, "hash_Insert");
  } while (rdp != dp);

  dp->user = gdbroot->my_pid;
  dp->aref = *arp;
  dp->opr   = pool_ItemReference(NULL, gdbroot->pool, ap->op);


  /* Lock the object */

  gdb_LockObject(sts, ap->op);

  /* Insert in list of direct links */

  pool_QinsertSucc(NULL, gdbroot->pool, &dp->dl_ll, &gdbroot->db->dl_lh);
  gdbroot->db->dl_lc++;

  return dp;
}
Example #3
0
static gdb_sNode *
testClient (
    pwr_tStatus		*sts,
    sub_sClient		*cp
)
{
    pwr_tStatus		lsts = GDH__SUCCESS;
    pwr_tSubid		sid = cp->sid;
    cdh_sParseName	parseName;
    cdh_sParseName	*pn;
    gdb_sObject		*op = NULL;
    sub_sClient		*rcp;
    gdb_sVolume		*vp;
    gdb_sNode		*np = NULL;
    mvol_sAttribute	attribute;
    mvol_sAttribute	*ap;
    pwr_sAttrRef		*arp;
    pwr_sAttrRef		*rarp;
    gdb_sCclass		*ccp;
    gdb_sCclass		*ccpLocked;
    pool_tRef		ccr;
    pwr_tUInt32		ridx;
    pwr_tBoolean		equal;
    pwr_tBoolean		fetched;



    gdb_AssumeLocked;

    do {
        if (cp->sub_by_name) {	/* Lookup by name.  */

            pn = cdh_ParseName(&lsts, &parseName, pwr_cNObjid, cp->name, 0);
            if (pn == NULL) break;

            do {
                ap = vol_NameToAttribute(&lsts, &attribute, pn, gdb_mLo_global, vol_mTrans_all);
                if (ap == NULL) break;
                rcp = hash_Search(sts, gdbroot->subc_ht, &sid);
                if (rcp != cp) break;	/* Subscription client no longer exists! */
                arp = mvol_AttributeToAref(&lsts, ap, &cp->aref);
                if (arp == NULL) break;
                op = ap->op;

                /* */
                vp = pool_Address(NULL, gdbroot->pool, op->l.vr);
                np = hash_Search(&lsts, gdbroot->nid_ht, &vp->g.nid);
                if (np == NULL) {
                    op = NULL;
                    break;
                }

                ccp = NULL;
                equal = 1;

                /* Get cached class if needed */
                if (!op->u.c.flags.b.classChecked || !op->u.c.flags.b.classEqual) {
                    ccp = cmvolc_GetCachedClass(&lsts, np, vp, ap, &equal, &fetched, NULL);
                    if (EVEN(lsts)) {
                        np = NULL;
                        op = NULL;
                        break;
                    }

                    if (fetched) {
                        rcp = hash_Search(sts, gdbroot->subc_ht, &sid);
                        if (rcp != cp) break;	/* Subscription client no longer exists! */
                    }


                    if (equal) {
                        if (cp->cclass != pool_cNRef) {
                            ccp = pool_Address(NULL, gdbroot->pool, cp->cclass);
                            if (ccp == NULL) errh_Bugcheck(GDH__WEIRD, "cached class address");
                            cmvolc_UnlockClass(NULL, ccp);
                            cp->cclass = pool_cNRef;
                        }
                        ccp = NULL;
                    } else {
                        ccr = pool_ItemReference(NULL, gdbroot->pool, ccp);
                        if (ccr == pool_cNRef) errh_Bugcheck(GDH__WEIRD, "cache class address to reference");


                        if (ccr != cp->cclass) {
                            if (cp->cclass != pool_cNRef) {
                                gdb_sCclass *cc2p = pool_Address(NULL, gdbroot->pool, cp->cclass);
                                cmvolc_UnlockClass(NULL, cc2p);
                            }

                            cmvolc_LockClass(NULL, ccp);
                            cp->cclass = ccr;
                        }
                    }


                    /* If gdb has been unlocked, refresh pointers */
                    /** @todo Check if we can do it more efficient, eg. vol_ArefToAttribute */
                    if (fetched) {
                        np = NULL;
                        op = NULL;
                        continue;
                    }
                }

                break;
            } while (1);

        } else {			/* Lookup by attribute reference.  */
            do {

                op = vol_OidToObject(&lsts, cp->aref.Objid, gdb_mLo_global, vol_mTrans_all, cvol_eHint_none);
                if (op == NULL) {
                    lsts = GDH__NOSUCHOBJ;
                    break;
                }
                rcp = hash_Search(sts, gdbroot->subc_ht, &sid);
                if (rcp != cp) break;	/* Subscription client no longer exists! */

                if (op->g.flags.b.isAliasServer) cp->aref.Objid = op->g.oid;
                /* This is a not to ugly fix, but it should be removed, LW.
                   It's done to make Leif-Göran Hansson happier. I.e. it makes
                   the linksup program work. */
                cp->aref.Objid = op->g.oid;

                vp = pool_Address(NULL, gdbroot->pool, op->l.vr);
                np = hash_Search(&lsts, gdbroot->nid_ht, &vp->g.nid);
                if (np == NULL) {
                    op = NULL;
                    break;
                }

                ccp = NULL;
                equal = 1;

                /* Get cached class if needed */
                if (!op->u.c.flags.b.classChecked || !op->u.c.flags.b.classEqual) {
                    ap = vol_ArefToAttribute(&lsts, &attribute, &cp->aref, gdb_mLo_global, vol_mTrans_all);
                    if (ap == NULL) break;
                    ccp = cmvolc_GetCachedClass(&lsts, np, vp, ap, &equal, &fetched, NULL);
                    if (EVEN(lsts)) {
                        np = NULL;
                        op = NULL;
                        break;
                    }

                    if (fetched) {
                        rcp = hash_Search(sts, gdbroot->subc_ht, &sid);
                        if (rcp != cp) break;	/* Subscription client no longer exists! */
                    }


                    if (equal) {
                        if (cp->cclass != pool_cNRef) {
                            ccp = pool_Address(NULL, gdbroot->pool, cp->cclass);
                            if (ccp == NULL) errh_Bugcheck(GDH__WEIRD, "cached class address");
                            cmvolc_UnlockClass(NULL, ccp);
                            cp->cclass = pool_cNRef;
                        }
                        ccp = NULL;
                    } else {
                        ccr = pool_ItemReference(NULL, gdbroot->pool, ccp);
                        if (ccr == pool_cNRef) errh_Bugcheck(GDH__WEIRD, "cache class address to reference");


                        if (ccr != cp->cclass) {
                            if (cp->cclass != pool_cNRef) {
                                gdb_sCclass *cc2p = pool_Address(NULL, gdbroot->pool, cp->cclass);
                                cmvolc_UnlockClass(NULL, cc2p);
                            }

                            cmvolc_LockClass(NULL, ccp);
                            cp->cclass = ccr;
                        }
                    }


                    /* If gdb has been unlocked, refresh pointers */
                    /** @todo Check if we can do it more efficient, eg. vol_ArefToAttribute */
                    if (fetched) {
                        np = NULL;
                        op = NULL;
                        continue;
                    }
                }

                break;
            } while (1);

        }
    } while (0);

    /* There is a risk that the client has disappeared after these
       calls (can result in a cache lookup). Verify that it still exists...  */

    rcp = hash_Search(sts, gdbroot->subc_ht, &sid);
    if (rcp == cp) {	/* OK, it exists! */
        cp->sts = lsts;
        if (op != NULL) {
            if (gdbroot->db->log.b.sub) errh_Info("Test client %s", op->g.f.name.orig);
            vp = pool_Address(NULL, gdbroot->pool, op->l.vr);
            np = pool_Address(NULL, gdbroot->pool, vp->l.nr);

            if (!equal) {
                ccpLocked = ccp;
                rarp = ndc_NarefToRaref(sts, ap, arp, ccp, &ridx, &cp->raref, &equal, NULL, ccpLocked, vp, np );
                if (rarp == NULL || equal) {
                    if (ccp->flags.b.cacheLock)
                        cmvolc_UnlockClass(NULL, ccp);
                    cp->cclass = pool_cNRef;
                    if (rarp == NULL)
                        np = gdbroot->no_node;
                } else {
                    if (!ccp->flags.b.rnConv) {
                        ndc_sRemoteToNative	*tbl;
                        gdb_sClass 	*c = hash_Search(sts, gdbroot->cid_ht, &ccp->key.cid);
                        if (c == NULL) errh_Bugcheck(GDH__WEIRD, "can't get class");

                        tbl = pool_Alloc(sts, gdbroot->pool, sizeof(*tbl) * c->acount);

                        ndc_UpdateRemoteToNativeTable(sts, tbl, c->acount, c, ccp, np->nid);
                        if (ODD(*sts)) {
                            ccp->rnConv = pool_Reference(NULL, gdbroot->pool, tbl);
                            ccp->flags.b.rnConv = 1;
                        } else {
                            pool_Free(NULL, gdbroot->pool, tbl);
                            cmvolc_UnlockClass(NULL, ccp);
                            cp->cclass = pool_cNRef;
                            np = gdbroot->no_node;
                        }
                    }
                }
            } /* not equal class versions */

        } else {
            np = gdbroot->no_node;
        }
    }

    return np;
}
Example #4
0
void
subcm_Data (
  qcom_sGet		*get
)
{
  pwr_tStatus		sts;
  pwr_tTime		curtim;
  pool_tRef		mr;
  sub_sMessage		*mp;
  pwr_tUInt32		refcount = 0;
  pwr_tInt32		i;
  sub_sClient		*cp;
  pool_tRef		dr;
  net_sSubData		*dp;
  void			*adrs;
  gdb_sNode		*np;
  net_sSubRemove	*rp = NULL;
  qcom_sQid		tgt;
  gdb_sCclass		*ccp;
  ndc_sRemoteToNative	*tbl;
  int                   rsize;
  

  time_GetTime( &curtim);

  gdb_AssumeUnlocked;

  tgt.qix = net_cProcHandler;

  gdb_ScopeLock {

    /* Allocate space for, and store the message in the pool.  */

    mp = pool_Alloc(&sts, gdbroot->pool, sizeof(*mp) - sizeof(mp->msg) + get->size);
    if (mp == NULL) break;
    mr = pool_ItemReference(NULL, gdbroot->pool, mp);

    memcpy(&mp->msg, get->data, get->size);
    pool_Qinit(NULL, gdbroot->pool, &mp->subm_ll);
    pool_QinsertPred(NULL, gdbroot->pool, &mp->subm_ll, &gdbroot->db->subm_lh);
    gdbroot->db->subm_lc++;
    np = hash_Search(&sts, gdbroot->nid_ht, &mp->msg.hdr.nid);


    /* Check if message is corrupt */
    dp = (net_sSubData *)&mp->msg.subdata;
    for ( i=0; i < mp->msg.count; i++) {
      if ( (char *)dp > (char *)&mp->msg + get->size || (char *)dp < (char *)&mp->msg) {
	errh_Error( "Subscription client message corrupt");
	gdb_Unlock;
	return;
      }
      dp = (net_sSubData *)((unsigned long)&dp->data + dp->size);
    }

    /* Walk through every entry in the message buffer.  */
    for (
      i=0,
      dp = (net_sSubData *)&mp->msg.subdata,
      dr = mr + offsetof(sub_sMessage, msg.subdata);

      i < mp->msg.count;

      i++,
      dr += offsetof(net_sSubData, data) + (unsigned long)dp->size,
      dp = (net_sSubData *)((unsigned long)&dp->data + dp->size)
    ) {

      cp = hash_Search(&sts, gdbroot->subc_ht, &dp->sid);
      if (cp == NULL) {
	if (rp == NULL) {
	  rp = pool_Alloc(&sts, gdbroot->pool, sizeof(*rp)
	    + ((mp->msg.count - 1) * sizeof(rp->sid[0])));
	  if (rp == NULL)
	    continue;
	  tgt.nid = mp->msg.hdr.nid;
	}
	rp->sid[rp->count++] = dp->sid;
	continue;
      }

      /* If the client has an earlier reference to a message, then
	 remove that reference.
	 This can cause the old message to get disposed of.  */

      subc_RemoveFromMessage(cp);

      /* Now start filling in the client according to the new
	 information we just received...  */

      memcpy(&cp->lastupdate, &curtim, sizeof(curtim));
      cp->sts = dp->sts;
      cp->count++;

      if (ODD(dp->sts)) {
	cp->old	    = FALSE;	/* There is new, fresh, real data!  */
	cp->submsg  = mr;
	cp->subdata = dr;
	refcount++;

	if (1 || mp->msg.hdr.xdr) {
          if (cp->cclass == pool_cNRef) {
            gdb_sClass		*classp;
            cdh_uTypeId		cid;

            cid.pwr = cp->aref.Body;
            cid.c.bix = 0;	/* To get the class id.  */
            classp = hash_Search(&sts, gdbroot->cid_ht, &cid.pwr);
	    rsize = dp->size;

            if (classp != NULL)
              ndc_ConvertData(&sts, np, classp, &cp->aref, dp->data, dp->data, (pwr_tUInt32 *)&rsize, ndc_eOp_decode, cp->aref.Offset, 0);
	  }
          else {
            cp->old = TRUE;
            ccp = pool_Address(&cp->sts, gdbroot->pool, cp->cclass);
            if (ccp != NULL) {
              tbl = pool_Address(&cp->sts, gdbroot->pool, ccp->rnConv);
              if (tbl != NULL) {
	        rsize = dp->size;
                ndc_ConvertRemoteData(&cp->sts, np, ccp, &cp->raref, dp->data, dp->data, (pwr_tUInt32 *)&rsize, ndc_eOp_decode, cp->raref.Offset, 0);
                if (ODD(cp->sts))
                  cp->old = FALSE;
              }
            }
          }
          
	  /* !!! Todo !!! Error handling. */
	}

	/* If the userdata field contains a valid pool_tRef, then
	   copy the data. This poolref is resolved in RTDB!  */

	if (cp->userdata != pool_cNRef) {
	  adrs = pool_Address(NULL, gdbroot->rtdb, cp->userdata);
	  if (adrs != NULL) {
            if (cp->cclass == pool_cNRef)
              memcpy(adrs, dp->data, MIN(dp->size, cp->usersize));
            else if (!cp->old) {
              pwr_tUInt32  size = cp->usersize;
              pwr_tBoolean first = 1;
              ndc_ConvertRemoteToNativeTable(&cp->sts, ccp, tbl, &cp->raref, &cp->aref, adrs, dp->data, &size, 
                                             cp->aref.Offset, 0, 0, &first, np->nid);
              if (EVEN(cp->sts))
                cp->old = TRUE;
            }
	  }
	}
      }
    }

    /* Fill in count as the # of references in the 'message' header. This
       is the # of references that have to be removed before the 'message'
       can be returned to pool. If there are no references to the 'message'
       just dispose it!  */

    if (refcount != 0) {
      mp->msg.count = refcount;
    } else {
      pool_Qremove(NULL, gdbroot->pool, &mp->subm_ll);
      gdbroot->db->subm_lc--;
      pool_Free(NULL, gdbroot->pool, mp);
    }

  } gdb_ScopeUnlock;

  if (rp != NULL) { 
    tgt = np->handler;
    net_Put(NULL, &tgt, rp, net_eMsg_subRemove, 0, pwr_Offset(rp, sid[rp->count]), 0);
#if 0
    errh_Info("Removed %d subscriptions", rp->count - 1);
#endif
    pool_Free(NULL, gdbroot->pool, rp);
  }
}