home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 7 / 07.iso / c / c004 / 1.ddi / CTSLOK.C < prev    next >
Encoding:
C/C++ Source or Header  |  1989-04-18  |  6.6 KB  |  296 lines
  1. /*
  2.  *    c-tree Server Lock Routines
  3.  *
  4.  *    This program is the CONFIDENTIAL and PROPRIETARY property 
  5.  *    of FairCom(R) Corporation. Any unauthorized use, reproduction or
  6.  *    transfer of this program is strictly prohibited.
  7.  *
  8.  *      Copyright (c) 1985, 1986, 1987, 1988, 1989 FairCom Corporation
  9.  *    (Subject to limited distribution and
  10.  *     restricted disclosure only.)
  11.  *    *** ALL RIGHTS RESERVED ***
  12.  *
  13.  *    4006 West Broadway
  14.  *    Columbia, MO 65203
  15.  *
  16.  *
  17.  *    c-tree(R)    Version 4.3
  18.  *            Release C
  19.  *            February 7, 1989 17:30
  20.  *
  21.  */
  22.  
  23. #include "ctstdr.h"        /* standard i/o header         */
  24. #include "ctoptn.h"        /* c-tree configuration options */
  25. #include "cterrc.h"        /* c-tree error codes        */
  26. #include "ctstrc.h"        /* c-tree data structures    */
  27. #include "ctgvar.h"        /* c-tree global variables    */
  28. #include "ctcomm.h"
  29.  
  30. #ifdef CTSERVER
  31.  
  32. extern SSTATUS cts_stat;
  33.  
  34. #define cts_wl    cts_stat.scts_wl
  35. #define cts_rl    cts_stat.scts_rl
  36. #define cts_ul    cts_stat.scts_ul
  37.  
  38. COUNT uerr();
  39.  
  40. extern COUNT cur_usrid;
  41.  
  42. LOCAL RECLOK *poplst()
  43. {
  44.     FAST RECLOK *retval;
  45.  
  46.     if ((retval = ct_frelst) == (RECLOK *) NULL)
  47.         uerr_cod = SFRE_ERR;
  48.     else
  49.         ct_frelst = ct_frelst->rllink;
  50.     return(retval);
  51. }
  52.  
  53. VOID pshlst(  plok,ctnum)
  54. PFAST RECLOK *plok;
  55. PFAST CTFILE      *ctnum;
  56. {
  57.     RECLOK        *prvlst,*nxtlst;
  58.  
  59.     if ((prvlst = plok->rlrlnk) == NULL) {
  60.         if (ctnum->rlokh != plok)
  61.             terr(980);
  62.     } else {
  63.         if (prvlst->rllink != plok)
  64.             terr(981);
  65.     }
  66.     if ((nxtlst = plok->rllink) == NULL) {
  67.         if (ctnum->rlokt != plok)
  68.             terr(982);
  69.     } else {
  70.         if (nxtlst->rlrlnk != plok)
  71.             terr(983);
  72.     }
  73.  
  74.     if (prvlst != NULL)
  75.         prvlst->rllink = nxtlst;
  76.     else
  77.         ctnum->rlokh   = nxtlst;
  78.     if (nxtlst != NULL)
  79.         nxtlst->rlrlnk = prvlst;
  80.     else
  81.         ctnum->rlokt   = prvlst;
  82.  
  83.     plok->rllink = ct_frelst;
  84.     ct_frelst       = plok;
  85. }
  86.  
  87. COUNT cts_lok(usrn,filno,loktyp,mode,recbyt)
  88. COUNT          usrn,filno,loktyp,mode;
  89. POINTER                          recbyt;
  90. {
  91.     FAST RECLOK *pp,*cp;
  92.     RECLOK        *np;
  93.     FAST CTFILE *ctnum;
  94.  
  95.     ctnum = ct_key + filno;
  96.  
  97.     /* check for empty lock list */
  98.     if ((cp = ctnum->rlokh) == NULL) {
  99.         if (mode == CHK_LOCK)
  100.             return(NO_ERROR);
  101.         if (mode == MST_LOCK)
  102.             return(DADV_ERR);
  103.         if ((cp = poplst()) == NULL)
  104.             return(uerr_cod);
  105.         ctnum->rlokh = ctnum->rlokt = cp;
  106.         cp->rllink   = cp->rlrlnk   = NULL;
  107.         goto lokret;
  108.     }
  109.  
  110.     /* check for lock past last existing lock */
  111.     if (recbyt > ctnum->rlokt->rlbpos) {
  112.         if (mode == CHK_LOCK)
  113.             return(NO_ERROR);
  114.         if (mode == MST_LOCK)
  115.             return(DADV_ERR);
  116.         if ((cp = poplst()) == NULL)
  117.             return(uerr_cod);
  118.         cp->rlrlnk          = ctnum->rlokt;
  119.         cp->rllink         = NULL;
  120.         ctnum->rlokt->rllink = cp;
  121.         ctnum->rlokt         = cp;
  122.         goto lokret;
  123.     }
  124.  
  125.     /* check for insertion into lock list */
  126.     cp = ctnum->rlokh;
  127.     pp = NULL;
  128.     while (cp != NULL && cp->rlbpos < recbyt) {
  129.         pp = cp;
  130.         cp = cp->rllink;
  131.     }
  132.     if (cp == NULL)
  133.         terr(984);
  134.  
  135.     if (cp->rlbpos == recbyt) {
  136.         if (cp->rlusrn != usrn) {
  137.             if (mode != ADD_LOCK)
  138.                 return(DADV_ERR);
  139.             if (cp->rltype == CTWRITE || loktyp == CTWRITE)
  140.                 return(DLOK_ERR);
  141.             /* else read lock: check if user further along list */
  142.             np = cp->rllink;
  143.             while (np && np->rlbpos == recbyt) {
  144.                 if (np->rlusrn == usrn)
  145.                     return(NO_ERROR);
  146.                 np = np->rllink;
  147.             }
  148.             /* else drop through to add lock in front of tie */
  149.         } else if (mode != ADD_LOCK) {
  150.             /* position & user agree: check for read lock */
  151.             if (cp->rltype == CTREAD && (mode == MST_LOCK ||
  152.                 (cp->rllink != NULL &&
  153.                  cp->rllink->rlbpos == recbyt)))
  154.                 return(DADV_ERR);
  155.             else
  156.                 return(NO_ERROR);
  157.         } else if (cp->rltype == loktyp || (cp->rltype == CTWRITE &&
  158.             loktyp == CTREAD)) {
  159.             cp->rltype = loktyp;
  160.             return(NO_ERROR);
  161.         } else { /* check for other user at same location */
  162.             np = cp->rllink;
  163.             if (np == NULL || np->rlbpos > recbyt) {
  164.                 cp->rltype = loktyp;
  165.                 return(NO_ERROR);
  166.             } else
  167.                 return(DLOK_ERR);
  168.         }
  169.     }
  170.  
  171.     /* if testing lock, check test mode */
  172.     if (mode == CHK_LOCK)
  173.         return(NO_ERROR);
  174.     if (mode == MST_LOCK)
  175.         return(DADV_ERR);
  176.  
  177.     /* cp->rlbpos > recbyt || insert in front of tie */
  178.     np = cp;
  179.     if ((cp = poplst()) == NULL)
  180.         return(uerr_cod);
  181.     if (pp == NULL)
  182.         ctnum->rlokh = cp;
  183.     else
  184.         pp->rllink = cp;
  185.     cp->rlrlnk = pp;
  186.     cp->rllink = np;
  187.     np->rlrlnk = cp;
  188.     /* goto lokret */
  189.  
  190. lokret:
  191.     cp->rlusrn = usrn;
  192.     cp->rlbpos = recbyt;
  193.     cp->rltype = loktyp;
  194.     return(NO_ERROR);
  195. }
  196.  
  197. LOCAL COUNT dellst(usrn,filno,recbyt)
  198. COUNT           usrn,filno;
  199. POINTER                  recbyt;
  200. {
  201.     FAST RECLOK *cp;
  202.     FAST CTFILE *ctnum;
  203.  
  204.     ctnum = ct_key + filno;
  205.     cp    = ctnum->rlokh;
  206.  
  207.     while (cp != NULL && cp->rlbpos < recbyt)
  208.         cp = cp->rllink;
  209.     if (cp == NULL || cp->rlbpos != recbyt)
  210.         return(UDLK_ERR);
  211.  
  212.     while (cp != NULL && cp->rlbpos == recbyt && cp->rlusrn != usrn)
  213.         cp = cp->rllink;
  214.     if (cp == NULL || cp->rlbpos != recbyt)
  215.         return(UDLK_ERR);
  216.  
  217.     pshlst(cp,ctnum);
  218.     return(NO_ERROR);
  219. }
  220.  
  221. /* --------------------------------------------------------------------
  222.    LOCK index node
  223.  */
  224.  
  225. COUNT LOCK(node,knum)    /* node == 0  => header */
  226. LONG       node;
  227. PFAST KEYFILE  *knum;
  228. {
  229.     return(NO_ERROR);
  230. }
  231.  
  232. /* --------------------------------------------------------------------
  233.    UNLOCK index file node
  234. */
  235.  
  236. COUNT UNLOCK(node,knum)
  237. LONG         node;
  238. PFAST KEYFILE    *knum;
  239. {
  240.     return(NO_ERROR);
  241. }
  242.  
  243.  
  244. /* --------------------------------------------------------------------
  245.    write LOCK data record
  246.  */
  247.  
  248. COUNT DLOCK(recbyt,dnum)        /* recbyt == 0  => header record */
  249. POINTER     recbyt;
  250. PFAST DATFILE      *dnum;
  251. {
  252.  
  253. /*
  254.  * the data record ct_locks are NOT guaranteed to be deadlock free.  Therefore,
  255.  * except for the header record which is only locked by internal c-tree 
  256.  * maintenance requests, the data record lock routine returns instead of
  257.  * sleeping when a lock is denied because of a competing lock.  The application
  258.  * program must deal with the appropriate action if a lock is denied to a
  259.  * data record.
  260.  */
  261.  
  262.     cts_wl++;
  263.     return(uerr_cod = cts_lok(cur_usrid,dnum->filnum,CTWRITE,
  264.         ADD_LOCK,recbyt));
  265. }
  266.  
  267. /* --------------------------------------------------------------------
  268.    read LOCK data record
  269.  */
  270.  
  271. COUNT RLOCK(recbyt,dnum)        /* recbyt == 0  => header record */
  272. POINTER     recbyt;
  273. PFAST DATFILE      *dnum;
  274. {
  275.     cts_rl++;
  276.     return(uerr_cod = cts_lok(cur_usrid,dnum->filnum,CTREAD,
  277.         ADD_LOCK,recbyt));
  278. }
  279.  
  280.  
  281. /* --------------------------------------------------------------------
  282.    UNLOCK data record
  283. */
  284.  
  285. COUNT UDLOCK(recbyt,dnum)
  286. POINTER         recbyt;
  287. PFAST DATFILE       *dnum;
  288. {
  289.     cts_ul++;
  290.     return(uerr_cod = dellst(cur_usrid,dnum->filnum,recbyt));
  291. }
  292.  
  293. #endif
  294.  
  295. /* end of ctslok.c */
  296.