home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / unix / volume21 / amd / part05 / mntfs.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-04-10  |  6.8 KB  |  307 lines
  1. /*
  2.  * $Id: mntfs.c,v 5.1.1.3 90/01/11 17:10:07 jsp Exp Locker: jsp $
  3.  *
  4.  * Copyright (c) 1990 Jan-Simon Pendry
  5.  * Copyright (c) 1990 Imperial College of Science, Technology & Medicine
  6.  * Copyright (c) 1990 The Regents of the University of California.
  7.  * All rights reserved.
  8.  *
  9.  * This code is derived from software contributed to Berkeley by
  10.  * Jan-Simon Pendry at Imperial College, London.
  11.  *
  12.  * Redistribution and use in source and binary forms are permitted
  13.  * provided that the above copyright notice and this paragraph are
  14.  * duplicated in all such forms and that any documentation,
  15.  * advertising materials, and other materials related to such
  16.  * distribution and use acknowledge that the software was developed
  17.  * by Imperial College of Science, Technology and Medicine, London, UK.
  18.  * The names of the College and University may not be used to endorse
  19.  * or promote products derived from this software without specific
  20.  * prior written permission.
  21.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
  22.  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  23.  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  24.  *
  25.  *    %W% (Berkeley) %G%
  26.  */
  27.  
  28. #include "am.h"
  29.  
  30. extern qelem mfhead;
  31. qelem mfhead = { &mfhead, &mfhead };
  32.  
  33. int mntfs_allocated;
  34.  
  35. /*
  36.  * This is the default attributes field which
  37.  * is copied into every new node to be created.
  38.  * The individual filesystem fs_init() routines
  39.  * patch the copy to represent the particular
  40.  * details for the relevant filesystem type
  41.  */
  42. static struct fattr gen_fattr = {
  43.     NFDIR,                /* type */
  44.     NFSMODE_DIR | 0555,        /* mode */
  45.     2,                /* nlink */
  46.     0,                /* uid */
  47.     0,                /* gid */
  48.     512,                /* size */
  49.     4096,                /* blocksize */
  50.     0,                /* rdev */
  51.     1,                /* blocks */
  52.     0,                /* fsid */
  53.     0,                /* fileid */
  54.     { 0, 0 },            /* atime */
  55.     { 0, 0 },            /* mtime */
  56.     { 0, 0 },            /* ctime */
  57. };
  58.  
  59. mntfs *dup_mntfs(mf)
  60. mntfs *mf;
  61. {
  62.     if (mf->mf_refc == 0) {
  63.         untimeout(mf->mf_cid);
  64.         mf->mf_cid = 0;
  65.         mf->mf_error = -1;
  66.         mf->mf_error &= ~MFF_ERROR;
  67.     }
  68.     mf->mf_refc++;
  69.     return mf;
  70. }
  71.  
  72. static init_mntfs(mf, ops, mo, mp, info, opts)
  73. mntfs *mf;
  74. am_ops *ops;
  75. am_opts *mo;
  76. char *mp;
  77. char *info;
  78. char *opts;
  79. {
  80.     mf->mf_ops = ops;
  81.     mf->mf_fo = mo;
  82.     mf->mf_mount = strdup(mp);
  83.     mf->mf_info = strdup(info);
  84.     mf->mf_opts = strdup(opts);
  85.     mf->mf_refc = 1;
  86.     mf->mf_flags = 0;
  87.     mf->mf_error = -1;
  88.     mf->mf_cid = 0;
  89.     mf->mf_private = 0;
  90.     mf->mf_prfree = 0;
  91.     mf->mf_attr.status = NFS_OK;
  92.     mf->mf_fattr = gen_fattr;
  93.     mf->mf_fattr.fsid = 42;
  94.     mf->mf_fattr.fileid = 0;
  95.     mf->mf_fattr.atime.seconds = clocktime();
  96.     mf->mf_fattr.atime.useconds = 0;
  97.     mf->mf_fattr.mtime = mf->mf_fattr.ctime = mf->mf_fattr.atime;
  98.  
  99.     if (ops->ffserver)
  100.         mf->mf_server = (*ops->ffserver)(mf);
  101.     else
  102.         mf->mf_server = 0;
  103. }
  104.  
  105. static mntfs *alloc_mntfs(ops, mo, mp, info, opts)
  106. am_ops *ops;
  107. am_opts *mo;
  108. char *mp;
  109. char *info;
  110. char *opts;
  111. {
  112.     mntfs *mf = ALLOC(mntfs);
  113.     init_mntfs(mf, ops, mo, mp, info, opts);
  114.     ins_que(&mf->mf_q, &mfhead);
  115.     mntfs_allocated++;
  116.  
  117.     return mf;
  118. }
  119.  
  120. mntfs *find_mntfs(ops, mo, mp, info, opts)
  121. am_ops *ops;
  122. am_opts *mo;
  123. char *mp;
  124. char *info;
  125. char *opts;
  126. {
  127.     mntfs *mf;
  128.  
  129. #ifdef DEBUG
  130.     dlog("Locating mntfs reference to %s", mp);
  131. #endif
  132.     ITER(mf, mntfs, &mfhead) {
  133.         if (STREQ(mf->mf_mount, mp)) {
  134.             /*
  135.              * Handle cases where error ops are involved
  136.              */
  137.             if (ops == &efs_ops) {
  138.                 /*
  139.                  * If the existing ops are not efs_ops
  140.                  * then continue...
  141.                  */
  142.                 if (mf->mf_ops != &efs_ops)
  143.                     continue;
  144.             } else /* ops != &efs_ops */ {
  145.                 /*
  146.                  * If the existing ops are efs_ops
  147.                  * then continue...
  148.                  */
  149.                 if (mf->mf_ops == &efs_ops)
  150.                     continue;
  151.             }
  152.  
  153.             if ((mf->mf_flags & MFF_RESTART) && amd_state == Run) {
  154.                 /*
  155.                  * Restart a previously mounted filesystem.
  156.                  */
  157.                 mntfs *mf2 = alloc_mntfs(&ifs_ops, mo, mp, info, opts);
  158. #ifdef DEBUG
  159.                 dlog("Restarting filesystem %s", mf->mf_mount);
  160. #endif
  161.                 /*
  162.                  * Remember who we are restarting
  163.                  */
  164.                 mf2->mf_private = (voidp) dup_mntfs(mf);
  165.                 mf2->mf_prfree = free_mntfs;
  166.                 return mf2;
  167.             }
  168.             mf->mf_fo = mo;
  169.             if (!(mf->mf_flags & (MFF_MOUNTED|MFF_MOUNTING|MFF_UNMOUNTING))) {
  170.                 fserver *fs;
  171.                 mf->mf_opts = strealloc(mf->mf_opts, opts);
  172.                 mf->mf_info = strealloc(mf->mf_info, info);
  173.                 fs = ops->ffserver ? (*ops->ffserver)(mf) : (fserver *) 0;
  174.                 if (mf->mf_server)
  175.                     free_srvr(mf->mf_server);
  176.                 mf->mf_server = fs;
  177.             }
  178.             return dup_mntfs(mf);
  179.         }
  180.     }
  181.  
  182.     return alloc_mntfs(ops, mo, mp, info, opts);
  183. }
  184.  
  185. mntfs *new_mntfs()
  186. {
  187.     return alloc_mntfs(&efs_ops, (am_opts *) 0, "//nil//", ".", "");
  188. }
  189.  
  190. static void uninit_mntfs(mf, rmd)
  191. mntfs *mf;
  192. int rmd;
  193. {
  194.     if (mf->mf_mount) free((voidp) mf->mf_mount);
  195.     if (mf->mf_opts) free((voidp) mf->mf_opts);
  196.     if (mf->mf_info) free((voidp) mf->mf_info);
  197.     if (mf->mf_private && mf->mf_prfree)
  198.         (*mf->mf_prfree)(mf->mf_private);
  199.     /*
  200.      * Clean up any directories that were made
  201.      */
  202.     if (rmd && (mf->mf_flags & MFF_MKMNT))
  203.         rmdirs(mf->mf_mount);
  204.  
  205.     /*
  206.      * Clean up the file server
  207.      */
  208.     if (mf->mf_server)
  209.         free_srvr(mf->mf_server);
  210.  
  211.     /*
  212.      * Don't do a callback on this mount
  213.      */
  214.     if (mf->mf_cid) {
  215.         untimeout(mf->mf_cid);
  216.         mf->mf_cid = 0;
  217.     }
  218. }
  219.  
  220. static void discard_mntfs(mf)
  221. mntfs *mf;
  222. {
  223.     rem_que(&mf->mf_q);
  224.     /*
  225.      * Free memory
  226.      */
  227.     uninit_mntfs(mf, TRUE);
  228.     free((voidp) mf);
  229.  
  230.     --mntfs_allocated;
  231. }
  232.  
  233. void flush_mntfs()
  234. {
  235.     mntfs *mf;
  236.  
  237.     mf = FIRST(mntfs, &mfhead);
  238.     while (mf != HEAD(mntfs, &mfhead)) {
  239.         mntfs *mf2 = mf;
  240.         mf = NEXT(mntfs, mf);
  241.         if (mf2->mf_refc == 0 && mf2->mf_cid)
  242.             discard_mntfs(mf2);
  243.     }
  244. }
  245.  
  246. void free_mntfs(mf)
  247. mntfs *mf;
  248. {
  249.     if (--mf->mf_refc == 0) {
  250.         if (mf->mf_flags & MFF_MOUNTED) {
  251.             int quoted;
  252.             mf->mf_flags &= ~MFF_MOUNTED;
  253.  
  254.             /*
  255.              * Record for posterity
  256.              */
  257.             quoted = strchr(mf->mf_info, ' ') != 0;    /* cheap */
  258.             plog(XLOG_INFO, "%s%s%s %sed fstype %s from %s",
  259.                 quoted ? "\"" : "",
  260.                 mf->mf_info,
  261.                 quoted ? "\"" : "",
  262.                 mf->mf_error ? "discard" : "unmount",
  263.                 mf->mf_ops->fs_type, mf->mf_mount);
  264.         }
  265.  
  266.         if (mf->mf_ops->fs_flags & FS_DISCARD) {
  267. #ifdef DEBUG
  268.             dlog("Immediately discarding mntfs for %s", mf->mf_mount);
  269. #endif
  270.             discard_mntfs(mf);
  271.         } else {
  272. #ifdef DEBUG
  273.             if (mf->mf_flags & MFF_RESTART) {
  274.                 dlog("Discarding remount hook for %s", mf->mf_mount);
  275.             } else {
  276.                 dlog("Discarding last mntfs reference to %s fstype %s",
  277.                     mf->mf_mount, mf->mf_ops->fs_type);
  278.             }
  279.             if (mf->mf_flags & (MFF_MOUNTED|MFF_MOUNTING|MFF_UNMOUNTING))
  280.                 dlog("mntfs reference for %s still active", mf->mf_mount);
  281. #endif
  282.             mf->mf_cid = timeout(ALLOWED_MOUNT_TIME, discard_mntfs, (voidp) mf);
  283.         }
  284.     }
  285. }
  286.  
  287. mntfs *realloc_mntfs(mf, ops, mo, mp, info, opts)
  288. mntfs *mf;
  289. am_ops *ops;
  290. am_opts *mo;
  291. char *mp;
  292. char *info;
  293. char *opts;
  294. {
  295.     mntfs *mf2;
  296.     if (mf->mf_refc == 1 && mf->mf_ops == &ifs_ops && STREQ(mf->mf_mount, mp)) {
  297.         /*
  298.          * If we are inheriting then just return
  299.          * the same node...
  300.          */
  301.         return mf;
  302.     }
  303.     mf2 = find_mntfs(ops, mo, mp, info, opts);
  304.     free_mntfs(mf);
  305.     return mf2;
  306. }
  307.