home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 15 / 15.iso / s / s053 / 8.ddi / usr / include / sys / rf_comm.h < prev    next >
Encoding:
C/C++ Source or Header  |  1990-12-08  |  11.3 KB  |  406 lines
  1. /*    Copyright (c) 1990 UNIX System Laboratories, Inc.    */
  2. /*    Copyright (c) 1984, 1986, 1987, 1988, 1989, 1990 AT&T    */
  3. /*      All Rights Reserved      */
  4.  
  5. /*    THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF         */
  6. /*    UNIX System Laboratories, Inc.                         */
  7. /*    The copyright notice above does not evidence any       */
  8. /*    actual or intended publication of such source code.    */
  9.  
  10. #ifndef _SYS_RF_COMM_H
  11. #define _SYS_RF_COMM_H
  12.  
  13. #ident    "@(#)/usr/include/sys/rf_comm.h.sl 1.1 4.0 12/08/90 62021 AT&T-USL"
  14.  
  15. /* parameters of this implementation */
  16.  
  17. #define NADDRLEN    6    /* length of network address */
  18.  
  19. #define RF_UP        1    /* on network */
  20. #define RF_DOWN     0    /* not on network */
  21. #define RF_INTER     2    /* RFS in an intermediate state */
  22.  
  23. #ifndef TRUE
  24. #define TRUE    1
  25. #define FALSE    0
  26. #endif
  27.  
  28. #ifndef NULL
  29. #define NULL    0
  30. #endif
  31.  
  32. /* is a receive queue empty? */
  33. #define RCVDEMP(RD)    LS_ISEMPTY(&(RD)->rd_rcvdq)
  34.  
  35. typedef struct naddr    {
  36.     ushort    length;
  37.     char    address[NADDRLEN];
  38. } naddr_t;
  39.  
  40. /*
  41.  * receive descriptor structure
  42.  */
  43.  
  44. typedef struct rcvd    {
  45.     union {
  46.         /* vp for RDGENERAL, sdp for RDSPECIFIC */
  47.         struct vnode    *rdun_vp;
  48.         struct sndd    *rdun_sdp;
  49.     } rd_un;
  50.     ls_elt_t     rd_rcvdq;    /* receive descriptor queue */
  51.     time_t        rd_mtime;    /* last write time - for cache */
  52.     struct rd_user    *rd_user_list;    /* one for each time RD is a gift
  53.                      * - meaningful only for general RD */
  54.     struct rcvd    *rd_next;    /* pointer to next rcvd */
  55.     long        rd_gen;        /* generation for gifts */
  56.     int        rd_qslp;    /* recv desc queue sleep lock */
  57.     char        rd_stat;    /* flags */
  58.     char        rd_qtype;    /* RDGENERAL or RDSPECIFIC */
  59.     ushort        rd_qcnt;    /* how many msgs queued */
  60.     int        rd_refcnt;    /* how many remote clients */
  61. } rcvd_t;
  62.  
  63. #define rd_vp    rd_un.rdun_vp
  64. #define rd_sdp    rd_un.rdun_sdp
  65.  
  66. /* rd_stat values */
  67. #define RDUSED        0x1
  68. #define RDUNUSED    0x2
  69. #define RDLINKDOWN    0x4
  70. #define RDWANT        0x10
  71. #define RDLOCKED    0x20
  72.  
  73. /* rd_qtype */
  74. #define RDGENERAL    0x1
  75. #define RDSPECIFIC    0x2
  76.  
  77. /* active general and specific RDs */
  78. #define ACTIVE_GRD(rdp) \
  79.  ((rdp)->rd_stat & RDUSED && (rdp)->rd_qtype & RDGENERAL && (rdp)->rd_user_list)
  80. #define ACTIVE_SRD(rdp) \
  81.  ((rdp)->rd_stat & RDUSED && (rdp)->rd_qtype & RDSPECIFIC)
  82.  
  83. /*
  84.  * given a ptr to an rd, yield ptr to denoted sd
  85.  */
  86. #define RDTOSD(rdp)    ((rdp) ? (rdp)->rd_sdp : NULL)
  87. /*
  88.  * given a ptr to an rd, yield ptr to denoted vnode
  89.  */
  90. #define RDTOV(rdp)    ((rdp) ? (rdp)->rd_vp : NULLVP)
  91. /*
  92.  * given a ptr to a vnode, yield ptr to denoted rd
  93.  */
  94. #define VTORD(vp)    (vtord(vp))
  95.  
  96. extern rcvd_t    *rcvd;
  97.  
  98. /*
  99.  * A send descriptor is the send end of a channel to a
  100.  * remote system and contains a pointer to a virtual circuit that
  101.  * identifies the remote machine.
  102.  *
  103.  * On the client side the send descriptor is kept as the file system
  104.  * specific part (lower level) of the corresponding vnode for a persistent
  105.  * reference, and as a temporary channel for a transient reference.
  106.  *
  107.  * Each server has its own private send descriptor that it uses to
  108.  * send replies.  This send descriptor on the server does not point
  109.  * to any particular resource.
  110.  *
  111.  * For the client side send descriptor, the sd_mntid is a cookie
  112.  * used to access the remote side's resource list so that counts can
  113.  * be kept properly for umount.    In the server side send descriptor
  114.  * this same field is used as a cookie into the local resource list.
  115.  */
  116.  
  117. typedef struct sndd {
  118.     ls_elt_t     sd_hash;    /* for hash list links */
  119.     ls_elt_t    sd_free;    /* for free list links */
  120.     long        sd_size;
  121.     char        sd_stat;
  122.     rf_gift_t    sd_gift;    /* for the remote rcvd */
  123.     long         sd_mntid;    /* denotes remote srmount entry */
  124.     struct proc    *sd_srvproc;    /* points to proc of dedicated server */
  125.     struct queue    *sd_queue;    /* points to stream head queue */
  126.     long        sd_fhandle;    /* file handle for client caching */
  127.     ulong        sd_vcode;    /* file vcode for client caching */
  128.     daddr_t        sd_nextr;    /* read-ahead offset */
  129.     /*
  130.      * Clients talking to 3.x servers sometimes hide stuff in sd_stashp.
  131.      */
  132.     struct dustash    *sd_stashp;
  133.     /*
  134.      * Clients talking to 4.0++ servers remember their contribution to
  135.      * the server's v_count in sd_remcnt.
  136.      */
  137.     long        sd_remcnt;
  138.     struct {
  139.         int    want : 1;
  140.         int    writer : 1;
  141.         uint    nreaders;
  142.     } sd_crwlock;            /* n readers, 1 writer in cache */
  143.     struct vnode    sd_vn;        /* upper level node denoting sd */
  144. } sndd_t;
  145.  
  146. /*
  147.  * Values for sd_stat.  These must NOT be overloaded.
  148.  */
  149. #define SDUNUSED    0
  150. #define SDUSED        0x1
  151. #define SDLOCKED    0x2
  152. #define SDLINKDOWN    0x4
  153. #define SDSERVE        0x8
  154. #define SDWANT        0x10
  155. #define SDCACHE        0x20    /* remote file is cacheable */
  156. #define SDMNDLCK    0x40    /* remote file mandatory lock set
  157.                  * Old protocol only.
  158.                  * (not updated if someone turns off mandatory
  159.                  * lock with chmod on remote file before
  160.                  * last file close)
  161.                  */
  162. #define SDINTER        0x80
  163.  
  164. /*
  165.  * given a ptr to an sd, yield ptr to denoted vnode
  166.  */
  167. #define SDTOV(sdp)    (&(sdp)->sd_vn)
  168. /*
  169.  * given a ptr to a vnode, yield ptr to denoted sd
  170.  */
  171. #define VTOSD(vp)    ((struct sndd *)(vp)->v_data)
  172. /*
  173.  * yield the sd containing the referenced sd_hash or sd_free ls_elt_t
  174.  */
  175. #define HASHTOSD(hp)    \
  176.     ((sndd_t *)(((char *)(hp)) - (char *)&((sndd_t *)0)->sd_hash))
  177. #define FREETOSD(fp)    \
  178.     ((sndd_t *)(((char *)(fp)) - (char *)&((sndd_t *)0)->sd_free))
  179. /*
  180.  * Lock and unlock send descriptors.
  181.  */
  182. #define SDLOCK(sdp) {                \
  183.     while ((sdp)->sd_stat & SDLOCKED) {    \
  184.         (sdp)->sd_stat |= SDWANT;        \
  185.         (void) sleep((caddr_t)(sdp), PSNDD);\
  186.     }                    \
  187.     (sdp)->sd_stat |= SDLOCKED;        \
  188. }
  189.  
  190. #define SDUNLOCK(sdp) {                \
  191.     ASSERT((sdp)->sd_stat & SDLOCKED);    \
  192.     (sdp)->sd_stat &= ~SDLOCKED;        \
  193.     if ((sdp)->sd_stat & SDWANT) {        \
  194.         (sdp)->sd_stat &= ~SDWANT;        \
  195.         wakeprocs((caddr_t)(sdp), PRMPT);    \
  196.     }                    \
  197. }
  198.  
  199. extern sndd_t    *sndd;
  200. extern void    sndd_hash();
  201. extern void    sndd_unhash();
  202.  
  203. /*
  204.  * Every time a client creates a new reference to a file the
  205.  * server creates a reference to an rduser structure.    This
  206.  * server action can take two forms :
  207.  *    1) create a new rduser structure;
  208.  *    2) increment the ru_vcount.
  209.  * At the same time, the rd_refcnt is incremented.
  210.  * Each counted reference to an rduser structure contributes
  211.  * 1 to the v_count on that file on the server.
  212.  */
  213.  
  214. typedef struct rd_user {
  215.     long        ru_srmntid;    /* which srmount entry */
  216.     struct rd_user    *ru_next;    /* next user */
  217.     struct queue    *ru_queue;    /* which stream queue */
  218.     ushort        ru_vcount;    /* references to denoted vnode */
  219.     ushort        ru_gen;        /* generation number */
  220.     ushort        ru_frwcnt;    /* n r/w opens */
  221.     ushort        ru_frcnt;    /* n read opens */
  222.     ushort        ru_fwcnt;    /* n write opens */
  223.     ushort        ru_flag;    /* flag (see below for values) */
  224.     ls_elt_t    ru_mapdlist;    /* heads list of mapping descriptors */
  225. } rd_user_t;
  226.  
  227. /* ru_flag values */
  228. #define RU_CACHE_ON        0x1    /* remote cacheing is enabled */
  229. #define RU_CACHE_DISABLE    0x2    /* remote cacheing is disabled
  230.                      * as opposed to being off entirely
  231.                      * which is assumed when ru_flag
  232.                      * is 0.  This is only necessary
  233.                      * for old clients who only expect
  234.                      * vcode and fhandle with gifts.
  235.                      */
  236. #define RU_MAPDLOCK        0x4    /* ru_mapdlist is locked */
  237. #define RU_MAPDWANT        0x8    /* ru_mapdlist lock is wanted */
  238.  
  239. #define RU_R_CREAT        0x10    /* This client successfully created
  240.                      * this file for reading.
  241.                      */
  242. #define RU_W_CREAT        0x20    /* This client successfully created
  243.                      * this file for writing.
  244.                      */
  245. #define RU_DONE            0x40    /* When walking rd_user_list,
  246.                      * already processed
  247.                      */
  248.  
  249. /*
  250.  * Each rd_user_t has a list of rf_mapd_t's describing a client machine's
  251.  * mappings to a file.  rfm_prots counts the number of times that each
  252.  * combination of the PROT_READ, PROT_WRITE, and PROT_EXEC bits
  253.  * are used in the maxprot of mappings to an offset/length pair.
  254.  *
  255.  * NOTE: rfm_prots[0] is present as padding for coding convenience. 
  256.  * maxprot == 0 is disallowed by the vm/vfs interface.
  257.  */
  258. typedef struct rf_mapd {
  259.     ls_elt_t    rfm_list;    /* heads list of mapping descriptors */
  260.     off_t        rfm_off;    /* file offset of mapping */
  261.     size_t        rfm_len;    /* length of mapping */
  262.     uint        rfm_prots[8];    /* counts of R, W, RW, X, RX, WX, RWX */
  263. } rf_mapd_t;
  264.  
  265. extern rd_user_t    *rd_user;
  266.  
  267. /* tunables */
  268. extern int    nrcvd;        /* number of receive descriptors */
  269. extern int    nsndd;        /* number of send descriptors */
  270. extern int    nrduser;    /* number of rd_user entries */
  271. extern int    maxserve;
  272. extern int    minserve;
  273.  
  274. /*
  275.  * rf_maxkmem limits persistently allocated kernel memory used by rfs, including
  276.  * idmapping info, authorization lists and mapping descriptors.  A zero value
  277.  * means no limit.  rf_availkmem is the amount of the maximum remaining.
  278.  */
  279. extern int    rf_maxkmem;
  280. extern int    rf_availkmem;
  281.  
  282. #ifdef _KERNEL
  283.  
  284. extern void    rf_freeb();
  285. extern void    rf_freemsg();
  286.  
  287. extern mblk_t    *rf_dequeue();
  288.  
  289. extern int    sndd_create();
  290. extern void    sndd_free();
  291.  
  292. #if defined(DEBUG)
  293. #define sndd_set(sd, queue, giftp)                \
  294.     ((void)(ASSERT((sd)->sd_stat & SDUSED),            \
  295.       (sd)->sd_queue = (queue_t *)(queue), (sd)->sd_gift = (giftp)[0]))
  296. #else
  297. #define sndd_set(sd, queue, giftp)            \
  298.     ((void)((sd)->sd_queue = (queue_t *)(queue),    \
  299.         (sd)->sd_gift = (giftp)[0]))
  300. #endif /* DEBUG */
  301.  
  302. extern int    rf_sndmsg();
  303. extern        rf_rcvmsg();
  304.  
  305. extern int    rf_allocmsg();
  306. extern int    rf_allocb();
  307.  
  308. extern int    rcvd_create();
  309. extern void    rcvd_delete();
  310. extern void    rcvd_free();
  311. extern rcvd_t    *vtord();
  312.  
  313. extern mblk_t    *rf_dequeue();
  314. extern int    rf_comminit();
  315. extern void    rf_commdinit();
  316. extern void    rf_deliver();
  317.  
  318. #ifdef DEBUG
  319. extern int    rdu_match();
  320. #else
  321. #define rdu_match(rdup, sid, mntid) \
  322.   (QPTOGP((rdup)->ru_queue)->sysid == (sid) && (rdup)->ru_srmntid == (mntid))
  323. #endif
  324.  
  325. extern int    rfesb_fbread();
  326. extern int    rfesb_pageio_setup();
  327.  
  328. #define NULLFRP        ((frtn_t *)NULL)
  329. #define NULLCADDR    ((caddr_t)NULL)
  330. #define NULLUIO        ((uio_t *)NULL)
  331. #define NULLCRED    ((cred_t *)NULL)
  332.  
  333. /*
  334.  * Signal conversion ops.
  335.  *    rf_response_t    *rp;
  336.  *    int        vcver;    -- virtual circuit version
  337.  *    k_sigset_t    *kp;
  338.  */
  339. #define rf_sigisempty(rp, vcver)    \
  340.     ((vcver) == RFS1DOT0 ?    \
  341.       (rp)->rp_v1sig == 0 : (rp)->rp_v2sigset.word[0] == 0)
  342.  
  343. #define rf_setrpsigs(rp, vcver, kp)    \
  344.     ((void)((vcver) == RFS1DOT0 ?    \
  345.       ((rp)->rp_v1sig = (kp)[0]) : ((rp)->rp_v2sigset.word[0] = (kp)[0])))
  346.  
  347. #define rf_getrpsigs(rp, vcver, kp)    \
  348.     ((void)((vcver) == RFS1DOT0 ?    \
  349.       ((kp)[0] = (rp)->rp_v1sig) : ((kp)[0] = (rp)->rp_v2sigset.word[0])))
  350.  
  351. #define rf_clrrpsigs(rp, vcver)    \
  352.     ((void)((vcver) == RFS1DOT0 ?    \
  353.       ((rp)->rp_v1sig = 0) : ((rp)->rp_v2sigset.word[0] = 0)))
  354.  
  355. extern void    rf_postrpsigs();
  356. extern void    rf_delsig();
  357.  
  358. /*
  359.  * Operations on rd_user structures.
  360.  */
  361. extern rd_user_t    *rdu_get();
  362. extern rd_user_t    *rdu_find();
  363. extern void        rdu_del();
  364. extern void        rdu_open();
  365. extern int        rdu_modecheck();
  366.  
  367. extern void        rftov_attr();
  368. extern void        vtorf_attr();
  369. extern int        rf_pullupmsg();
  370. extern void        rf_iov_alloc();
  371. extern mblk_t        *rf_dropbytes();
  372. extern caddr_t        rf_msgdata();
  373.  
  374. extern rcvd_t    *rf_gifttord();
  375. extern vnode_t    *rf_gifttovp();
  376.  
  377. /* Gift templates. */
  378. extern rf_gift_t    rf_daemon_gift;
  379. extern rf_gift_t    rf_null_gift;
  380.  
  381. #define RF_IOV_FREE(iovp, niov)    \
  382.     kmem_free((caddr_t)(iovp), (size_t)((niov) * sizeof(iovec_t)))
  383.  
  384. /* fast for simple cases */
  385. #ifdef DEBUG
  386. #define RF_PULLUP(bp, hdrsz, datasz) \
  387.     (RF_MSG(bp)->m_size == (hdrsz) + (datasz) && !(bp)->b_cont ? \
  388.       (ASSERT((bp)->b_wptr - (bp)->b_rptr == RF_MSG(bp)->m_size), 0) : \
  389.       rf_pullupmsg((bp), (hdrsz), (datasz)))
  390. #else
  391. #define RF_PULLUP(bp, hdrsz, datasz) \
  392.     (RF_MSG(bp)->m_size == (hdrsz) + (datasz) && !(bp)->b_cont ? 0 : \
  393.       rf_pullupmsg((bp), (hdrsz), (datasz)))
  394. #endif
  395.  
  396. #if defined(u3b2) && !defined(lint) && !defined(CXREF)
  397. asm    int
  398. ipl()
  399. {
  400.     ANDW3 &0x1e000,%psw,%r0
  401. }
  402. #endif
  403.  
  404. #endif /* _KERNEL */
  405. #endif /* _SYS_RF_COMM_H */
  406.