usr/src/cmd/fs.d/cachefs/cfsd/cfsd_svc.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License, Version 1.0 only
   6  * (the "License").  You may not use this file except in compliance
   7  * with the License.
   8  *
   9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
  10  * or http://www.opensolaris.org/os/licensing.
  11  * See the License for the specific language governing permissions
  12  * and limitations under the License.
  13  *
  14  * When distributing Covered Code, include this CDDL HEADER in each
  15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  16  * If applicable, add the following below this CDDL HEADER, with the
  17  * fields enclosed by brackets "[]" replaced with your own identifying
  18  * information: Portions Copyright [yyyy] [name of copyright owner]
  19  *
  20  * CDDL HEADER END
  21  */
  22 /*
  23  * Copyright 1994-2002 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  */
  26
  27 #pragma ident   "%Z%%M% %I%     %E% SMI"
  28
  29 /*
  30  * RPC service routines.
  31  */
  32
  33 #include <stdio.h>
  34 #include <stdlib.h>
  35 #include <string.h>
  36 #include <errno.h>
  37 #include <rpc/rpc.h>
  38 #include <rpc/pmap_clnt.h> /* for pmap_unset */
  39 #include <string.h> /* strcmp */
  40 #include <signal.h>
  41 #include <unistd.h> /* setsid */
  42 #include <sys/types.h>
  43 #include <sys/stat.h>
  44 #include <time.h>
  45 #include <memory.h>
  46 #include <stropts.h>
  47 #include <netconfig.h>
  48 #include <sys/resource.h> /* rlimit */
  49 #include <thread.h>
  50 #include <synch.h>
  51 #include <mdbug/mdbug.h>
  52 #include <common/cachefsd.h>
  53 #include <sys/fs/cachefs_fs.h>
  54 #include <sys/fs/cachefs_dlog.h>
  55 #include <sys/fs/cachefs_ioctl.h>
  56 #include "cfsd.h"
  57 #include "cfsd_kmod.h"
  58 #include "cfsd_maptbl.h"
  59 #include "cfsd_logfile.h"
  60 #include "cfsd_fscache.h"
  61 #include "cfsd_cache.h"
  62 #include "cfsd_all.h"
  63 #include "cfsd_subr.h"
  64
  65 /* declared in cfsd_main.c */
  66 extern cfsd_all_object_t *all_object_p;
  67
  68 /*
  69  *                      cachefsd_null_1_svc
  70  *
  71  * Description:
  72  *      Routine to process NULLPROC command, see /usr/include/rpc/clnt.h.
  73  * Arguments:
  74  *      inp     should be NULL
  75  *      outp    should be NULL
  76  *      reqp    svc_req info
  77  * Returns:
  78  *      Always returns 1, e.g. returns success result.
  79  * Preconditions:
  80  *      precond(reqp)
  81  */
  82 bool_t
  83 cachefsd_null_1_svc(void *inp, void *outp, struct svc_req *reqp)
  84 {
  85         dbug_enter("cachefsd_null_1_svc");
  86         dbug_precond(reqp);
  87
  88         dbug_assert(inp == NULL);
  89         dbug_assert(outp == NULL);
  90
  91         dbug_leave("cachefsd_null_1_svc");
  92         return (1);
  93 }
  94
  95 /*
  96  *                      cachefsd_caches_1_svc
  97  *
  98  * Description:
  99  *      Returns list of caches on the system.
 100  * Arguments:
 101  *      inp     should be NULL
 102  *      outp    should point to return object
 103  *      reqp    svc_req info
 104  * Returns:
 105  *      Returns 1 for success 0 if an error occurs.
 106  * Preconditions:
 107  *      precond(reqp)
 108  */
 109 bool_t
 110 cachefsd_caches_1_svc(void *inp,
 111         cachefsd_caches_return *outp,
 112         struct svc_req *reqp)
 113 {
 114         size_t cnt;
 115         size_t index;
 116         cfsd_cache_object_t *cache_object_p;
 117         cachefsd_caches_id *headp, *idp;
 118
 119         dbug_enter("cachefsd_caches_1_svc");
 120         dbug_precond(reqp);
 121
 122         dbug_assert(inp == NULL);
 123         dbug_assert(outp);
 124
 125         if (inp || (outp == NULL)) {
 126                 dbug_leave("cachefsd_caches_1_svc");
 127                 return (0);
 128         }
 129         all_lock(all_object_p);
 130         headp = NULL;
 131
 132         /* if there are any caches */
 133         cnt = all_object_p->i_cachecount;
 134         if (cnt) {
 135                 /* allocate space for each cache information */
 136                 headp = idp = cfsd_calloc(sizeof (cachefsd_caches_id) * cnt);
 137
 138                 /* for each cache */
 139                 for (index = 0; index < cnt; index++, idp++) {
 140                         /* get the cache */
 141                         cache_object_p = all_cachelist_at(all_object_p, index);
 142                         dbug_assert(cache_object_p);
 143
 144                         /* get the cache id and name */
 145                         idp->cci_cacheid = cache_object_p->i_cacheid;
 146                         idp->cci_name = subr_strdup(cache_object_p->i_cachedir);
 147                 }
 148         }
 149
 150         /* fill in the return object */
 151         outp->ccr_modify = all_object_p->i_modify;
 152         outp->ccr_ids.ccr_ids_len = cnt;
 153         outp->ccr_ids.ccr_ids_val = headp;
 154
 155         all_unlock(all_object_p);
 156
 157         dbug_leave("cachefsd_caches_1_svc");
 158         return (1);
 159 }
 160
 161 /*
 162  *                      cachefsd_cache_status_1_svc
 163  *
 164  * Description:
 165  *      Returns status about a particular cache.
 166  * Arguments:
 167  *      inp     should be ptr to cache id
 168  *      outp    should be ptr to place to put cache status
 169  *      reqp    svc_req info
 170  * Returns:
 171  *      Returns 1 for success 0 if an error occurs.
 172  * Preconditions:
 173  *      precond(reqp)
 174  */
 175 bool_t
 176 cachefsd_cache_status_1_svc(int *inp, struct cachefsd_cache_status *outp,
 177     struct svc_req *reqp)
 178 {
 179         cfsd_fscache_object_t *fscache_object_p = NULL;
 180         size_t cnt, index;
 181         cfsd_cache_object_t *cache_object_p;
 182         cfsd_kmod_object_t *kmod_object_p;
 183         cachefsio_getstats_t gs;
 184         int xx;
 185
 186         dbug_enter("cachefsd_cache_status_1_svc");
 187         dbug_precond(reqp);
 188
 189         dbug_assert(inp);
 190         dbug_assert(outp);
 191
 192         if ((inp == NULL) || (outp == NULL)) {
 193                 dbug_leave("cachefsd_cache_status_1_svc");
 194                 return (0);
 195         }
 196         memset(outp, 0, sizeof (*outp));
 197
 198         /* find the requested cache */
 199         all_lock(all_object_p);
 200         cnt = all_object_p->i_cachecount;
 201         for (index = 0; index < cnt; index++) {
 202                 /* get the cache */
 203                 cache_object_p = all_cachelist_at(all_object_p, index);
 204                 dbug_assert(cache_object_p);
 205
 206                 /* if a match */
 207                 if (cache_object_p->i_cacheid == *inp) {
 208                         cache_lock(cache_object_p);
 209                         cache_object_p->i_refcnt++;
 210                         cache_unlock(cache_object_p);
 211                         break;
 212                 }
 213         }
 214         all_unlock(all_object_p);
 215
 216         /* if no match */
 217         if (index >= cnt) {
 218                 dbug_leave("cachefsd_cache_status_1_svc");
 219                 return (1);
 220         }
 221         /* find a mounted file system in the cache */
 222         cache_lock(cache_object_p);
 223         cnt = cache_object_p->i_fscachecount;
 224         for (index = 0; index < cnt; index++) {
 225                 /* get the fscache */
 226                 fscache_object_p = cache_fscachelist_at(cache_object_p, index);
 227                 dbug_assert(fscache_object_p);
 228
 229                 /* mounted */
 230                 if (fscache_object_p->i_mounted) {
 231                         fscache_lock(fscache_object_p);
 232                         fscache_object_p->i_refcnt++;
 233                         fscache_unlock(fscache_object_p);
 234                         break;
 235                 }
 236                 fscache_object_p = NULL;
 237         }
 238         cache_unlock(cache_object_p);
 239
 240         outp->ccs_size = 0;
 241         outp->ccs_lrusize = 0;
 242         outp->ccs_packsize = 0;
 243         outp->ccs_freesize = 0;
 244         outp->ccs_lrutime = 0;
 245
 246         kmod_object_p = cfsd_kmod_create();
 247         if (fscache_object_p) {
 248                 xx = kmod_setup(kmod_object_p, fscache_object_p->i_mntpt);
 249                 if (xx != 0) {
 250                         dbug_print(("err",
 251                             "setup of kmod interface failed %d", xx));
 252                 } else if ((xx = kmod_getstats(kmod_object_p, &gs)) != 0) {
 253                         dbug_print(("err", "getstat failed %d", xx));
 254                 } else {
 255                         outp->ccs_size = gs.gs_total;
 256                         outp->ccs_lrusize = gs.gs_gc + gs.gs_active;
 257                         outp->ccs_packsize = gs.gs_packed;
 258                         outp->ccs_freesize = gs.gs_free;
 259                         outp->ccs_lrutime = gs.gs_gctime;
 260
 261                         fscache_lock(fscache_object_p);
 262                         fscache_object_p->i_refcnt--;
 263                         fscache_unlock(fscache_object_p);
 264                 }
 265         }
 266         cfsd_kmod_destroy(kmod_object_p);
 267
 268         outp->ccs_id = cache_object_p->i_cacheid;
 269         outp->ccs_name = subr_strdup(cache_object_p->i_cachedir);
 270         outp->ccs_modify = cache_object_p->i_modify;
 271         cache_lock(cache_object_p);
 272         cache_object_p->i_refcnt--;
 273         cache_unlock(cache_object_p);
 274
 275         dbug_leave("cachefsd_cache_status_1_svc");
 276         return (1);
 277 }
 278
 279 /*
 280  *                      cachefsd_mounts_1_svc
 281  *
 282  * Description:
 283  *      Returns the list of file systems that are in the cache.
 284  * Arguments:
 285  *      inp     should be ptr to cache id
 286  *      outp    should be ptr to place to put mounts
 287  *      reqp    svc_req info
 288  * Returns:
 289  *      Returns 1 for success 0 if an internal error occurs.
 290  * Preconditions:
 291  *      precond(reqp)
 292  */
 293 bool_t
 294 cachefsd_mounts_1_svc(int *inp, struct cachefsd_mount_returns *outp,
 295     struct svc_req *reqp)
 296 {
 297         size_t cnt, index;
 298         cfsd_cache_object_t *cache_object_p;
 299         cfsd_fscache_object_t *fscache_object_p;
 300         struct cachefsd_mount *headp, *idp;
 301
 302         dbug_enter("cachefsd_mounts_1_svc");
 303         dbug_precond(reqp);
 304
 305         dbug_assert(inp);
 306         dbug_assert(outp);
 307         if ((inp == NULL) || (outp == NULL)) {
 308                 dbug_leave("cachefsd_mounts_1_svc");
 309                 return (0);
 310         }
 311         memset(outp, 0, sizeof (*outp));
 312
 313         /* find the requested cache */
 314         all_lock(all_object_p);
 315         cnt = all_object_p->i_cachecount;
 316         for (index = 0; index < cnt; index++) {
 317                 /* get the cache */
 318                 cache_object_p = all_cachelist_at(all_object_p, index);
 319                 dbug_assert(cache_object_p);
 320
 321                 /* if a match */
 322                 if (cache_object_p->i_cacheid == *inp) {
 323                         cache_lock(cache_object_p);
 324                         cache_object_p->i_refcnt++;
 325                         cache_unlock(cache_object_p);
 326                         break;
 327                 }
 328         }
 329         all_unlock(all_object_p);
 330
 331         /* if no match was found */
 332         if (index >= cnt) {
 333                 outp->cmr_error = ENOENT;
 334                 dbug_leave("cachefsd_mounts_1_svc");
 335                 return (1);
 336         }
 337
 338         cache_lock(cache_object_p);
 339         headp = NULL;
 340
 341         /* if there are any fscaches */
 342         cnt = cache_object_p->i_fscachecount;
 343         if (cnt) {
 344                 /* allocate space for each fscache information */
 345                 headp = idp = cfsd_calloc(sizeof (cachefsd_mount) * cnt);
 346                 /* for each fscache */
 347                 for (index = 0; index < cnt; index++, idp++) {
 348                         /* get the fscache */
 349                         fscache_object_p =
 350                             cache_fscachelist_at(cache_object_p, index);
 351                         dbug_assert(fscache_object_p);
 352
 353                         /* get the fscache id and name */
 354                         idp->cm_fsid = fscache_object_p->i_fscacheid;
 355                         idp->cm_name = subr_strdup(fscache_object_p->i_name);
 356                 }
 357         }
 358
 359         /* fill in the return object */
 360         outp->cmr_modify = cache_object_p->i_modify;
 361         outp->cmr_error = 0;
 362         outp->cmr_names.cmr_names_len = cnt;
 363         outp->cmr_names.cmr_names_val = headp;
 364
 365         cache_object_p->i_refcnt--;
 366         cache_unlock(cache_object_p);
 367
 368         dbug_leave("cachefsd_mounts_1_svc");
 369         return (1);
 370 }
 371
 372 /*
 373  *                      cachefsd_mount_stat_1_svc
 374  *
 375  * Description:
 376  *      Returns status information about a single file system
 377  *      in the cache.
 378  * Arguments:
 379  *      inp     should be which file system to get info for
 380  *      outp    should be place to put mount info
 381  *      reqp    svc_req info
 382  * Returns:
 383  *      Returns 1 for success 0 if an error occurs.
 384  * Preconditions:
 385  *      precond(reqp)
 386  */
 387 bool_t
 388 cachefsd_mount_stat_1_svc(struct cachefsd_mount_stat_args *inp,
 389     struct cachefsd_mount_stat *outp, struct svc_req *reqp)
 390 {
 391         size_t cnt, index;
 392         cfsd_cache_object_t *cache_object_p;
 393         cfsd_fscache_object_t *fscache_object_p;
 394         char namebuf[MAXPATHLEN];
 395         struct stat sinfo;
 396
 397         dbug_enter("cachefsd_mount_stat_1_svc");
 398         dbug_precond(reqp);
 399
 400         dbug_assert(inp);
 401         dbug_assert(outp);
 402         if ((inp == NULL) || (outp == NULL)) {
 403                 dbug_leave("cachefsd_mount_stat_1_svc");
 404                 return (0);
 405         }
 406         memset(outp, 0, sizeof (*outp));
 407
 408         /* find the requested cache */
 409         all_lock(all_object_p);
 410         cnt = all_object_p->i_cachecount;
 411         for (index = 0; index < cnt; index++) {
 412                 /* get the cache */
 413                 cache_object_p = all_cachelist_at(all_object_p, index);
 414                 dbug_assert(cache_object_p);
 415
 416                 /* if a match */
 417                 if (cache_object_p->i_cacheid == inp->cma_cacheid) {
 418                         cache_lock(cache_object_p);
 419                         cache_object_p->i_refcnt++;
 420                         cache_unlock(cache_object_p);
 421                         break;
 422                 }
 423         }
 424         all_unlock(all_object_p);
 425
 426         /* if no match was found */
 427         if (index >= cnt) {
 428                 dbug_leave("cachefsd_mount_stat_1_svc");
 429                 return (1);
 430         }
 431
 432         /* find the requested fscache */
 433         cache_lock(cache_object_p);
 434         cnt = cache_object_p->i_fscachecount;
 435         for (index = 0; index < cnt; index++) {
 436                 /* get the fscache */
 437                 fscache_object_p = cache_fscachelist_at(cache_object_p, index);
 438                 dbug_assert(fscache_object_p);
 439
 440                 /* if a match */
 441                 if (fscache_object_p->i_fscacheid == inp->cma_fsid) {
 442                         fscache_lock(fscache_object_p);
 443                         fscache_object_p->i_refcnt++;
 444                         fscache_unlock(fscache_object_p);
 445                         break;
 446                 }
 447         }
 448         cache_unlock(cache_object_p);
 449
 450         /* if no match was found */
 451         if (index >= cnt) {
 452                 cache_lock(cache_object_p);
 453                 cache_object_p->i_refcnt--;
 454                 cache_unlock(cache_object_p);
 455                 dbug_leave("cachefsd_mount_stat_1_svc");
 456                 return (1);
 457         }
 458
 459         fscache_lock(fscache_object_p);
 460
 461         /* see if there are changes to roll to the server */
 462         if ((fscache_object_p->i_connected == 0) &&
 463             (fscache_object_p->i_changes == 0)) {
 464                 snprintf(namebuf, sizeof (namebuf), "%s/%s/%s",
 465                     cache_object_p->i_cachedir, fscache_object_p->i_name,
 466                     CACHEFS_DLOG_FILE);
 467                 if (stat(namebuf, &sinfo) == 0) {
 468                         fscache_changes(fscache_object_p, 1);
 469                 }
 470         }
 471
 472         /* fill in the return object */
 473         outp->cms_cacheid = cache_object_p->i_cacheid;
 474         outp->cms_fsid = fscache_object_p->i_fscacheid;
 475         outp->cms_name = subr_strdup(fscache_object_p->i_name);
 476         outp->cms_backfs = subr_strdup(fscache_object_p->i_backfs);
 477         outp->cms_mountpt = subr_strdup(fscache_object_p->i_mntpt);
 478         outp->cms_backfstype = subr_strdup(fscache_object_p->i_backfstype);
 479         outp->cms_writemode = NULL;
 480         outp->cms_options = subr_strdup(fscache_object_p->i_cfsopt);
 481         outp->cms_mounted = fscache_object_p->i_mounted;
 482         outp->cms_connected = fscache_object_p->i_connected;
 483         outp->cms_reconcile = fscache_object_p->i_reconcile;
 484         outp->cms_changes = fscache_object_p->i_changes;
 485         outp->cms_time_state = fscache_object_p->i_time_state;
 486         outp->cms_mnttime = fscache_object_p->i_time_mnt;
 487         outp->cms_modify = fscache_object_p->i_modify;
 488
 489         fscache_object_p->i_refcnt--;
 490         fscache_unlock(fscache_object_p);
 491
 492         cache_lock(cache_object_p);
 493         cache_object_p->i_refcnt--;
 494         cache_unlock(cache_object_p);
 495
 496         dbug_leave("cachefsd_mount_stat_1_svc");
 497         return (1);
 498 }
 499
 500 /*
 501  *                      cachefsd_fs_mounted_1_svc
 502  *
 503  * Description:
 504  *      Sent by the mount command to indicate a new file system
 505  *      has been mounted
 506  * Arguments:
 507  *      inp     ptr to mount information
 508  *      outp    should be null
 509  *      reqp    svc_req info
 510  * Returns:
 511  *      Returns 1 for success 0 if an internal error occurs.
 512  * Preconditions:
 513  *      precond(inp)
 514  */
 515 bool_t
 516 cachefsd_fs_mounted_1_svc(struct cachefsd_fs_mounted *inp, void *outp,
 517     struct svc_req *reqp)
 518 {
 519         int error = 0;
 520
 521         dbug_enter("cachefsd_fs_mounted_1_svc");
 522         dbug_precond(reqp);
 523
 524         dbug_assert(inp);
 525         dbug_assert(outp == NULL);
 526         if ((inp == NULL) || outp) {
 527                 dbug_leave("cachefsd_fs_mounted_1_svc");
 528                 return (0);
 529         }
 530
 531         if (inp->mt_cachedir == NULL) {
 532                 dbug_print(("error", "cachedir is null"));
 533                 error = 1;
 534         }
 535         if (inp->mt_cacheid == NULL) {
 536                 dbug_print(("error", "cacheid is null"));
 537                 error = 1;
 538         }
 539
 540         if (error == 0) {
 541                 dbug_print(("info", "Mounted in %s file system %s",
 542                     inp->mt_cachedir, inp->mt_cacheid));
 543                 subr_add_mount(all_object_p, inp->mt_cachedir, inp->mt_cacheid);
 544         }
 545
 546         dbug_leave("cachefsd_fs_mounted_1_svc");
 547         return (1);
 548 }
 549
 550 /*
 551  *                      cachefsd_fs_unmounted_1_svc
 552  *
 553  * Description:
 554  * Arguments:
 555  *      inp
 556  *      outp
 557  *      reqp
 558  * Returns:
 559  *      Returns 1 for success 0 if an internal error occurs.
 560  * Preconditions:
 561  *      precond(inp)
 562  *      precond(outp == NULL)
 563  *      precond(reqp)
 564  */
 565 bool_t
 566 cachefsd_fs_unmounted_1_svc(struct cachefsd_fs_unmounted *inp, int *outp,
 567     struct svc_req *reqp)
 568 {
 569         size_t cnt1, cnt2, index1, index2;
 570         cfsd_cache_object_t *cache_object_p;
 571         cfsd_fscache_object_t *fscache_object_p = NULL;
 572         int found = 0;
 573         int flag = 0;
 574
 575         dbug_enter("cachefsd_fs_unmounted_1_svc");
 576
 577         dbug_precond(inp);
 578         dbug_precond(outp);
 579         dbug_precond(reqp);
 580
 581         if ((inp == NULL) || (outp == NULL)) {
 582                 dbug_leave("cachefsd_fs_unmounted_1_svc");
 583                 return (0);
 584         }
 585         memset(outp, 0, sizeof (*outp));
 586
 587         if (inp->mntpt == NULL) {
 588                 dbug_print(("error", "mntpt is null"));
 589                 *outp = EIO;
 590                 dbug_leave("cachefsd_fs_unmounted_1_svc");
 591                 return (1);
 592         }
 593
 594         /* for each cache */
 595         all_lock(all_object_p);
 596         cnt1 = all_object_p->i_cachecount;
 597         for (index1 = 0; index1 < cnt1; index1++) {
 598                 /* get the cache */
 599                 cache_object_p = all_cachelist_at(all_object_p, index1);
 600                 dbug_assert(cache_object_p);
 601
 602                 /* for each file system in this cache */
 603                 cache_lock(cache_object_p);
 604                 cnt2 = cache_object_p->i_fscachecount;
 605                 for (index2 = 0; index2 < cnt2; index2++) {
 606                         /* get the fscache */
 607                         fscache_object_p =
 608                             cache_fscachelist_at(cache_object_p, index2);
 609                         dbug_assert(fscache_object_p);
 610
 611                         /* skip if not mounted */
 612                         if (fscache_object_p->i_mounted == 0)
 613                                 continue;
 614
 615                         /* if a match */
 616                         if (strcmp(fscache_object_p->i_mntpt,
 617                                 inp->mntpt) == 0) {
 618                                 fscache_lock(fscache_object_p);
 619                                 fscache_object_p->i_refcnt++;
 620                                 flag = inp->flag;
 621                                 fscache_unlock(fscache_object_p);
 622                                 found = 1;
 623                                 break;
 624                         }
 625                 }
 626                 cache_unlock(cache_object_p);
 627                 if (found)
 628                         break;
 629                 fscache_object_p = NULL;
 630         }
 631         all_unlock(all_object_p);
 632
 633         /* if no match */
 634         if (fscache_object_p == NULL) {
 635                 *outp = EIO;
 636         } else {
 637                 *outp = fscache_unmount(fscache_object_p, flag);
 638
 639                 fscache_lock(fscache_object_p);
 640                 fscache_object_p->i_refcnt--;
 641                 fscache_unlock(fscache_object_p);
 642         }
 643         dbug_leave("cachefsd_fs_unmounted_1_svc");
 644         return (1);
 645 }
 646
 647 /*
 648  *                      cachefsd_disconnection_1_svc
 649  *
 650  * Description:
 651  * Arguments:
 652  *      inp
 653  *      outp
 654  *      reqp
 655  * Returns:
 656  *      Returns 1 for success 0 if an internal error occurs.
 657  * Preconditions:
 658  *      precond(inp)
 659  *      precond(outp)
 660  *      precond(reqp)
 661  */
 662 bool_t
 663 cachefsd_disconnection_1_svc(struct cachefsd_disconnection_args *inp, int *outp,
 664     struct svc_req *reqp)
 665 {
 666         size_t cnt1, cnt2, index1, index2;
 667         cfsd_cache_object_t *cache_object_p;
 668         cfsd_fscache_object_t *fscache_object_p = NULL;
 669         int found = 0;
 670
 671         dbug_enter("cachefsd_disconnection_1_svc");
 672
 673         dbug_precond(inp);
 674         dbug_precond(outp);
 675         dbug_precond(reqp);
 676
 677         if ((inp == NULL) || (outp == NULL)) {
 678                 dbug_leave("cachefsd_disconnection_1_svc");
 679                 return (0);
 680         }
 681         memset(outp, 0, sizeof (*outp));
 682
 683         /* for each cache */
 684         all_lock(all_object_p);
 685         cnt1 = all_object_p->i_cachecount;
 686         for (index1 = 0; index1 < cnt1; index1++) {
 687                 /* get the cache */
 688                 cache_object_p = all_cachelist_at(all_object_p, index1);
 689                 dbug_assert(cache_object_p);
 690
 691                 /* for each file system in this cache */
 692                 cache_lock(cache_object_p);
 693                 cnt2 = cache_object_p->i_fscachecount;
 694                 for (index2 = 0; index2 < cnt2; index2++) {
 695                         /* get the fscache */
 696                         fscache_object_p =
 697                             cache_fscachelist_at(cache_object_p, index2);
 698                         dbug_assert(fscache_object_p);
 699
 700                         /* if a match */
 701                         if (strcmp(fscache_object_p->i_mntpt, inp->cda_mntpt)
 702                             == 0) {
 703                                 fscache_lock(fscache_object_p);
 704                                 fscache_object_p->i_refcnt++;
 705                                 fscache_unlock(fscache_object_p);
 706                                 found = 1;
 707                                 break;
 708                         }
 709                 }
 710                 cache_unlock(cache_object_p);
 711                 if (found)
 712                         break;
 713                 fscache_object_p = NULL;
 714         }
 715         all_unlock(all_object_p);
 716
 717         /* if no match */
 718         if (fscache_object_p == NULL) {
 719                 *outp = 3;
 720         } else {
 721                 *outp = fscache_simdisconnect(fscache_object_p,
 722                     inp->cda_disconnect);
 723
 724                 fscache_lock(fscache_object_p);
 725                 fscache_object_p->i_refcnt--;
 726                 fscache_unlock(fscache_object_p);
 727         }
 728         dbug_leave("cachefsd_disconnection_1_svc");
 729         return (1);
 730 }
 731
 732 /*
 733  *                      cachefsdprog_1_freeresult
 734  *
 735  * Description:
 736  * Arguments:
 737  *      transp
 738  *      xdr_result
 739  *      resultp
 740  * Returns:
 741  *      Returns ...
 742  * Preconditions:
 743  *      precond(transp)
 744  */
 745 int
 746 cachefsdprog_1_freeresult(SVCXPRT *transp, xdrproc_t xdr_result,
 747         caddr_t resultp)
 748 {
 749         dbug_enter("cachefsdprog_1_freeresult");
 750
 751         dbug_precond(transp);
 752
 753         (void) xdr_free(xdr_result, resultp);
 754         dbug_leave("cachefsdprog_1_freeresult");
 755         return (1);
 756 }