src/afs/VNOPS/afs_vnop_dirops.c

   1 /*
   2  * Copyright 2000, International Business Machines Corporation and others.
   3  * All Rights Reserved.
   4  *
   5  * This software has been released under the terms of the IBM Public
   6  * License.  For details, see the LICENSE file in the top-level source
   7  * directory or online at http://www.openafs.org/dl/license10.html
   8  */
   9
  10 /*
  11  * afs_vnop_dirops.c - make and remove directories
  12  *
  13  * Implements:
  14  *
  15  * afs_mkdir
  16  * afs_rmdir
  17  *
  18  */
  19
  20 #include <afsconfig.h>
  21 #include "afs/param.h"
  22
  23 RCSID
  24     ("$Header$");
  25
  26 #include "afs/sysincludes.h"    /* Standard vendor system headers */
  27 #include "afsincludes.h"        /* Afs-based standard headers */
  28 #include "afs/afs_stats.h"      /* statistics */
  29 #include "afs/afs_cbqueue.h"
  30 #include "afs/nfsclient.h"
  31 #include "afs/afs_osidnlc.h"
  32
  33 extern afs_rwlock_t afs_xvcache;
  34 extern afs_rwlock_t afs_xcbhash;
  35
  36 /* don't set CDirty in here because RPC is called synchronously */
  37
  38 int
  39 afs_mkdir(OSI_VC_DECL(adp), char *aname, struct vattr *attrs,
  40      register struct vcache **avcp, struct AFS_UCRED *acred)
  41 {
  42     struct vrequest treq;
  43     register afs_int32 code;
  44     register struct conn *tc;
  45     struct VenusFid newFid;
  46     register struct dcache *tdc;
  47     afs_size_t offset, len;
  48     register struct vcache *tvc;
  49     struct AFSStoreStatus InStatus;
  50     struct AFSFetchStatus OutFidStatus, OutDirStatus;
  51     struct AFSCallBack CallBack;
  52     struct AFSVolSync tsync;
  53     afs_int32 now;
  54     struct afs_fakestat_state fakestate;
  55     XSTATS_DECLS;
  56     OSI_VC_CONVERT(adp);
  57
  58     AFS_STATCNT(afs_mkdir);
  59     afs_Trace2(afs_iclSetp, CM_TRACE_MKDIR, ICL_TYPE_POINTER, adp,
  60                ICL_TYPE_STRING, aname);
  61
  62     if ((code = afs_InitReq(&treq, acred)))
  63         goto done2;
  64     afs_InitFakeStat(&fakestate);
  65
  66     if (strlen(aname) > AFSNAMEMAX) {
  67         code = ENAMETOOLONG;
  68         goto done3;
  69     }
  70
  71     if (!afs_ENameOK(aname)) {
  72         code = EINVAL;
  73         goto done3;
  74     }
  75
  76     AFS_DISCON_LOCK();
  77
  78     code = afs_EvalFakeStat(&adp, &fakestate, &treq);
  79     if (code)
  80         goto done;
  81     code = afs_VerifyVCache(adp, &treq);
  82     if (code)
  83         goto done;
  84
  85     /** If the volume is read-only, return error without making an RPC to the
  86       * fileserver
  87       */
  88     if (adp->states & CRO) {
  89         code = EROFS;
  90         goto done;
  91     }
  92
  93     if (AFS_IS_DISCONNECTED && !AFS_IS_LOGGING) {
  94         /*printf("Network is down in afs_mkdir\n");*/
  95         code = ENETDOWN;
  96     }
  97
  98     InStatus.Mask = AFS_SETMODTIME | AFS_SETMODE | AFS_SETGROUP;
  99     InStatus.ClientModTime = osi_Time();
 100     InStatus.UnixModeBits = attrs->va_mode & 0xffff;    /* only care about protection bits */
 101     InStatus.Group = (afs_int32) acred->cr_gid;
 102     tdc = afs_GetDCache(adp, (afs_size_t) 0, &treq, &offset, &len, 1);
 103     ObtainWriteLock(&adp->lock, 153);
 104     do {
 105         tc = afs_Conn(&adp->fid, &treq, SHARED_LOCK);
 106         if (tc) {
 107             XSTATS_START_TIME(AFS_STATS_FS_RPCIDX_MAKEDIR);
 108             now = osi_Time();
 109             RX_AFS_GUNLOCK();
 110             code =
 111                 RXAFS_MakeDir(tc->id, (struct AFSFid *)&adp->fid.Fid, aname,
 112                               &InStatus, (struct AFSFid *)&newFid.Fid,
 113                               &OutFidStatus, &OutDirStatus, &CallBack,
 114                               &tsync);
 115             RX_AFS_GLOCK();
 116             XSTATS_END_TIME;
 117             CallBack.ExpirationTime += now;
 118             /* DON'T forget to Set the callback value... */
 119         } else
 120             code = -1;
 121     } while (afs_Analyze
 122              (tc, code, &adp->fid, &treq, AFS_STATS_FS_RPCIDX_MAKEDIR,
 123               SHARED_LOCK, NULL));
 124
 125     if (code) {
 126         if (code < 0) {
 127             ObtainWriteLock(&afs_xcbhash, 490);
 128             afs_DequeueCallback(adp);
 129             adp->states &= ~CStatd;
 130             ReleaseWriteLock(&afs_xcbhash);
 131             osi_dnlc_purgedp(adp);
 132         }
 133         ReleaseWriteLock(&adp->lock);
 134         if (tdc)
 135             afs_PutDCache(tdc);
 136         goto done;
 137     }
 138     /* otherwise, we should see if we can make the change to the dir locally */
 139     if (tdc)
 140         ObtainWriteLock(&tdc->lock, 632);
 141     if (afs_LocalHero(adp, tdc, &OutDirStatus, 1)) {
 142         /* we can do it locally */
 143         ObtainWriteLock(&afs_xdcache, 294);
 144         code = afs_dir_Create(tdc, aname, &newFid.Fid);
 145         ReleaseWriteLock(&afs_xdcache);
 146         if (code) {
 147             ZapDCE(tdc);        /* surprise error -- use invalid value */
 148             DZap(tdc);
 149         }
 150     }
 151     if (tdc) {
 152         ReleaseWriteLock(&tdc->lock);
 153         afs_PutDCache(tdc);
 154     }
 155     adp->m.LinkCount = OutDirStatus.LinkCount;
 156     newFid.Cell = adp->fid.Cell;
 157     newFid.Fid.Volume = adp->fid.Fid.Volume;
 158     ReleaseWriteLock(&adp->lock);
 159     /* now we're done with parent dir, create the real dir's cache entry */
 160     tvc = afs_GetVCache(&newFid, &treq, NULL, NULL);
 161     if (tvc) {
 162         code = 0;
 163         *avcp = tvc;
 164     } else
 165         code = ENOENT;
 166   done:
 167     AFS_DISCON_UNLOCK();
 168   done3:
 169     afs_PutFakeStat(&fakestate);
 170     code = afs_CheckCode(code, &treq, 26);
 171   done2:
 172     return code;
 173 }
 174
 175
 176 int
 177 /* don't set CDirty in here because RPC is called synchronously */
 178 #if     defined(AFS_SUN5_ENV) || defined(AFS_SGI_ENV)
 179 afs_rmdir(OSI_VC_DECL(adp), char *aname, struct vnode *cdirp,
 180           struct AFS_UCRED *acred)
 181 #else
 182 afs_rmdir(OSI_VC_DECL(adp), char *aname, struct AFS_UCRED *acred)
 183 #endif
 184 {
 185     struct vrequest treq;
 186     register struct dcache *tdc;
 187     register struct vcache *tvc = NULL;
 188     register afs_int32 code;
 189     register struct conn *tc;
 190     afs_size_t offset, len;
 191     struct AFSFetchStatus OutDirStatus;
 192     struct AFSVolSync tsync;
 193     struct afs_fakestat_state fakestate;
 194     XSTATS_DECLS;
 195     OSI_VC_CONVERT(adp);
 196
 197     AFS_STATCNT(afs_rmdir);
 198
 199     afs_Trace2(afs_iclSetp, CM_TRACE_RMDIR, ICL_TYPE_POINTER, adp,
 200                ICL_TYPE_STRING, aname);
 201
 202     if ((code = afs_InitReq(&treq, acred)))
 203         goto done2;
 204     afs_InitFakeStat(&fakestate);
 205
 206     if (strlen(aname) > AFSNAMEMAX) {
 207         code = ENAMETOOLONG;
 208         goto done;
 209     }
 210
 211     AFS_DISCON_LOCK();
 212
 213     code = afs_EvalFakeStat(&adp, &fakestate, &treq);
 214     if (code)
 215         goto done;
 216
 217     code = afs_VerifyVCache(adp, &treq);
 218     if (code)
 219         goto done;
 220
 221     /** If the volume is read-only, return error without making an RPC to the
 222       * fileserver
 223       */
 224     if (adp->states & CRO) {
 225         code = EROFS;
 226         goto done;
 227     }
 228
 229     if (AFS_IS_DISCONNECTED && !AFS_IS_LOGGING) {
 230         code = ENETDOWN;
 231         goto done;
 232     }
 233
 234     tdc = afs_GetDCache(adp, (afs_size_t) 0, &treq, &offset, &len, 1);  /* test for error below */
 235     ObtainWriteLock(&adp->lock, 154);
 236     if (tdc)
 237         ObtainSharedLock(&tdc->lock, 633);
 238     if (tdc && (adp->states & CForeign)) {
 239         struct VenusFid unlinkFid;
 240
 241         unlinkFid.Fid.Vnode = 0;
 242         code = afs_dir_Lookup(tdc, aname, &unlinkFid.Fid);
 243         if (code == 0) {
 244             afs_int32 cached = 0;
 245
 246             unlinkFid.Cell = adp->fid.Cell;
 247             unlinkFid.Fid.Volume = adp->fid.Fid.Volume;
 248             if (unlinkFid.Fid.Unique == 0) {
 249                 tvc =
 250                     afs_LookupVCache(&unlinkFid, &treq, &cached, adp, aname);
 251             } else {
 252                 ObtainReadLock(&afs_xvcache);
 253                 tvc = afs_FindVCache(&unlinkFid, 0, 1 /* do xstats */ );
 254                 ReleaseReadLock(&afs_xvcache);
 255             }
 256         }
 257     }
 258
 259     do {
 260         tc = afs_Conn(&adp->fid, &treq, SHARED_LOCK);
 261         if (tc) {
 262             XSTATS_START_TIME(AFS_STATS_FS_RPCIDX_REMOVEDIR);
 263             RX_AFS_GUNLOCK();
 264             code =
 265                 RXAFS_RemoveDir(tc->id, (struct AFSFid *)&adp->fid.Fid, aname,
 266                                 &OutDirStatus, &tsync);
 267             RX_AFS_GLOCK();
 268             XSTATS_END_TIME;
 269         } else
 270             code = -1;
 271     } while (afs_Analyze
 272              (tc, code, &adp->fid, &treq, AFS_STATS_FS_RPCIDX_REMOVEDIR,
 273               SHARED_LOCK, NULL));
 274
 275     if (code) {
 276         if (tdc) {
 277             ReleaseSharedLock(&tdc->lock);
 278             afs_PutDCache(tdc);
 279         }
 280         if (code < 0) {
 281             ObtainWriteLock(&afs_xcbhash, 491);
 282             afs_DequeueCallback(adp);
 283             adp->states &= ~CStatd;
 284             ReleaseWriteLock(&afs_xcbhash);
 285             osi_dnlc_purgedp(adp);
 286         }
 287         ReleaseWriteLock(&adp->lock);
 288         goto done;
 289     }
 290     /* here if rpc worked; update the in-core link count */
 291     adp->m.LinkCount = OutDirStatus.LinkCount;
 292     if (tdc)
 293         UpgradeSToWLock(&tdc->lock, 634);
 294     if (afs_LocalHero(adp, tdc, &OutDirStatus, 1)) {
 295         /* we can do it locally */
 296         code = afs_dir_Delete(tdc, aname);
 297         if (code) {
 298             ZapDCE(tdc);        /* surprise error -- invalid value */
 299             DZap(tdc);
 300         }
 301     }
 302     if (tdc) {
 303         ReleaseWriteLock(&tdc->lock);
 304         afs_PutDCache(tdc);     /* drop ref count */
 305     }
 306
 307
 308     if (tvc)
 309         osi_dnlc_purgedp(tvc);  /* get rid of any entries for this directory */
 310     else
 311         osi_dnlc_remove(adp, aname, 0);
 312
 313     if (tvc) {
 314         ObtainWriteLock(&tvc->lock, 155);
 315         tvc->states &= ~CUnique;        /* For the dfs xlator */
 316         ReleaseWriteLock(&tvc->lock);
 317         afs_PutVCache(tvc);
 318     }
 319     ReleaseWriteLock(&adp->lock);
 320     /* don't worry about link count since dirs can not be hardlinked */
 321     code = 0;
 322
 323   done:
 324     AFS_DISCON_UNLOCK();
 325   done3:
 326     afs_PutFakeStat(&fakestate);
 327     code = afs_CheckCode(code, &treq, 27);
 328   done2:
 329     return code;
 330 }