src/afs/VNOPS/afs_vnop_rename.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  * Implements:
  12  * afsrename
  13  * afs_rename
  14  *
  15  */
  16
  17 #include <afsconfig.h>
  18 #include "../afs/param.h"
  19
  20 RCSID("$Header$");
  21
  22 #include "../afs/sysincludes.h" /* Standard vendor system headers */
  23 #include "../afs/afsincludes.h" /* Afs-based standard headers */
  24 #include "../afs/afs_stats.h" /* statistics */
  25 #include "../afs/afs_cbqueue.h"
  26 #include "../afs/nfsclient.h"
  27 #include "../afs/afs_osidnlc.h"
  28
  29 extern afs_rwlock_t afs_xcbhash;
  30
  31 /* Note that we don't set CDirty here, this is OK because the rename
  32  * RPC is called synchronously. */
  33
  34 afsrename(aodp, aname1, andp, aname2, acred)
  35     register struct vcache *aodp, *andp;
  36     char *aname1, *aname2;
  37     struct AFS_UCRED *acred; {
  38     struct vrequest treq;
  39     register struct conn *tc;
  40     register afs_int32 code;
  41     afs_int32 returnCode;
  42     int oneDir, doLocally;
  43     afs_size_t offset, len;
  44     struct VenusFid unlinkFid, fileFid;
  45     struct vcache *tvc;
  46     struct dcache *tdc1, *tdc2;
  47     struct AFSFetchStatus OutOldDirStatus, OutNewDirStatus;
  48     struct AFSVolSync tsync;
  49     XSTATS_DECLS
  50
  51     AFS_STATCNT(afs_rename);
  52     afs_Trace4(afs_iclSetp, CM_TRACE_RENAME, ICL_TYPE_POINTER, aodp,
  53                ICL_TYPE_STRING, aname1, ICL_TYPE_POINTER, andp,
  54                ICL_TYPE_STRING, aname2);
  55
  56     if (code = afs_InitReq(&treq, acred)) return code;
  57
  58     /* verify the latest versions of the stat cache entries */
  59 tagain:
  60     code = afs_VerifyVCache(aodp, &treq);
  61     if (code) goto done;
  62     code = afs_VerifyVCache(andp, &treq);
  63     if (code) goto done;
  64
  65     /* lock in appropriate order, after some checks */
  66     if (aodp->fid.Cell != andp->fid.Cell || aodp->fid.Fid.Volume != andp->fid.Fid.Volume) {
  67         code = EXDEV;
  68         goto done;
  69     }
  70     oneDir = 0;
  71     code = 0;
  72     if (andp->fid.Fid.Vnode == aodp->fid.Fid.Vnode) {
  73         if (!strcmp(aname1, aname2)) {
  74             /* Same directory and same name; this is a noop and just return success
  75              * to save cycles and follow posix standards */
  76
  77             code = 0;
  78             goto done;
  79         }
  80         ObtainWriteLock(&andp->lock,147);
  81         tdc1 = afs_GetDCache(aodp, (afs_size_t) 0, &treq, &offset, &len, 0);
  82         if (!tdc1) {
  83             code = ENOENT;
  84         } else {
  85             ObtainWriteLock(&tdc1->lock, 643);
  86         }
  87         tdc2 = tdc1;
  88         oneDir = 1;         /* only one dude locked */
  89     }
  90     else if ((andp->states & CRO) || (aodp->states & CRO)) {
  91        code = EROFS;
  92        goto done;
  93      }
  94     else if (andp->fid.Fid.Vnode < aodp->fid.Fid.Vnode) {
  95         ObtainWriteLock(&andp->lock,148);       /* lock smaller one first */
  96         ObtainWriteLock(&aodp->lock,149);
  97         tdc2 = afs_FindDCache(andp, 0);
  98         if (tdc2) ObtainWriteLock(&tdc2->lock, 644);
  99         tdc1 = afs_GetDCache(aodp, (afs_size_t) 0, &treq, &offset, &len, 0);
 100         if (tdc1)
 101             ObtainWriteLock(&tdc1->lock, 645);
 102         else
 103             code = ENOENT;
 104     }
 105     else {
 106         ObtainWriteLock(&aodp->lock,150);       /* lock smaller one first */
 107         ObtainWriteLock(&andp->lock,557);
 108         tdc1 = afs_GetDCache(aodp, (afs_size_t) 0, &treq, &offset, &len, 0);
 109         if (tdc1)
 110             ObtainWriteLock(&tdc1->lock, 646);
 111         else
 112             code = ENOENT;
 113         tdc2 = afs_FindDCache(andp, 0);
 114         if (tdc2) ObtainWriteLock(&tdc2->lock, 647);
 115     }
 116
 117     osi_dnlc_remove (aodp, aname1, 0);
 118     osi_dnlc_remove (andp, aname2, 0);
 119     afs_symhint_inval(aodp);
 120     afs_symhint_inval(andp);
 121
 122     /*
 123      * Make sure that the data in the cache is current. We may have
 124      * received a callback while we were waiting for the write lock.
 125      */
 126     if (tdc1) {
 127         if (!(aodp->states & CStatd)
 128             || !hsame(aodp->m.DataVersion, tdc1->f.versionNo)) {
 129
 130             ReleaseWriteLock(&aodp->lock);
 131             if (!oneDir) {
 132                 if (tdc2) {
 133                     ReleaseWriteLock(&tdc2->lock);
 134                     afs_PutDCache(tdc2);
 135                 }
 136                 ReleaseWriteLock(&andp->lock);
 137             }
 138             ReleaseWriteLock(&tdc1->lock);
 139             afs_PutDCache(tdc1);
 140             goto tagain;
 141         }
 142     }
 143
 144     if (code == 0)
 145         code = afs_dir_Lookup(&tdc1->f.inode, aname1, &fileFid.Fid);
 146     if (code) {
 147         if (tdc1) {
 148             ReleaseWriteLock(&tdc1->lock);
 149             afs_PutDCache(tdc1);
 150         }
 151         ReleaseWriteLock(&aodp->lock);
 152         if (!oneDir) {
 153             if (tdc2) {
 154                 ReleaseWriteLock(&tdc2->lock);
 155                 afs_PutDCache(tdc2);
 156             }
 157             ReleaseWriteLock(&andp->lock);
 158         }
 159         goto done;
 160     }
 161
 162     /* locks are now set, proceed to do the real work */
 163     do {
 164         tc = afs_Conn(&aodp->fid, &treq, SHARED_LOCK);
 165         if (tc) {
 166           XSTATS_START_TIME(AFS_STATS_FS_RPCIDX_RENAME);
 167 #ifdef RX_ENABLE_LOCKS
 168           AFS_GUNLOCK();
 169 #endif /* RX_ENABLE_LOCKS */
 170           code = RXAFS_Rename(tc->id, (struct AFSFid *) &aodp->fid.Fid, aname1,
 171                                 (struct AFSFid *) &andp->fid.Fid, aname2,
 172                                 &OutOldDirStatus, &OutNewDirStatus, &tsync);
 173 #ifdef RX_ENABLE_LOCKS
 174           AFS_GLOCK();
 175 #endif /* RX_ENABLE_LOCKS */
 176           XSTATS_END_TIME;
 177         } else code = -1;
 178
 179     } while
 180         (afs_Analyze(tc, code, &andp->fid, &treq,
 181                      AFS_STATS_FS_RPCIDX_RENAME, SHARED_LOCK, (struct cell *)0));
 182
 183     returnCode = code;      /* remember for later */
 184
 185     /* Now we try to do things locally.  This is really loathsome code. */
 186     unlinkFid.Fid.Vnode = 0;
 187     if (code == 0) {
 188         /*  In any event, we don't really care if the data (tdc2) is not
 189             in the cache; if it isn't, we won't do the update locally.  */
 190         /* see if version numbers increased properly */
 191         doLocally = 1;
 192         if (oneDir) {
 193             /* number increases by 1 for whole rename operation */
 194             if (!afs_LocalHero(aodp, tdc1, &OutOldDirStatus, 1)) {
 195                 doLocally = 0;
 196             }
 197         }
 198         else {
 199             /* two separate dirs, each increasing by 1 */
 200             if (!afs_LocalHero(aodp, tdc1, &OutOldDirStatus, 1))
 201                 doLocally = 0;
 202             if (!afs_LocalHero(andp, tdc2, &OutNewDirStatus, 1))
 203                 doLocally = 0;
 204             if (!doLocally) {
 205                 if (tdc1) {
 206                     ZapDCE(tdc1);
 207                     DZap(&tdc1->f.inode);
 208                 }
 209                 if (tdc2) {
 210                     ZapDCE(tdc2);
 211                     DZap(&tdc2->f.inode);
 212                 }
 213             }
 214         }
 215         /* now really do the work */
 216         if (doLocally) {
 217             /* first lookup the fid of the dude we're moving */
 218             code = afs_dir_Lookup(&tdc1->f.inode, aname1, &fileFid.Fid);
 219             if (code == 0) {
 220                 /* delete the source */
 221                 code = afs_dir_Delete(&tdc1->f.inode, aname1);
 222             }
 223             /* first see if target is there */
 224             if (code == 0 &&
 225                 afs_dir_Lookup(&tdc2->f.inode, aname2, &unlinkFid.Fid) == 0) {
 226                 /* target already exists, and will be unlinked by server */
 227                 code = afs_dir_Delete(&tdc2->f.inode, aname2);
 228             }
 229             if (code == 0) {
 230                 code = afs_dir_Create(&tdc2->f.inode, aname2, &fileFid.Fid);
 231             }
 232             if (code != 0) {
 233                 ZapDCE(tdc1);
 234                 DZap(&tdc1->f.inode);
 235                 if (!oneDir) {
 236                     ZapDCE(tdc2);
 237                     DZap(&tdc2->f.inode);
 238                 }
 239             }
 240         }
 241
 242         /* update dir link counts */
 243         aodp->m.LinkCount = OutOldDirStatus.LinkCount;
 244         if (!oneDir)
 245             andp->m.LinkCount = OutNewDirStatus.LinkCount;
 246
 247     }
 248     else {      /* operation failed (code != 0) */
 249         if (code < 0) {
 250             /* if failed, server might have done something anyway, and
 251              * assume that we know about it */
 252           ObtainWriteLock(&afs_xcbhash, 498);
 253           afs_DequeueCallback(aodp);
 254           afs_DequeueCallback(andp);
 255           andp->states &= ~CStatd;
 256           aodp->states &= ~CStatd;
 257           ReleaseWriteLock(&afs_xcbhash);
 258           osi_dnlc_purgedp(andp);
 259           osi_dnlc_purgedp(aodp);
 260         }
 261     }
 262
 263     /* release locks */
 264     if (tdc1) {
 265         ReleaseWriteLock(&tdc1->lock);
 266         afs_PutDCache(tdc1);
 267     }
 268
 269     if ((!oneDir) && tdc2) {
 270         ReleaseWriteLock(&tdc2->lock);
 271         afs_PutDCache(tdc2);
 272     }
 273
 274     ReleaseWriteLock(&aodp->lock);
 275     if (!oneDir) ReleaseWriteLock(&andp->lock);
 276
 277     if (returnCode) {
 278         code = returnCode;
 279         goto done;
 280     }
 281
 282     /* now, some more details.  if unlinkFid.Fid.Vnode then we should decrement
 283         the link count on this file.  Note that if fileFid is a dir, then we don't
 284         have to invalidate its ".." entry, since its DataVersion # should have
 285         changed. However, interface is not good enough to tell us the
 286         *file*'s new DataVersion, so we're stuck.  Our hack: delete mark
 287         the data as having an "unknown" version (effectively discarding the ".."
 288         entry */
 289     if (unlinkFid.Fid.Vnode) {
 290         unlinkFid.Fid.Volume = aodp->fid.Fid.Volume;
 291         unlinkFid.Cell = aodp->fid.Cell;
 292         tvc = (struct vcache *)0;
 293         if (!unlinkFid.Fid.Unique) {
 294             tvc = afs_LookupVCache(&unlinkFid, &treq, (afs_int32 *)0, WRITE_LOCK,
 295                                    aodp, aname1);
 296         }
 297         if (!tvc) /* lookup failed or wasn't called */
 298            tvc = afs_GetVCache(&unlinkFid, &treq, (afs_int32 *)0,
 299                                (struct vcache*)0, WRITE_LOCK);
 300
 301         if (tvc) {
 302 #if     defined(AFS_SUN_ENV) || defined(AFS_ALPHA_ENV) || defined(AFS_SUN5_ENV)
 303             afs_BozonLock(&tvc->pvnLock, tvc);  /* Since afs_TryToSmush will do a pvn_vptrunc */
 304 #endif
 305             ObtainWriteLock(&tvc->lock,151);
 306             tvc->m.LinkCount--;
 307             tvc->states &= ~CUnique;            /* For the dfs xlator */
 308             if (tvc->m.LinkCount == 0 && !osi_Active(tvc)) {
 309                 /* if this was last guy (probably) discard from cache.
 310                  * We have to be careful to not get rid of the stat
 311                  * information, since otherwise operations will start
 312                  * failing even if the file was still open (or
 313                  * otherwise active), and the server no longer has the
 314                  * info.  If the file still has valid links, we'll get
 315                  * a break-callback msg from the server, so it doesn't
 316                  * matter that we don't discard the status info */
 317                 if (!AFS_NFSXLATORREQ(acred)) afs_TryToSmush(tvc, acred, 0);
 318             }
 319             ReleaseWriteLock(&tvc->lock);
 320 #if     defined(AFS_SUN_ENV) || defined(AFS_ALPHA_ENV)  || defined(AFS_SUN5_ENV)
 321             afs_BozonUnlock(&tvc->pvnLock, tvc);
 322 #endif
 323             afs_PutVCache(tvc, WRITE_LOCK);
 324         }
 325     }
 326
 327     /* now handle ".." invalidation */
 328     if (!oneDir) {
 329         fileFid.Fid.Volume = aodp->fid.Fid.Volume;
 330         fileFid.Cell = aodp->fid.Cell;
 331         if (!fileFid.Fid.Unique)
 332             tvc = afs_LookupVCache(&fileFid, &treq, (afs_int32 *)0, WRITE_LOCK, andp, aname2);
 333         else
 334             tvc = afs_GetVCache(&fileFid, &treq, (afs_int32 *)0,
 335                                 (struct vcache*)0, WRITE_LOCK);
 336         if (tvc && (vType(tvc) == VDIR)) {
 337             ObtainWriteLock(&tvc->lock,152);
 338             tdc1 = afs_FindDCache(tvc, 0);
 339             if (tdc1) {
 340                 ObtainWriteLock(&tdc1->lock, 648);
 341                 ZapDCE(tdc1);   /* mark as unknown */
 342                 DZap(&tdc1->f.inode);
 343                 ReleaseWriteLock(&tdc1->lock);
 344                 afs_PutDCache(tdc1);    /* put it back */
 345             }
 346             osi_dnlc_remove(tvc, "..", 0);
 347             ReleaseWriteLock(&tvc->lock);
 348             afs_PutVCache(tvc, WRITE_LOCK);
 349         } else if (tvc) {
 350             /* True we shouldn't come here since tvc SHOULD be a dir, but we
 351              * 'syntactically' need to unless  we change the 'if' above...
 352              */
 353             afs_PutVCache(tvc, WRITE_LOCK);
 354         }
 355     }
 356     code = returnCode;
 357 done:
 358     code = afs_CheckCode(code, &treq, 25);
 359     return code;
 360 }
 361
 362 #ifdef  AFS_OSF_ENV
 363 afs_rename(fndp, tndp)
 364     struct nameidata *fndp, *tndp; {
 365     register struct vcache *aodp = (struct vcache *)fndp->ni_dvp;
 366     char *aname1 = fndp->ni_dent.d_name;
 367     register struct vcache *andp = (struct vcache *)tndp->ni_dvp;
 368     char *aname2 = tndp->ni_dent.d_name;
 369     struct ucred *acred = tndp->ni_cred;
 370 #else   /* AFS_OSF_ENV */
 371 #if defined(AFS_SGI_ENV)
 372 afs_rename(OSI_VC_ARG(aodp), aname1, andp, aname2, npnp, acred)
 373     struct pathname *npnp;
 374 #else
 375 afs_rename(OSI_VC_ARG(aodp), aname1, andp, aname2, acred)
 376 #endif
 377     OSI_VC_DECL(aodp);
 378     register struct vcache *andp;
 379     char *aname1, *aname2;
 380     struct AFS_UCRED *acred; {
 381 #endif
 382     register afs_int32 code;
 383     OSI_VC_CONVERT(aodp)
 384
 385     code = afsrename(aodp, aname1, andp, aname2, acred);
 386 #ifdef  AFS_OSF_ENV
 387     AFS_RELE(tndp->ni_dvp);
 388     if (tndp->ni_vp != NULL) {
 389         AFS_RELE(tndp->ni_vp);
 390     }
 391     AFS_RELE(fndp->ni_dvp);
 392     AFS_RELE(fndp->ni_vp);
 393 #endif  /* AFS_OSF_ENV */
 394     return code;
 395 }