src/WINNT/afsd/cm_vnodeops.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 #include <afs/param.h>
  11 #include <afs/stds.h>
  12
  13 #ifndef DJGPP
  14 #include <windows.h>
  15 #include <winsock2.h>
  16 #endif /* !DJGPP */
  17 #include <stddef.h>
  18 #include <malloc.h>
  19 #include <string.h>
  20 #include <stdlib.h>
  21
  22 #include <osi.h>
  23
  24 #include "afsd.h"
  25
  26 /* Used by cm_FollowMountPoint */
  27 #define RWVOL   0
  28 #define ROVOL   1
  29 #define BACKVOL 2
  30
  31 #ifdef DEBUG
  32 extern void afsi_log(char *pattern, ...);
  33 #endif
  34
  35 unsigned int cm_mountRootGen = 0;
  36
  37 /*
  38  * Case-folding array.  This was constructed by inspecting of SMBtrace output.
  39  * I do not know anything more about it.
  40  */
  41 unsigned char cm_foldUpper[256] = {
  42      0x0,  0x1,  0x2,  0x3,  0x4,  0x5,  0x6,  0x7,
  43      0x8,  0x9,  0xa,  0xb,  0xc,  0xd,  0xe,  0xf,
  44     0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
  45     0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
  46     0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
  47     0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
  48     0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
  49     0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
  50     0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
  51     0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
  52     0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
  53     0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
  54     0x60, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
  55     0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
  56     0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
  57     0x58, 0x59, 0x5a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
  58     0x80, 0x9a, 0x90, 0x41, 0x8e, 0x41, 0x8f, 0x80,
  59     0x45, 0x45, 0x45, 0x49, 0x49, 0x49, 0x8e, 0x8f,
  60     0x90, 0x92, 0x92, 0x4f, 0x99, 0x4f, 0x55, 0x55,
  61     0x59, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
  62     0x41, 0x49, 0x4f, 0x55, 0xa5, 0xa5, 0x56, 0xa7,
  63     0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
  64     0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
  65     0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
  66     0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
  67     0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
  68     0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
  69     0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
  70     0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
  71     0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
  72     0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
  73     0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
  74 };
  75
  76 /*
  77  * Case-insensitive string comparison.  We used to use stricmp, but it doesn't
  78  * know about 8-bit characters (e.g. 129 is lowercase u-umlaut, 154 is
  79  * upper-case u-umlaut).
  80  */
  81 int cm_stricmp(const char *str1, const char *str2)
  82 {
  83         char c1, c2;
  84
  85         while (1) {
  86                 if (*str1 == 0)
  87                         if (*str2 == 0)
  88                                 return 0;
  89                         else
  90                                 return -1;
  91                 if (*str2 == 0)
  92                         return 1;
  93                 c1 = (char) cm_foldUpper[(unsigned char)(*str1++)];
  94                 c2 = (char) cm_foldUpper[(unsigned char)(*str2++)];
  95                 if (c1 < c2)
  96                         return -1;
  97                 if (c1 > c2)
  98                         return 1;
  99         }
 100 }
 101
 102 /* characters that are legal in an 8.3 name */
 103 /*
 104  * We used to have 1's for all characters from 128 to 254.  But
 105  * the NT client behaves better if we create an 8.3 name for any
 106  * name that has a character with the high bit on, and if we
 107  * delete those characters from 8.3 names.  In particular, see
 108  * Sybase defect 10859.
 109  */
 110 char cm_LegalChars[256] = {
 111  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 112  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 113  0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0,
 114  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0,
 115  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 116  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1,
 117  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 118  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1,
 119  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 120  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 121  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 122  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 123  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 124  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 125  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 126  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
 127 };
 128
 129 /* return true iff component is a valid 8.3 name */
 130 int cm_Is8Dot3(char *namep)
 131 {
 132         int sawDot = 0;
 133         int sawUpper = 0, sawLower = 0;
 134         unsigned char tc;
 135         int charCount = 0;
 136
 137         /*
 138          * can't have a leading dot;
 139          * special case for . and ..
 140          */
 141         if (namep[0] == '.') {
 142                 if (namep[1] == 0)
 143                         return 1;
 144                 if (namep[1] == '.' && namep[2] == 0)
 145                         return 1;
 146                 return 0;
 147         }
 148         while (tc = *namep++) {
 149                 if (tc == '.') {
 150                         /* saw another dot */
 151                         if (sawDot) return 0;   /* second dot */
 152                         sawDot = 1;
 153                         charCount = 0;
 154                         continue;
 155                 }
 156                 if (cm_LegalChars[tc] == 0)
 157                         return 0;
 158                 if (tc >= 'A' && tc <= 'Z')
 159                         sawUpper = 1;
 160                 else if (tc >= 'a' && tc <= 'z')
 161                         sawLower = 1;
 162                 charCount++;
 163                 if (!sawDot && charCount > 8)
 164                         /* more than 8 chars in name */
 165                         return 0;
 166                 if (sawDot && charCount > 3)
 167                         /* more than 3 chars in extension */
 168                         return 0;
 169         }
 170 /*
 171  * Used to check that all characters were the same case.
 172  * This doesn't help 16-bit apps, and meanwhile it causes the
 173  * MS-DOS Command Prompt to misbehave; see Sybase defect 10709.
 174  *
 175         if (sawUpper && sawLower)
 176                 return 0;
 177  */
 178         return 1;
 179 }
 180
 181 /*
 182  * Number unparsing map for generating 8.3 names;
 183  * Taken from DFS.
 184  */
 185 char cm_8Dot3Mapping[41] =
 186 {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
 187  'B', 'C', 'D', 'F', 'G', 'H', 'J', 'K', 'L', 'M', 'N', 'P', 'Q', 'R', 'S',
 188  'T', 'V', 'W', 'X', 'Y', 'Z', '_', '-', '$', '#', '@', '%', '!', '&', 'E', 'O'
 189 };
 190 int cm_8Dot3MapSize = sizeof(cm_8Dot3Mapping);
 191
 192 void cm_Gen8Dot3Name(cm_dirEntry_t *dep, char *shortName, char **shortNameEndp)
 193 {
 194         char number[12];
 195         int i, nsize = 0;
 196         int vnode = ntohl(dep->fid.vnode);
 197         char *lastDot;
 198         int validExtension = 0;
 199         char tc, *temp, *name;
 200
 201         /* Unparse the file's vnode number to get a "uniquifier" */
 202         do {
 203                 number[nsize] = cm_8Dot3Mapping[vnode % cm_8Dot3MapSize];
 204                 nsize++;
 205                 vnode /= cm_8Dot3MapSize;
 206         } while (vnode);
 207
 208         /*
 209          * Look for valid extension.  There has to be a dot, and
 210          * at least one of the characters following has to be legal.
 211          */
 212         lastDot = strrchr(dep->name, '.');
 213         if (lastDot) {
 214                 temp = lastDot; temp++;
 215                 while (tc = *temp++)
 216                         if (cm_LegalChars[tc])
 217                                 break;
 218                 if (tc)
 219                         validExtension = 1;
 220         }
 221
 222         /* Copy name characters */
 223         name = dep->name;
 224         for (i = 0, name = dep->name;
 225              i < (7 - nsize) && name != lastDot; ) {
 226                 tc = *name++;
 227
 228                 if (tc == 0)
 229                         break;
 230                 if (!cm_LegalChars[tc])
 231                         continue;
 232                 i++;
 233                 *shortName++ = toupper(tc);
 234         }
 235
 236         /* tilde */
 237         *shortName++ = '~';
 238
 239         /* Copy uniquifier characters */
 240         memcpy(shortName, number, nsize);
 241         shortName += nsize;
 242
 243         if (validExtension) {
 244                 /* Copy extension characters */
 245                 *shortName++ = *lastDot++;      /* copy dot */
 246                 for (i = 0, tc = *lastDot++;
 247                      i < 3 && tc;
 248                      tc = *lastDot++) {
 249                         if (cm_LegalChars[tc]) {
 250                                 i++;
 251                                 *shortName++ = toupper(tc);
 252                         }
 253                 }
 254         }
 255
 256         /* Trailing null */
 257         *shortName = 0;
 258
 259         if (shortNameEndp)
 260                 *shortNameEndp = shortName;
 261 }
 262
 263 /* return success if we can open this file in this mode */
 264 long cm_CheckOpen(cm_scache_t *scp, int openMode, int trunc, cm_user_t *userp,
 265         cm_req_t *reqp)
 266 {
 267         long rights;
 268         long code;
 269
 270         rights = 0;
 271         if (openMode != 1) rights |= PRSFS_READ;
 272         if (openMode == 1 || openMode == 2 || trunc) rights |= PRSFS_WRITE;
 273
 274         lock_ObtainMutex(&scp->mx);
 275
 276         code = cm_SyncOp(scp, NULL, userp, reqp, rights,
 277                          CM_SCACHESYNC_GETSTATUS
 278                          | CM_SCACHESYNC_NEEDCALLBACK);
 279         lock_ReleaseMutex(&scp->mx);
 280
 281         return code;
 282 }
 283
 284 /* return success if we can open this file in this mode */
 285 long cm_CheckNTOpen(cm_scache_t *scp, unsigned int desiredAccess,
 286         unsigned int createDisp, cm_user_t *userp, cm_req_t *reqp)
 287 {
 288         long rights;
 289         long code;
 290
 291         /* Always allow delete; the RPC will tell us if it's OK */
 292         if (desiredAccess == DELETE)
 293                 return 0;
 294
 295         rights = 0;
 296
 297         if (desiredAccess & AFS_ACCESS_READ)
 298                 rights |= PRSFS_READ;
 299
 300         if ((desiredAccess & AFS_ACCESS_WRITE)
 301             || createDisp == 4)
 302                 rights |= PRSFS_WRITE;
 303
 304         lock_ObtainMutex(&scp->mx);
 305
 306         code = cm_SyncOp(scp, NULL, userp, reqp, rights,
 307                          CM_SCACHESYNC_GETSTATUS
 308                          | CM_SCACHESYNC_NEEDCALLBACK);
 309         lock_ReleaseMutex(&scp->mx);
 310
 311         /*
 312          * If the open will fail because the volume is readonly, then we will
 313          * return an access denied error instead.  This is to help brain-dead
 314          * apps run correctly on replicated volumes.
 315          * See defect 10007 for more information.
 316          */
 317         if (code == CM_ERROR_READONLY)
 318                 code = CM_ERROR_NOACCESS;
 319
 320         return code;
 321 }
 322
 323 /*
 324  * When CAP_NT_SMBS has been negotiated, deletion (of files or directories) is
 325  * done in three steps:
 326  * (1) open for deletion (NT_CREATE_AND_X)
 327  * (2) set for deletion on close (NTWTRANSACTION2, SET_FILE_INFO)
 328  * (3) close (CLOSE)
 329  * We must not do the RPC until step 3.  But if we are going to return an error
 330  * code (e.g. directory not empty), we must return it by step 2, otherwise most
 331  * clients will not notice it.  So we do a preliminary check.  For deleting
 332  * files, this is almost free, since we have already done the RPC to get the
 333  * parent directory's status bits.  But for deleting directories, we must do an
 334  * additional RPC to get the directory's data to check if it is empty.  Sigh.
 335  */
 336 long cm_CheckNTDelete(cm_scache_t *dscp, cm_scache_t *scp, cm_user_t *userp,
 337         cm_req_t *reqp)
 338 {
 339         long code;
 340         osi_hyper_t thyper;
 341         cm_buf_t *bufferp;
 342         cm_dirEntry_t *dep;
 343         unsigned short *hashTable;
 344         unsigned int i, idx;
 345         int BeyondPage = 0, HaveDot = 0, HaveDotDot = 0;
 346
 347         /* First check permissions */
 348         lock_ObtainMutex(&dscp->mx);
 349         code = cm_SyncOp(dscp, NULL, userp, reqp, PRSFS_DELETE,
 350                          CM_SCACHESYNC_GETSTATUS
 351                          | CM_SCACHESYNC_NEEDCALLBACK);
 352         lock_ReleaseMutex(&dscp->mx);
 353         if (code)
 354                 return code;
 355
 356         /* If deleting directory, must be empty */
 357
 358         if (scp->fileType != CM_SCACHETYPE_DIRECTORY)
 359                 return code;
 360
 361         thyper.HighPart = 0; thyper.LowPart = 0;
 362         lock_ObtainRead(&scp->bufCreateLock);
 363         code = buf_Get(scp, &thyper, &bufferp);
 364         lock_ReleaseRead(&scp->bufCreateLock);
 365         if (code)
 366                 return code;
 367
 368         lock_ObtainMutex(&bufferp->mx);
 369         lock_ObtainMutex(&scp->mx);
 370         while (1) {
 371                 code = cm_SyncOp(scp, bufferp, userp, reqp, 0,
 372                                  CM_SCACHESYNC_NEEDCALLBACK
 373                                  | CM_SCACHESYNC_READ
 374                                  | CM_SCACHESYNC_BUFLOCKED);
 375                 if (code)
 376                         break;
 377
 378                 if (cm_HaveBuffer(scp, bufferp, 1))
 379                         break;
 380
 381                 /* otherwise, load the buffer and try again */
 382                 lock_ReleaseMutex(&bufferp->mx);
 383                 code = cm_GetBuffer(scp, bufferp, NULL, userp, reqp);
 384                 lock_ReleaseMutex(&scp->mx);
 385                 lock_ObtainMutex(&bufferp->mx);
 386                 lock_ObtainMutex(&scp->mx);
 387                 if (code)
 388                         break;
 389         }
 390
 391         /* We try to determine emptiness without looking beyond the first page,
 392          * and without assuming "." and ".." are present and are on the first
 393          * page (though these assumptions might, after all, be reasonable).
 394          */
 395         hashTable = (unsigned short *)(bufferp->datap + (32 * 5));
 396         for (i=0; i<128; i++) {
 397                 idx = ntohs(hashTable[i]);
 398                 while (idx) {
 399                         if (idx >= 64) {
 400                                 BeyondPage = 1;
 401                                 break;
 402                         }
 403                         dep = (cm_dirEntry_t *)(bufferp->datap + (32 * idx));
 404                         if (strcmp(dep->name, ".") == 0)
 405                                 HaveDot = 1;
 406                         else if (strcmp(dep->name, "..") == 0)
 407                                 HaveDotDot = 1;
 408                         else {
 409                                 code = CM_ERROR_NOTEMPTY;
 410                                 goto done;
 411                         }
 412                         idx = ntohs(dep->next);
 413                 }
 414         }
 415         if (BeyondPage && HaveDot && HaveDotDot)
 416                 code = CM_ERROR_NOTEMPTY;
 417         else
 418                 code = 0;
 419 done:
 420         lock_ReleaseMutex(&bufferp->mx);
 421         buf_Release(bufferp);
 422         lock_ReleaseMutex(&scp->mx);
 423         return code;
 424 }
 425
 426 /*
 427  * Iterate through all entries in a directory.
 428  * When the function funcp is called, the buffer is locked but the
 429  * directory vnode is not.
 430  */
 431 long cm_ApplyDir(cm_scache_t *scp, cm_DirFuncp_t funcp, void *parmp,
 432         osi_hyper_t *startOffsetp, cm_user_t *userp, cm_req_t *reqp,
 433         cm_scache_t **retscp)
 434 {
 435     char *tp;
 436     long code;
 437     cm_dirEntry_t *dep;
 438     cm_buf_t *bufferp;
 439     long temp;
 440     osi_hyper_t dirLength;
 441     osi_hyper_t bufferOffset;
 442     osi_hyper_t curOffset;
 443     osi_hyper_t thyper;
 444     long entryInDir;
 445     long entryInBuffer;
 446         cm_pageHeader_t *pageHeaderp;
 447     int slotInPage;
 448     long nextEntryCookie;
 449     int numDirChunks;   /* # of 32 byte dir chunks in this entry */
 450
 451     /* get the directory size */
 452         lock_ObtainMutex(&scp->mx);
 453     code = cm_SyncOp(scp, NULL, userp, reqp, PRSFS_LOOKUP,
 454                      CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
 455         if (code) {
 456                 lock_ReleaseMutex(&scp->mx);
 457         return code;
 458     }
 459
 460     if (scp->fileType != CM_SCACHETYPE_DIRECTORY) {
 461                 lock_ReleaseMutex(&scp->mx);
 462                 return CM_ERROR_NOTDIR;
 463     }
 464
 465         if (retscp)                     /* if this is a lookup call */
 466         {
 467                 cm_lookupSearch_t*      sp = parmp;
 468         int casefold = sp->caseFold;
 469
 470         sp->caseFold = 0; /* we have a strong preference for exact matches */
 471                 if ( *retscp = cm_dnlcLookup(scp, sp))  /* dnlc hit */
 472                 {
 473             sp->caseFold = casefold;
 474                         lock_ReleaseMutex(&scp->mx);
 475                         return 0;
 476                 }
 477
 478         sp->caseFold = casefold;
 479         }
 480
 481         /*
 482          * XXX We only get the length once.  It might change when we drop the
 483          * lock.
 484          */
 485     dirLength = scp->length;
 486
 487         lock_ReleaseMutex(&scp->mx);
 488
 489     bufferp = NULL;
 490     bufferOffset.LowPart = bufferOffset.HighPart = 0;
 491         if (startOffsetp)
 492         curOffset = *startOffsetp;
 493         else {
 494         curOffset.HighPart = 0;
 495         curOffset.LowPart = 0;
 496         }
 497
 498     while (1) {
 499                 /* make sure that curOffset.LowPart doesn't point to the first
 500          * 32 bytes in the 2nd through last dir page, and that it
 501                  * doesn't point at the first 13 32-byte chunks in the first
 502                  * dir page, since those are dir and page headers, and don't
 503                  * contain useful information.
 504          */
 505                 temp = curOffset.LowPart & (2048-1);
 506         if (curOffset.HighPart == 0 && curOffset.LowPart < 2048) {
 507             /* we're in the first page */
 508             if (temp < 13*32) temp = 13*32;
 509                 }
 510                 else {
 511                         /* we're in a later dir page */
 512             if (temp < 32) temp = 32;
 513         }
 514
 515         /* make sure the low order 5 bits are zero */
 516         temp &= ~(32-1);
 517
 518         /* now put temp bits back ito curOffset.LowPart */
 519         curOffset.LowPart &= ~(2048-1);
 520         curOffset.LowPart |= temp;
 521
 522         /* check if we've passed the dir's EOF */
 523         if (LargeIntegerGreaterThanOrEqualTo(curOffset, dirLength))
 524                         break;
 525
 526         /* see if we can use the bufferp we have now; compute in which
 527          * page the current offset would be, and check whether that's
 528                  * the offset of the buffer we have.  If not, get the buffer.
 529                  */
 530         thyper.HighPart = curOffset.HighPart;
 531         thyper.LowPart = curOffset.LowPart & ~(buf_bufferSize-1);
 532         if (!bufferp || !LargeIntegerEqualTo(thyper, bufferOffset)) {
 533                         /* wrong buffer */
 534             if (bufferp) {
 535                                 lock_ReleaseMutex(&bufferp->mx);
 536                 buf_Release(bufferp);
 537                 bufferp = NULL;
 538                         }
 539
 540                         lock_ObtainRead(&scp->bufCreateLock);
 541             code = buf_Get(scp, &thyper, &bufferp);
 542                         lock_ReleaseRead(&scp->bufCreateLock);
 543
 544                         lock_ObtainMutex(&bufferp->mx);
 545             if (code) break;
 546             bufferOffset = thyper;
 547
 548             /* now get the data in the cache */
 549             while (1) {
 550                 lock_ObtainMutex(&scp->mx);
 551                                 code = cm_SyncOp(scp, bufferp, userp, reqp,
 552                                  PRSFS_LOOKUP,
 553                                  CM_SCACHESYNC_NEEDCALLBACK
 554                                  | CM_SCACHESYNC_READ
 555                                  | CM_SCACHESYNC_BUFLOCKED);
 556                                 if (code) {
 557                                         lock_ReleaseMutex(&scp->mx);
 558                                         break;
 559                                 }
 560
 561                 if (cm_HaveBuffer(scp, bufferp, 1)) {
 562                                         lock_ReleaseMutex(&scp->mx);
 563                                         break;
 564                                 }
 565
 566                 /* otherwise, load the buffer and try again */
 567                 lock_ReleaseMutex(&bufferp->mx);
 568                 code = cm_GetBuffer(scp, bufferp, NULL, userp,
 569                                     reqp);
 570                 lock_ReleaseMutex(&scp->mx);
 571                 lock_ObtainMutex(&bufferp->mx);
 572                 if (code) break;
 573             }
 574             if (code) {
 575                                 lock_ReleaseMutex(&bufferp->mx);
 576                                 buf_Release(bufferp);
 577                 bufferp = NULL;
 578                 break;
 579                         }
 580         }       /* if (wrong buffer) ... */
 581
 582         /* now we have the buffer containing the entry we're interested
 583          * in; copy it out if it represents a non-deleted entry.
 584          */
 585                 entryInDir = curOffset.LowPart & (2048-1);
 586         entryInBuffer = curOffset.LowPart & (buf_bufferSize - 1);
 587
 588                 /* page header will help tell us which entries are free.  Page
 589                  * header can change more often than once per buffer, since
 590                  * AFS 3 dir page size may be less than (but not more than) a
 591                  * buffer package buffer.
 592          */
 593                 /* only look intra-buffer */
 594                 temp = curOffset.LowPart & (buf_bufferSize - 1);
 595         temp &= ~(2048 - 1);    /* turn off intra-page bits */
 596                 pageHeaderp = (cm_pageHeader_t *) (bufferp->datap + temp);
 597
 598                 /* now determine which entry we're looking at in the page.  If
 599                  * it is free (there's a free bitmap at the start of the dir),
 600                  * we should skip these 32 bytes.
 601          */
 602         slotInPage = (entryInDir & 0x7e0) >> 5;
 603         if (!(pageHeaderp->freeBitmap[slotInPage>>3]
 604                & (1 << (slotInPage & 0x7)))) {
 605                         /* this entry is free */
 606             numDirChunks = 1;   /* only skip this guy */
 607             goto nextEntry;
 608         }
 609
 610                 tp = bufferp->datap + entryInBuffer;
 611         dep = (cm_dirEntry_t *) tp;     /* now points to AFS3 dir entry */
 612
 613         /* while we're here, compute the next entry's location, too,
 614                  * since we'll need it when writing out the cookie into the
 615                  * dir listing stream.
 616          */
 617                 numDirChunks = cm_NameEntries(dep->name, NULL);
 618
 619         /* compute the offset of the cookie representing the next entry */
 620         nextEntryCookie = curOffset.LowPart
 621                         + (CM_DIR_CHUNKSIZE * numDirChunks);
 622
 623         if (dep->fid.vnode != 0) {
 624                         /* this is one of the entries to use: it is not deleted */
 625                         code = (*funcp)(scp, dep, parmp, &curOffset);
 626             if (code) break;
 627                 }       /* if we're including this name */
 628
 629       nextEntry:
 630         /* and adjust curOffset to be where the new cookie is */
 631                 thyper.HighPart = 0;
 632         thyper.LowPart = CM_DIR_CHUNKSIZE * numDirChunks;
 633         curOffset = LargeIntegerAdd(thyper, curOffset);
 634     }           /* while copying data for dir listing */
 635
 636         /* release the mutex */
 637     if (bufferp) {
 638                 lock_ReleaseMutex(&bufferp->mx);
 639         buf_Release(bufferp);
 640         }
 641     return code;
 642 }
 643
 644 int cm_NoneUpper(char *s)
 645 {
 646         char c;
 647         while (c = *s++)
 648                 if (c >= 'A' && c <= 'Z')
 649                         return 0;
 650         return 1;
 651 }
 652
 653 int cm_NoneLower(char *s)
 654 {
 655         char c;
 656         while (c = *s++)
 657                 if (c >= 'a' && c <= 'z')
 658                         return 0;
 659         return 1;
 660 }
 661
 662 long cm_LookupSearchProc(cm_scache_t *scp, cm_dirEntry_t *dep, void *rockp,
 663         osi_hyper_t *offp)
 664 {
 665         cm_lookupSearch_t *sp;
 666     int match;
 667         char shortName[13];
 668         char *matchName;
 669
 670     sp = (cm_lookupSearch_t *) rockp;
 671
 672         matchName = dep->name;
 673         if (sp->caseFold)
 674         match = cm_stricmp(matchName, sp->searchNamep);
 675         else
 676                 match = strcmp(matchName, sp->searchNamep);
 677
 678         if (match != 0
 679             && sp->hasTilde
 680             && !cm_Is8Dot3(dep->name)) {
 681                 matchName = shortName;
 682                 cm_Gen8Dot3Name(dep, shortName, NULL);
 683                 if (sp->caseFold)
 684                         match = cm_stricmp(matchName, sp->searchNamep);
 685                 else
 686                         match = strcmp(matchName, sp->searchNamep);
 687         }
 688
 689         if (match != 0)
 690                 return 0;
 691
 692         sp->found = 1;
 693     if(!sp->caseFold) sp->ExactFound = 1;
 694
 695         if (!sp->caseFold || matchName == shortName) {
 696                 sp->fid.vnode = ntohl(dep->fid.vnode);
 697                 sp->fid.unique = ntohl(dep->fid.unique);
 698         return CM_ERROR_STOPNOW;
 699     }
 700
 701         /*
 702          * If we get here, we are doing a case-insensitive search, and we
 703          * have found a match.  Now we determine what kind of match it is:
 704          * exact, lower-case, upper-case, or none of the above.  This is done
 705          * in order to choose among matches, if there are more than one.
 706          */
 707
 708         /* Exact matches are the best. */
 709         match = strcmp(matchName, sp->searchNamep);
 710         if (match == 0) {
 711         sp->ExactFound = 1;
 712                 sp->fid.vnode = ntohl(dep->fid.vnode);
 713                 sp->fid.unique = ntohl(dep->fid.unique);
 714         return CM_ERROR_STOPNOW;
 715     }
 716
 717         /* Lower-case matches are next. */
 718         if (sp->LCfound)
 719                 return 0;
 720         if (cm_NoneUpper(matchName)) {
 721                 sp->LCfound = 1;
 722                 goto inexact;
 723         }
 724
 725         /* Upper-case matches are next. */
 726         if (sp->UCfound)
 727                 return 0;
 728         if (cm_NoneLower(matchName)) {
 729                 sp->UCfound = 1;
 730                 goto inexact;
 731         }
 732
 733         /* General matches are last. */
 734         if (sp->NCfound)
 735                 return 0;
 736         sp->NCfound = 1;
 737
 738 inexact:
 739         sp->fid.vnode = ntohl(dep->fid.vnode);
 740         sp->fid.unique = ntohl(dep->fid.unique);
 741         return 0;
 742 }
 743
 744 /* read the contents of a mount point into the appropriate string.
 745  * called with locked scp, and returns with locked scp.
 746  */
 747 long cm_ReadMountPoint(cm_scache_t *scp, cm_user_t *userp, cm_req_t *reqp)
 748 {
 749         long code;
 750         cm_buf_t *bufp;
 751         osi_hyper_t thyper;
 752         int tlen;
 753
 754         if (scp->mountPointStringp) return 0;
 755
 756         /* otherwise, we have to read it in */
 757         lock_ReleaseMutex(&scp->mx);
 758
 759         lock_ObtainRead(&scp->bufCreateLock);
 760         thyper.LowPart = thyper.HighPart = 0;
 761         code = buf_Get(scp, &thyper, &bufp);
 762         lock_ReleaseRead(&scp->bufCreateLock);
 763
 764         lock_ObtainMutex(&scp->mx);
 765         if (code) {
 766                 return code;
 767         }
 768         while (1) {
 769                 code = cm_SyncOp(scp, bufp, userp, reqp, 0,
 770                         CM_SCACHESYNC_READ | CM_SCACHESYNC_NEEDCALLBACK);
 771                 if (code) {
 772                         goto done;
 773                 }
 774
 775                 if (cm_HaveBuffer(scp, bufp, 0)) break;
 776
 777                 /* otherwise load buffer */
 778                 code = cm_GetBuffer(scp, bufp, NULL, userp, reqp);
 779                 if (code) {
 780                         goto done;
 781                 }
 782         }
 783         /* locked, has callback, has valid data in buffer */
 784         if ((tlen = scp->length.LowPart) > 1000) return CM_ERROR_TOOBIG;
 785         if (tlen <= 0) {
 786                 code = CM_ERROR_INVAL;
 787                 goto done;
 788         }
 789
 790         /* someone else did the work while we were out */
 791         if (scp->mountPointStringp) {
 792                 code = 0;
 793                 goto done;
 794         }
 795
 796         /* otherwise, copy out the link */
 797         scp->mountPointStringp = malloc(tlen);
 798         memcpy(scp->mountPointStringp, bufp->datap, tlen);
 799
 800         /* now make it null-terminated.  Note that the original contents of a
 801          * link that is a mount point is "#volname." where "." is there just to
 802          * be turned into a null.  That is, we can trash the last char of the
 803          * link without damaging the vol name.  This is a stupid convention,
 804          * but that's the protocol.
 805          */
 806         scp->mountPointStringp[tlen-1] = 0;
 807         code = 0;
 808
 809 done:
 810         if (bufp) buf_Release(bufp);
 811         return code;
 812 }
 813
 814 /* called with a locked scp and chases the mount point, yielding outScpp.
 815  * scp remains locked, just for simplicity of describing the interface.
 816  */
 817 long cm_FollowMountPoint(cm_scache_t *scp, cm_scache_t *dscp, cm_user_t *userp,
 818         cm_req_t *reqp, cm_scache_t **outScpp)
 819 {
 820         char *cellNamep;
 821         char *volNamep;
 822         int tlen;
 823         long code;
 824         char *cp;
 825         char *mpNamep;
 826         cm_volume_t *volp;
 827         cm_cell_t *cellp;
 828         char mtType;
 829         cm_fid_t tfid;
 830         size_t vnLength;
 831         int type;
 832
 833         if (scp->mountRootFidp && scp->mountRootGen >= cm_mountRootGen) {
 834                 tfid = *scp->mountRootFidp;
 835                 lock_ReleaseMutex(&scp->mx);
 836                 code = cm_GetSCache(&tfid, outScpp, userp, reqp);
 837                 lock_ObtainMutex(&scp->mx);
 838                 return code;
 839         }
 840
 841         /* parse the volume name */
 842         mpNamep = scp->mountPointStringp;
 843         osi_assert(mpNamep);
 844         tlen = strlen(scp->mountPointStringp);
 845         mtType = *scp->mountPointStringp;
 846         cellNamep = malloc(tlen);
 847         volNamep = malloc(tlen);
 848
 849         cp = strrchr(mpNamep, ':');
 850         if (cp) {
 851                 /* cellular mount point */
 852                 memset(cellNamep, 0, tlen);
 853                 strncpy(cellNamep, mpNamep+1, cp - mpNamep - 1);
 854                 strcpy(volNamep, cp+1);
 855                 /* now look up the cell */
 856                 cellp = cm_GetCell(cellNamep, CM_FLAG_CREATE);
 857         }
 858         else {
 859                 /* normal mt pt */
 860                 strcpy(volNamep, mpNamep+1);
 861
 862                 cellp = cm_FindCellByID(scp->fid.cell);
 863         }
 864
 865         if (!cellp) {
 866                 code = CM_ERROR_NOSUCHCELL;
 867                 goto done;
 868         }
 869
 870         vnLength = strlen(volNamep);
 871         if (vnLength >= 8 && strcmp(volNamep + vnLength - 7, ".backup") == 0)
 872                 type = BACKVOL;
 873         else if (vnLength >= 10
 874                   && strcmp(volNamep + vnLength - 9, ".readonly") == 0)
 875                 type = ROVOL;
 876         else
 877                 type = RWVOL;
 878
 879         /* check for backups within backups */
 880         if (type == BACKVOL
 881             && (scp->flags & (CM_SCACHEFLAG_RO | CM_SCACHEFLAG_PURERO))
 882                   == CM_SCACHEFLAG_RO) {
 883                 code = CM_ERROR_NOSUCHVOLUME;
 884                 goto done;
 885         }
 886
 887         /* now we need to get the volume */
 888         lock_ReleaseMutex(&scp->mx);
 889         code = cm_GetVolumeByName(cellp, volNamep, userp, reqp, 0, &volp);
 890         lock_ObtainMutex(&scp->mx);
 891
 892         if (code == 0) {
 893                 /* save the parent of the volume root for this is the
 894                  * place where the volume is mounted and we must remember
 895                  * this in the volume structure rather than just in the
 896                  * scache entry lest the scache entry gets recycled
 897                  * (defect 11489)
 898                  */
 899                 lock_ObtainMutex(&volp->mx);
 900                 if(volp->dotdotFidp == (cm_fid_t *) NULL)
 901                         volp->dotdotFidp = (cm_fid_t *) malloc(sizeof(cm_fid_t));
 902                 *(volp->dotdotFidp) = dscp->fid;
 903                 lock_ReleaseMutex(&volp->mx);
 904
 905                 if (scp->mountRootFidp == 0) {
 906                         scp->mountRootFidp = malloc(sizeof(cm_fid_t));
 907                 }
 908                 scp->mountRootFidp->cell = cellp->cellID;
 909                 /* if the mt pt is in a read-only volume (not just a
 910                  * backup), and if there is a read-only volume for the
 911                  * target, and if this is a type '#' mount point, use
 912                  * the read-only, otherwise use the one specified.
 913                  */
 914                 if (mtType == '#' && (scp->flags & CM_SCACHEFLAG_PURERO)
 915                         && volp->roID != 0 && type == RWVOL)
 916                         type = ROVOL;
 917                 if (type == ROVOL)
 918                         scp->mountRootFidp->volume = volp->roID;
 919                 else if (type == BACKVOL)
 920                         scp->mountRootFidp->volume = volp->bkID;
 921                 else
 922                         scp->mountRootFidp->volume = volp->rwID;
 923
 924                 /* the rest of the fid is a magic number */
 925                 scp->mountRootFidp->vnode = 1;
 926                 scp->mountRootFidp->unique = 1;
 927                 scp->mountRootGen = cm_mountRootGen;
 928
 929                 tfid = *scp->mountRootFidp;
 930                 lock_ReleaseMutex(&scp->mx);
 931                 code = cm_GetSCache(&tfid, outScpp, userp, reqp);
 932                 lock_ObtainMutex(&scp->mx);
 933         }
 934
 935 done:
 936         free(cellNamep);
 937         free(volNamep);
 938         return code;
 939 }
 940
 941 int cm_ExpandSysName(char *inp, char *outp, long outSize)
 942 {
 943         char *tp;
 944     int prefixCount;
 945
 946     tp = strrchr(inp, '@');
 947     if (tp == NULL) return 0;           /* no @sys */
 948
 949     if (strcmp(tp, "@sys") != 0) return 0;      /* no @sys */
 950
 951         /* caller just wants to know if this is a valid @sys type of name */
 952         if (outp == NULL) return 1;
 953
 954         /* otherwise generate the properly expanded @sys name */
 955     prefixCount = tp - inp;
 956
 957     strncpy(outp, inp, prefixCount);    /* copy out "a." from "a.@sys" */
 958     outp[prefixCount] = 0;                      /* null terminate the "a." */
 959     strcat(outp, cm_sysName);           /* append i386_nt40 */
 960     return 1;
 961 }
 962
 963 long cm_Lookup(cm_scache_t *dscp, char *namep, long flags, cm_user_t *userp,
 964         cm_req_t *reqp, cm_scache_t **outpScpp)
 965 {
 966         long code;
 967         int dnlcHit = 1;        /* did we hit in the dnlc? yes, we did */
 968     cm_scache_t *tscp = NULL;
 969     cm_scache_t *mountedScp;
 970     cm_lookupSearch_t rock;
 971     char tname[256];
 972         int getroot;
 973
 974         if (dscp->fid.vnode == 1 && dscp->fid.unique == 1
 975          && strcmp(namep, "..") == 0) {
 976                 if (dscp->dotdotFidp == (cm_fid_t *)NULL
 977              || dscp->dotdotFidp->volume == 0)
 978                         return CM_ERROR_NOSUCHVOLUME;
 979                 rock.fid = *dscp->dotdotFidp;
 980                 goto haveFid;
 981         }
 982
 983         if (cm_ExpandSysName(namep, tname, sizeof(tname))) {
 984                 namep = tname;
 985     }
 986         memset(&rock, 0, sizeof(rock));
 987     rock.fid.cell = dscp->fid.cell;
 988     rock.fid.volume = dscp->fid.volume;
 989     rock.searchNamep = namep;
 990     rock.caseFold = (flags & CM_FLAG_CASEFOLD);
 991         rock.hasTilde = ((strchr(namep, '~') != NULL) ? 1 : 0);
 992
 993         /* If NOMOUNTCHASE, bypass DNLC by passing NULL scp pointer */
 994         code = cm_ApplyDir(dscp, cm_LookupSearchProc, &rock, NULL, userp, reqp,
 995                        (flags & CM_FLAG_NOMOUNTCHASE) ? NULL : &tscp);
 996
 997         /* code == 0 means we fell off the end of the dir, while stopnow means
 998      * that we stopped early, probably because we found the entry we're
 999          * looking for.  Any other non-zero code is an error.
1000      */
1001     if (code && code != CM_ERROR_STOPNOW)
1002         return code;
1003
1004         getroot = (dscp==cm_rootSCachep) ;
1005     if (!rock.found) {
1006         if (!cm_freelanceEnabled || !getroot) {
1007             if (flags & CM_FLAG_CHECKPATH)
1008                 return CM_ERROR_NOSUCHPATH;
1009             else
1010                 return CM_ERROR_NOSUCHFILE;
1011         }
1012         else {  /* nonexistent dir on freelance root, so add it */
1013                         osi_Log1(afsd_logp,"cm_Lookup adding mount for non-existent directory: %s",
1014                      osi_LogSaveString(afsd_logp,namep));
1015                         code = cm_FreelanceAddMount(namep, namep, "root.cell.", namep[0] == '.', &rock.fid);
1016             if (code < 0) {   /* add mount point failed, so give up */
1017                 if (flags & CM_FLAG_CHECKPATH)
1018                     return CM_ERROR_NOSUCHPATH;
1019                 else
1020                     return CM_ERROR_NOSUCHFILE;
1021             }
1022             tscp = NULL;   /* to force call of cm_GetSCache */
1023         }
1024         }
1025
1026 haveFid:
1027         if ( !tscp )    /* we did not find it in the dnlc */
1028         {
1029                 dnlcHit = 0;
1030         code = cm_GetSCache(&rock.fid, &tscp, userp, reqp);
1031         if (code)
1032             return code;
1033         }
1034     /* tscp is now held */
1035
1036         lock_ObtainMutex(&tscp->mx);
1037         code = cm_SyncOp(tscp, NULL, userp, reqp, 0,
1038                       CM_SCACHESYNC_GETSTATUS | CM_SCACHESYNC_NEEDCALLBACK);
1039     if (code) {
1040                 lock_ReleaseMutex(&tscp->mx);
1041                 cm_ReleaseSCache(tscp);
1042         return code;
1043         }
1044     /* tscp is now locked */
1045
1046     if (!(flags & CM_FLAG_NOMOUNTCHASE)
1047               && tscp->fileType == CM_SCACHETYPE_MOUNTPOINT) {
1048                 /* mount points are funny: they have a volume name to mount
1049          * the root of.
1050          */
1051                 code = cm_ReadMountPoint(tscp, userp, reqp);
1052         if (code == 0)
1053                         code = cm_FollowMountPoint(tscp, dscp, userp, reqp,
1054                                         &mountedScp);
1055                 lock_ReleaseMutex(&tscp->mx);
1056                 cm_ReleaseSCache(tscp);
1057                 if (code) {
1058             return code;
1059         }
1060         tscp = mountedScp;
1061     }
1062         else {
1063                 lock_ReleaseMutex(&tscp->mx);
1064         }
1065
1066         /* copy back pointer */
1067     *outpScpp = tscp;
1068
1069         /* insert scache in dnlc */
1070         if ( !dnlcHit && !(flags & CM_FLAG_NOMOUNTCHASE) && rock.ExactFound ) {
1071             /* lock the directory entry to prevent racing callback revokes */
1072             lock_ObtainMutex(&dscp->mx);
1073             if ( dscp->cbServerp && dscp->cbExpires )
1074             cm_dnlcEnter(dscp, namep, tscp);
1075             lock_ReleaseMutex(&dscp->mx);
1076         }
1077
1078         /* and return */
1079     return 0;
1080 }
1081
1082 long cm_Unlink(cm_scache_t *dscp, char *namep, cm_user_t *userp, cm_req_t *reqp)
1083 {
1084         long code;
1085         cm_conn_t *connp;
1086         AFSFid afsFid;
1087         int sflags;
1088         AFSFetchStatus newDirStatus;
1089         AFSVolSync volSync;
1090
1091 #ifdef AFS_FREELANCE_CLIENT
1092         if (cm_freelanceEnabled && dscp == cm_rootSCachep) {
1093           /* deleting a mount point from the root dir. */
1094           code = cm_FreelanceRemoveMount(namep);
1095           return code;
1096         }
1097 #endif
1098
1099         /* make sure we don't screw up the dir status during the merge */
1100         lock_ObtainMutex(&dscp->mx);
1101         sflags = CM_SCACHESYNC_STOREDATA;
1102         code = cm_SyncOp(dscp, NULL, userp, reqp, 0, sflags);
1103         lock_ReleaseMutex(&dscp->mx);
1104         if (code) return code;
1105
1106         /* make the RPC */
1107         afsFid.Volume = dscp->fid.volume;
1108         afsFid.Vnode = dscp->fid.vnode;
1109         afsFid.Unique = dscp->fid.unique;
1110         do {
1111                 code = cm_Conn(&dscp->fid, userp, reqp, &connp);
1112                 if (code) continue;
1113
1114                 code = RXAFS_RemoveFile(connp->callp, &afsFid, namep,
1115                                         &newDirStatus, &volSync);
1116
1117         } while (cm_Analyze(connp, userp, reqp, &dscp->fid, &volSync, NULL, NULL, code));
1118         code = cm_MapRPCError(code, reqp);
1119
1120         lock_ObtainMutex(&dscp->mx);
1121         cm_dnlcRemove(dscp, namep);
1122         cm_SyncOpDone(dscp, NULL, sflags);
1123         if (code == 0) cm_MergeStatus(dscp, &newDirStatus, &volSync, userp, 0);
1124         lock_ReleaseMutex(&dscp->mx);
1125
1126         return code;
1127 }
1128
1129 /* called with a locked vnode, and fills in the link info.
1130  * returns this the vnode still locked.
1131  */
1132 long cm_HandleLink(cm_scache_t *linkScp, cm_user_t *userp, cm_req_t *reqp)
1133 {
1134         long code;
1135         cm_buf_t *bufp;
1136         long temp;
1137         osi_hyper_t thyper;
1138
1139         lock_AssertMutex(&linkScp->mx);
1140         if (!linkScp->mountPointStringp) {
1141                 /* read the link data */
1142                 lock_ReleaseMutex(&linkScp->mx);
1143                 thyper.LowPart = thyper.HighPart = 0;
1144                 code = buf_Get(linkScp, &thyper, &bufp);
1145                 lock_ObtainMutex(&linkScp->mx);
1146                 if (code) return code;
1147                 while (1) {
1148                         code = cm_SyncOp(linkScp, bufp, userp, reqp, 0,
1149                                 CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_READ);
1150                         if (code) {
1151                                 buf_Release(bufp);
1152                                 return code;
1153                         }
1154                         if (cm_HaveBuffer(linkScp, bufp, 0)) break;
1155
1156                         code = cm_GetBuffer(linkScp, bufp, NULL, userp, reqp);
1157                         if (code) {
1158                                 buf_Release(bufp);
1159                                 return code;
1160                         }
1161                 } /* while loop to get the data */
1162
1163                 /* now if we still have no link read in,
1164                  * copy the data from the buffer */
1165                 if ((temp = linkScp->length.LowPart) >= 1024) {
1166                         buf_Release(bufp);
1167                         return CM_ERROR_TOOBIG;
1168                 }
1169
1170                 /* otherwise, it fits; make sure it is still null (could have
1171                  * lost race with someone else referencing this link above),
1172                  * and if so, copy in the data.
1173                  */
1174                 if (linkScp->mountPointStringp == NULL) {
1175                         linkScp->mountPointStringp = malloc(temp+1);
1176                         strncpy(linkScp->mountPointStringp, bufp->datap, temp);
1177                         linkScp->mountPointStringp[temp] = 0;   /* null terminate */
1178                 }
1179                 buf_Release(bufp);
1180         }       /* don't have sym link contents cached */
1181
1182         return 0;
1183 }
1184
1185 /* called with a held vnode and a path suffix, with the held vnode being a
1186  * symbolic link.  Our goal is to generate a new path to interpret, and return
1187  * this new path in newSpaceBufferp.  If the new vnode is relative to a dir
1188  * other than the directory containing the symbolic link, then the new root is
1189  * returned in *newRootScpp, otherwise a null is returned there.
1190  */
1191 long cm_AssembleLink(cm_scache_t *linkScp, char *pathSuffixp,
1192         cm_scache_t **newRootScpp, cm_space_t **newSpaceBufferp,
1193         cm_user_t *userp, cm_req_t *reqp)
1194 {
1195         long code;
1196         char *linkp;
1197         cm_space_t *tsp;
1198
1199         lock_ObtainMutex(&linkScp->mx);
1200         code = cm_HandleLink(linkScp, userp, reqp);
1201         if (code) goto done;
1202
1203         /* if we may overflow the buffer, bail out; buffer is signficantly
1204          * bigger than max path length, so we don't really have to worry about
1205          * being a little conservative here.
1206          */
1207         if (strlen(linkScp->mountPointStringp) + strlen(pathSuffixp) + 2
1208              >= CM_UTILS_SPACESIZE)
1209                 return CM_ERROR_TOOBIG;
1210
1211         tsp = cm_GetSpace();
1212         linkp = linkScp->mountPointStringp;
1213         if (strncmp(linkp, cm_mountRoot, cm_mountRootLen) == 0) {
1214                 if (strlen(linkp) > cm_mountRootLen)
1215                         strcpy(tsp->data, linkp+cm_mountRootLen+1);
1216                 else
1217                         tsp->data[0] = 0;
1218                 *newRootScpp = cm_rootSCachep;
1219                 cm_HoldSCache(cm_rootSCachep);
1220         } else if (*linkp == '\\' || *linkp == '/') {
1221           /* formerly, this was considered to be from the AFS root,
1222              but this seems to create problems.  instead, we will just
1223              reject the link */
1224 #if 0
1225                 strcpy(tsp->data, linkp+1);
1226                 *newRootScpp = cm_rootSCachep;
1227                 cm_HoldSCache(cm_rootSCachep);
1228 #else
1229                 code = CM_ERROR_NOSUCHPATH;
1230                 goto done;
1231 #endif
1232         }
1233         else {
1234                 /* a relative link */
1235                 strcpy(tsp->data, linkp);
1236                 *newRootScpp = NULL;
1237         }
1238         if (pathSuffixp[0] != 0) {      /* if suffix string is non-null */
1239                 strcat(tsp->data, "\\");
1240                 strcat(tsp->data, pathSuffixp);
1241         }
1242         *newSpaceBufferp = tsp;
1243         code = 0;
1244
1245 done:
1246         lock_ReleaseMutex(&linkScp->mx);
1247         return code;
1248 }
1249
1250 long cm_NameI(cm_scache_t *rootSCachep, char *pathp, long flags,
1251         cm_user_t *userp, char *tidPathp, cm_req_t *reqp, cm_scache_t **outScpp)
1252 {
1253         long code;
1254         char *tp;                       /* ptr moving through input buffer */
1255         char tc;                        /* temp char */
1256         int haveComponent;              /* has new component started? */
1257         char component[256];            /* this is the new component */
1258         char *cp;                       /* component name being assembled */
1259         cm_scache_t *tscp;              /* current location in the hierarchy */
1260         cm_scache_t *nscp;              /* next dude down */
1261         cm_scache_t *dirScp;            /* last dir we searched */
1262         cm_scache_t *linkScp;           /* new root for the symlink we just
1263                                          * looked up */
1264         cm_space_t *psp;                /* space for current path, if we've hit
1265                                          * any symlinks */
1266         cm_space_t *tempsp;             /* temp vbl */
1267         char *restp;                    /* rest of the pathname to interpret */
1268         int symlinkCount;               /* count of # of symlinks traversed */
1269         int extraFlag;                  /* avoid chasing mt pts for dir cmd */
1270         int phase = 1;                  /* 1 = tidPathp, 2 = pathp */
1271
1272         tp = tidPathp;
1273         if (tp == NULL) {
1274                 tp = pathp;
1275                 phase = 2;
1276         }
1277         if (tp == NULL) {
1278                 tp = "";
1279         }
1280         haveComponent = 0;
1281         psp = NULL;
1282         tscp = rootSCachep;
1283         cm_HoldSCache(tscp);
1284         symlinkCount = 0;
1285         while (1) {
1286             tc = *tp++;
1287
1288             /* map Unix slashes into DOS ones so we can interpret Unix
1289              * symlinks properly
1290              */
1291             if (tc == '/') tc = '\\';
1292
1293             if (!haveComponent) {
1294                         if (tc == '\\') continue;
1295             else if (tc == 0) {
1296                                 if (phase == 1) {
1297                                         phase = 2;
1298                                         tp = pathp;
1299                                         continue;
1300                                 }
1301                 code = 0;
1302                 break;
1303             }
1304             else {
1305                                 haveComponent = 1;
1306                 cp = component;
1307                 *cp++ = tc;
1308             }
1309             }
1310             else {
1311                 /* we have a component here */
1312                 if (tc == 0 || tc == '\\') {
1313                     /* end of the component; we're at the last
1314                      * component if tc == 0.  However, if the last
1315                      * is a symlink, we have more to do.
1316                      */
1317                     *cp++ = 0;  /* add null termination */
1318                     extraFlag = 0;
1319                     if ((flags & CM_FLAG_DIRSEARCH) && tc == 0)
1320                         extraFlag = CM_FLAG_NOMOUNTCHASE;
1321                     code = cm_Lookup(tscp, component,
1322                                       flags | extraFlag,
1323                                       userp, reqp, &nscp);
1324
1325                     if (code) {
1326                         cm_ReleaseSCache(tscp);
1327                         if (psp) cm_FreeSpace(psp);
1328                         return code;
1329                     }
1330                     haveComponent = 0;  /* component done */
1331                     dirScp = tscp;              /* for some symlinks */
1332                     tscp = nscp;        /* already held */
1333                     if (tc == 0 && !(flags & CM_FLAG_FOLLOW) && phase == 2) {
1334                         code = 0;
1335                         cm_ReleaseSCache(dirScp);
1336                         break;
1337                     }
1338
1339                     /* now, if tscp is a symlink, we should follow
1340                      * it and assemble the path again.
1341                      */
1342                     lock_ObtainMutex(&tscp->mx);
1343                     code = cm_SyncOp(tscp, NULL, userp, reqp, 0,
1344                                       CM_SCACHESYNC_GETSTATUS
1345                                       | CM_SCACHESYNC_NEEDCALLBACK);
1346                     if (code) {
1347                         lock_ReleaseMutex(&tscp->mx);
1348                         cm_ReleaseSCache(tscp);
1349                         cm_ReleaseSCache(dirScp);
1350                         break;
1351                     }
1352                     if (tscp->fileType == CM_SCACHETYPE_SYMLINK) {
1353                         /* this is a symlink; assemble a new buffer */
1354                         lock_ReleaseMutex(&tscp->mx);
1355                         if (symlinkCount++ >= 16) {
1356                             cm_ReleaseSCache(tscp);
1357                             cm_ReleaseSCache(dirScp);
1358                             if (psp) cm_FreeSpace(psp);
1359                             return CM_ERROR_TOOBIG;
1360                         }
1361                         if (tc == 0) restp = "";
1362                         else restp = tp;
1363                         code = cm_AssembleLink(tscp, restp, &linkScp, &tempsp, userp, reqp);
1364                         if (code) {
1365                             /* something went wrong */
1366                             cm_ReleaseSCache(tscp);
1367                             cm_ReleaseSCache(dirScp);
1368                             break;
1369                         }
1370
1371                         /* otherwise, tempsp has the new path,
1372                          * and linkScp is the new root from
1373                          * which to interpret that path.
1374                          * Continue with the namei processing,
1375                          * also doing the bookkeeping for the
1376                          * space allocation and tracking the
1377                          * vnode reference counts.
1378                          */
1379                         if (psp) cm_FreeSpace(psp);
1380                         psp = tempsp;
1381                         tp = psp->data;
1382                         cm_ReleaseSCache(tscp);
1383                         tscp = linkScp; /* already held
1384                                          * by AssembleLink */
1385                         /* now, if linkScp is null, that's
1386                          * AssembleLink's way of telling us that
1387                          * the sym link is relative to the dir
1388                          * containing the link.  We have a ref
1389                          * to it in dirScp, and we hold it now
1390                          * and reuse it as the new spot in the
1391                          * dir hierarchy.
1392                          */
1393                         if (tscp == NULL) {
1394                             cm_HoldSCache(dirScp);
1395                             tscp = dirScp;
1396                         }
1397                     }   /* if we have a sym link */
1398                     else {
1399                         /* not a symlink, we may be done */
1400                         lock_ReleaseMutex(&tscp->mx);
1401                         if (tc == 0) {
1402                             if (phase == 1) {
1403                                 phase = 2;
1404                                 tp = pathp;
1405                                 continue;
1406                             }
1407                             cm_ReleaseSCache(dirScp);
1408                             code = 0;
1409                             break;
1410                         }
1411                     }
1412                     cm_ReleaseSCache(dirScp);
1413                 } /* end of a component */
1414                 else *cp++ = tc;
1415             } /* we have a component */
1416         } /* big while loop over all components */
1417
1418         /* already held */
1419     if (psp) cm_FreeSpace(psp);
1420         if (code == 0) *outScpp = tscp;
1421         return code;
1422 }
1423
1424 /* called with a dir, and a vnode within the dir that happens to be a symlink.
1425  * We chase the link, and return a held pointer to the target, if it exists,
1426  * in *outScpp.  If we succeed, we return 0, otherwise we return an error code
1427  * and do not hold or return a target vnode.
1428  *
1429  * This is very similar to calling cm_NameI with the last component of a name,
1430  * which happens to be a symlink, except that we've already passed by the name.
1431  *
1432  * This function is typically called by the directory listing functions, which
1433  * encounter symlinks but need to return the proper file length so programs
1434  * like "more" work properly when they make use of the attributes retrieved from
1435  * the dir listing.
1436  *
1437  * The input vnode should not be locked when this function is called.
1438  */
1439 long cm_EvaluateSymLink(cm_scache_t *dscp, cm_scache_t *linkScp,
1440         cm_scache_t **outScpp, cm_user_t *userp, cm_req_t *reqp)
1441 {
1442         long code;
1443         cm_space_t *spacep;
1444         cm_scache_t *newRootScp;
1445
1446         osi_Log1(afsd_logp, "Evaluating symlink vp %x", linkScp);
1447
1448         code = cm_AssembleLink(linkScp, "", &newRootScp, &spacep, userp, reqp);
1449         if (code) return code;
1450
1451         /* now, if newRootScp is NULL, we're really being told that the symlink
1452          * is relative to the current directory (dscp).
1453          */
1454         if (newRootScp == NULL) {
1455                 newRootScp = dscp;
1456                 cm_HoldSCache(dscp);
1457         }
1458
1459         code = cm_NameI(newRootScp, spacep->data,
1460                 CM_FLAG_CASEFOLD | CM_FLAG_FOLLOW | CM_FLAG_DIRSEARCH,
1461                 userp, NULL, reqp, outScpp);
1462
1463         /* this stuff is allocated no matter what happened on the namei call,
1464          * so free it */
1465         cm_FreeSpace(spacep);
1466         cm_ReleaseSCache(newRootScp);
1467
1468         return code;
1469 }
1470
1471 /* make this big enough so that one buffer of dir pages won't overflow.  We'll
1472  * check anyway, but we want to minimize the chance that we have to leave stuff
1473  * unstat'd.
1474  */
1475 #define CM_BULKMAX              128
1476
1477 /* rock for bulk stat calls */
1478 typedef struct cm_bulkStat {
1479         osi_hyper_t bufOffset;  /* only do it for things in this buffer page */
1480
1481         /* info for the actual call */
1482         int counter;                    /* next free slot */
1483         AFSFid fids[CM_BULKMAX];
1484         AFSFetchStatus stats[CM_BULKMAX];
1485         AFSCallBack callbacks[CM_BULKMAX];
1486 } cm_bulkStat_t;
1487
1488 /* for a given entry, make sure that it isn't in the stat cache, and then
1489  * add it to the list of file IDs to be obtained.
1490  *
1491  * Don't bother adding it if we already have a vnode.  Note that the dir
1492  * is locked, so we have to be careful checking the vnode we're thinking of
1493  * processing, to avoid deadlocks.
1494  */
1495 long cm_TryBulkProc(cm_scache_t *scp, cm_dirEntry_t *dep, void *rockp,
1496         osi_hyper_t *offp)
1497 {
1498         osi_hyper_t thyper;
1499         cm_bulkStat_t *bsp;
1500         int i;
1501         cm_scache_t *tscp;
1502         cm_fid_t tfid;
1503
1504         bsp = rockp;
1505
1506         /* Don't overflow bsp. */
1507         if (bsp->counter >= CM_BULKMAX)
1508                 return CM_ERROR_STOPNOW;
1509
1510         thyper.LowPart = buf_bufferSize;
1511         thyper.HighPart = 0;
1512         thyper = LargeIntegerAdd(thyper, bsp->bufOffset);
1513
1514         /* thyper is now the first byte past the end of the record we're
1515          * interested in, and bsp->bufOffset is the first byte of the record
1516          * we're interested in.
1517          * Skip data in the others.
1518          * Skip '.' and '..'
1519          */
1520         if (LargeIntegerLessThan(*offp, bsp->bufOffset))
1521                 return 0;
1522         if (LargeIntegerGreaterThanOrEqualTo(*offp, thyper))
1523                 return CM_ERROR_STOPNOW;
1524         if (strcmp(dep->name, ".") == 0 || strcmp(dep->name, "..") == 0)
1525                 return 0;
1526
1527         tfid.cell = scp->fid.cell;
1528         tfid.volume = scp->fid.volume;
1529         tfid.vnode = ntohl(dep->fid.vnode);
1530         tfid.unique = ntohl(dep->fid.unique);
1531         tscp = cm_FindSCache(&tfid);
1532         if (tscp) {
1533                 if (lock_TryMutex(&tscp->mx)) {
1534                         /* we have an entry that we can look at */
1535                         if (cm_HaveCallback(tscp)) {
1536                                 /* we have a callback on it.  Don't bother
1537                                  * fetching this stat entry, since we're happy
1538                                  * with the info we have.
1539                                  */
1540                                 lock_ReleaseMutex(&tscp->mx);
1541                                 cm_ReleaseSCache(tscp);
1542                                 return 0;
1543                         }
1544                         lock_ReleaseMutex(&tscp->mx);
1545                 }       /* got lock */
1546                 cm_ReleaseSCache(tscp);
1547         }       /* found entry */
1548
1549 #ifdef AFS_FREELANCE_CLIENT
1550         // yj: if this is a mountpoint under root.afs then we don't want it
1551         // to be bulkstat-ed, instead, we call getSCache directly and under
1552         // getSCache, it is handled specially.
1553         if      ( cm_freelanceEnabled &&
1554           tfid.cell==AFS_FAKE_ROOT_CELL_ID &&
1555           tfid.volume==AFS_FAKE_ROOT_VOL_ID &&
1556           !(tfid.vnode==0x1 && tfid.unique==0x1) )
1557         {
1558         osi_Log0(afsd_logp, "cm_TryBulkProc Freelance calls cm_SCache on root.afs mountpoint");
1559                 return cm_GetSCache(&tfid, &tscp, NULL, NULL);
1560         }
1561 #endif /* AFS_FREELANCE_CLIENT */
1562
1563         i = bsp->counter++;
1564         bsp->fids[i].Volume = scp->fid.volume;
1565         bsp->fids[i].Vnode = tfid.vnode;
1566         bsp->fids[i].Unique = tfid.unique;
1567         return 0;
1568 }
1569
1570 /* called with a locked scp and a pointer to a buffer.  Make bulk stat
1571  * calls on all undeleted files in the page of the directory specified.
1572  */
1573 void cm_TryBulkStat(cm_scache_t *dscp, osi_hyper_t *offsetp, cm_user_t *userp,
1574         cm_req_t *reqp)
1575 {
1576         long code;
1577         cm_bulkStat_t bb;       /* this is *BIG*, probably 12K or so;
1578                                  * watch for stack problems */
1579         AFSCBFids fidStruct;
1580         AFSBulkStats statStruct;
1581         cm_conn_t *connp;
1582         AFSCBs callbackStruct;
1583         long filex;
1584         AFSVolSync volSync;
1585         cm_callbackRequest_t cbReq;
1586         long filesThisCall;
1587         long i;
1588         long j;
1589         cm_scache_t *scp;
1590         cm_fid_t tfid;
1591
1592         osi_Log1(afsd_logp, "cm_TryBulkStat dir 0x%x", (long) dscp);
1593
1594         /* should be on a buffer boundary */
1595         osi_assert((offsetp->LowPart & (buf_bufferSize - 1)) == 0);
1596
1597         bb.counter = 0;
1598         bb.bufOffset = *offsetp;
1599
1600         /* first, assemble the file IDs we need to stat */
1601         code = cm_ApplyDir(dscp, cm_TryBulkProc, (void *) &bb, offsetp, userp,
1602                            reqp, NULL);
1603
1604         /* if we failed, bail out early */
1605         if (code && code != CM_ERROR_STOPNOW) return;
1606
1607         /* otherwise, we may have one or more bulk stat's worth of stuff in bb;
1608          * make the calls to create the entries.  Handle AFSCBMAX files at a
1609          * time.
1610          */
1611         filex = 0;
1612         while(filex < bb.counter) {
1613                 filesThisCall = bb.counter - filex;
1614                 if (filesThisCall > AFSCBMAX) filesThisCall = AFSCBMAX;
1615
1616                 fidStruct.AFSCBFids_len = filesThisCall;
1617                 fidStruct.AFSCBFids_val = &bb.fids[filex];
1618                 statStruct.AFSBulkStats_len = filesThisCall;
1619                 statStruct.AFSBulkStats_val = &bb.stats[filex];
1620                 callbackStruct.AFSCBs_len = filesThisCall;
1621                 callbackStruct.AFSCBs_val = &bb.callbacks[filex];
1622                 cm_StartCallbackGrantingCall(NULL, &cbReq);
1623                 osi_Log1(afsd_logp, "CALL BulkStatus, %d entries", filesThisCall);
1624                 do {
1625                         code = cm_Conn(&dscp->fid, userp, reqp, &connp);
1626                         if (code) continue;
1627
1628                         code = RXAFS_BulkStatus(connp->callp, &fidStruct,
1629                                 &statStruct, &callbackStruct, &volSync);
1630
1631                 } while (cm_Analyze(connp, userp, reqp, &dscp->fid,
1632                                     &volSync, NULL, &cbReq, code));
1633                 code = cm_MapRPCError(code, reqp);
1634
1635                 osi_Log0(afsd_logp, "CALL BulkStatus DONE");
1636
1637                 /* may as well quit on an error, since we're not going to do
1638                  * much better on the next immediate call, either.
1639                  */
1640                 if (code) break;
1641
1642                 /* otherwise, we should do the merges */
1643                 for(i = 0; i<filesThisCall; i++) {
1644                         j = filex + i;
1645                         tfid.cell = dscp->fid.cell;
1646                         tfid.volume = bb.fids[j].Volume;
1647                         tfid.vnode = bb.fids[j].Vnode;
1648                         tfid.unique = bb.fids[j].Unique;
1649                         code = cm_GetSCache(&tfid, &scp, userp, reqp);
1650                         if (code != 0) continue;
1651
1652                         /* otherwise, if this entry has no callback info,
1653                          * merge in this.
1654                          */
1655                         lock_ObtainMutex(&scp->mx);
1656                         /* now, we have to be extra paranoid on merging in this
1657                          * information, since we didn't use cm_SyncOp before
1658                          * starting the fetch to make sure that no bad races
1659                          * were occurring.  Specifically, we need to make sure
1660                          * we don't obliterate any newer information in the
1661                          * vnode than have here.
1662                          *
1663                          * Right now, be pretty conservative: if there's a
1664                          * callback or a pending call, skip it.
1665                          */
1666                         if (scp->cbServerp == NULL
1667                                 && !(scp->flags &
1668                                         (CM_SCACHEFLAG_FETCHING
1669                                          | CM_SCACHEFLAG_STORING
1670                                          | CM_SCACHEFLAG_SIZESTORING))) {
1671                                 cm_EndCallbackGrantingCall(scp, &cbReq,
1672                                         &bb.callbacks[j],
1673                                         CM_CALLBACK_MAINTAINCOUNT);
1674                                 cm_MergeStatus(scp, &bb.stats[j], &volSync,
1675                                         userp, 0);
1676                         }
1677                         lock_ReleaseMutex(&scp->mx);
1678                         cm_ReleaseSCache(scp);
1679                 } /* all files in the response */
1680                 /* now tell it to drop the count,
1681                  * after doing the vnode processing above */
1682                 cm_EndCallbackGrantingCall(NULL, NULL, NULL, 0);
1683
1684                 filex += filesThisCall;
1685         }       /* while there are still more files to process */
1686         osi_Log0(afsd_logp, "END cm_TryBulkStat");
1687 }
1688
1689 void cm_StatusFromAttr(AFSStoreStatus *statusp, cm_scache_t *scp, cm_attr_t *attrp)
1690 {
1691         long mask;
1692
1693         /* initialize store back mask as inexpensive local variable */
1694         mask = 0;
1695         memset(statusp, 0, sizeof(AFSStoreStatus));
1696
1697         /* copy out queued info from scache first, if scp passed in */
1698         if (scp) {
1699                 if (scp->mask & CM_SCACHEMASK_CLIENTMODTIME) {
1700                         statusp->ClientModTime = scp->clientModTime;
1701                         mask |= AFS_SETMODTIME;
1702                         scp->mask &= ~CM_SCACHEMASK_CLIENTMODTIME;
1703                 }
1704         }
1705
1706         if (attrp) {
1707                 /* now add in our locally generated request */
1708                 if (attrp->mask & CM_ATTRMASK_CLIENTMODTIME) {
1709                         statusp->ClientModTime = attrp->clientModTime;
1710                         mask |= AFS_SETMODTIME;
1711                 }
1712                 if (attrp->mask & CM_ATTRMASK_UNIXMODEBITS) {
1713                         statusp->UnixModeBits = attrp->unixModeBits;
1714                         mask |= AFS_SETMODE;
1715                 }
1716                 if (attrp->mask & CM_ATTRMASK_OWNER) {
1717                         statusp->Owner = attrp->owner;
1718                         mask |= AFS_SETOWNER;
1719                 }
1720                 if (attrp->mask & CM_ATTRMASK_GROUP) {
1721                         statusp->Group = attrp->group;
1722                         mask |= AFS_SETGROUP;
1723                 }
1724         }
1725         statusp->Mask = mask;
1726 }
1727
1728 /* set the file size, and make sure that all relevant buffers have been
1729  * truncated.  Ensure that any partially truncated buffers have been zeroed
1730  * to the end of the buffer.
1731  */
1732 long cm_SetLength(cm_scache_t *scp, osi_hyper_t *sizep, cm_user_t *userp,
1733         cm_req_t *reqp)
1734 {
1735         long code;
1736         int shrinking;
1737
1738         /* start by locking out buffer creation */
1739         lock_ObtainWrite(&scp->bufCreateLock);
1740
1741         /* verify that this is a file, not a dir or a symlink */
1742         lock_ObtainMutex(&scp->mx);
1743         code = cm_SyncOp(scp, NULL, userp, reqp, 0,
1744                 CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
1745         if (code) goto done;
1746
1747         if (scp->fileType != CM_SCACHETYPE_FILE) {
1748                 code = CM_ERROR_ISDIR;
1749                 goto done;
1750         }
1751
1752 startover:
1753         if (LargeIntegerLessThan(*sizep, scp->length))
1754                 shrinking = 1;
1755         else
1756                 shrinking = 0;
1757
1758         lock_ReleaseMutex(&scp->mx);
1759
1760         /* can't hold scp->mx lock here, since we may wait for a storeback to
1761          * finish if the buffer package is cleaning a buffer by storing it to
1762          * the server.
1763          */
1764         if (shrinking)
1765                 buf_Truncate(scp, userp, reqp, sizep);
1766
1767         /* now ensure that file length is short enough, and update truncPos */
1768         lock_ObtainMutex(&scp->mx);
1769
1770         /* make sure we have a callback (so we have the right value for the
1771          * length), and wait for it to be safe to do a truncate.
1772          */
1773         code = cm_SyncOp(scp, NULL, userp, reqp, PRSFS_WRITE,
1774                 CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS
1775                 | CM_SCACHESYNC_SETSTATUS | CM_SCACHESYNC_SETSIZE);
1776         if (code) goto done;
1777
1778         if (LargeIntegerLessThan(*sizep, scp->length)) {
1779                 /* a real truncation.  If truncPos is not set yet, or is bigger
1780                  * than where we're truncating the file, set truncPos to this
1781                  * new value.
1782                  */
1783                 if (!shrinking)
1784                         goto startover;
1785                 if (!(scp->mask & CM_SCACHEMASK_TRUNCPOS)
1786                         || LargeIntegerLessThan(*sizep, scp->length)) {
1787                         /* set trunc pos */
1788                         scp->truncPos = *sizep;
1789                         scp->mask |= CM_SCACHEMASK_TRUNCPOS;
1790                 }
1791                 /* in either case, the new file size has been changed */
1792                 scp->length = *sizep;
1793                 scp->mask |= CM_SCACHEMASK_LENGTH;
1794         }
1795         else if (LargeIntegerGreaterThan(*sizep, scp->length)) {
1796                 /* really extending the file */
1797                 scp->length = *sizep;
1798                 scp->mask |= CM_SCACHEMASK_LENGTH;
1799         }
1800
1801         /* done successfully */
1802         code = 0;
1803
1804 done:
1805         lock_ReleaseMutex(&scp->mx);
1806         lock_ReleaseWrite(&scp->bufCreateLock);
1807
1808         return code;
1809 }
1810
1811 /* set the file size or other attributes (but not both at once) */
1812 long cm_SetAttr(cm_scache_t *scp, cm_attr_t *attrp, cm_user_t *userp,
1813         cm_req_t *reqp)
1814 {
1815         long code;
1816         int flags;
1817         AFSFetchStatus afsOutStatus;
1818         AFSVolSync volSync;
1819         cm_conn_t *connp;
1820         AFSFid tfid;
1821         AFSStoreStatus afsInStatus;
1822
1823         /* handle file length setting */
1824         if (attrp->mask & CM_ATTRMASK_LENGTH)
1825                 return cm_SetLength(scp, &attrp->length, userp, reqp);
1826
1827         flags = CM_SCACHESYNC_STORESTATUS;
1828
1829         lock_ObtainMutex(&scp->mx);
1830         /* otherwise, we have to make an RPC to get the status */
1831         code = cm_SyncOp(scp, NULL, userp, reqp, 0, CM_SCACHESYNC_STORESTATUS);
1832
1833         /* make the attr structure */
1834         cm_StatusFromAttr(&afsInStatus, scp, attrp);
1835
1836         lock_ReleaseMutex(&scp->mx);
1837         if (code) return code;
1838
1839         /* now make the RPC */
1840         osi_Log1(afsd_logp, "CALL StoreStatus vp %x", (long) scp);
1841         tfid.Volume = scp->fid.volume;
1842         tfid.Vnode = scp->fid.vnode;
1843         tfid.Unique = scp->fid.unique;
1844         do {
1845                 code = cm_Conn(&scp->fid, userp, reqp, &connp);
1846                 if (code) continue;
1847
1848                 code = RXAFS_StoreStatus(connp->callp, &tfid,
1849                         &afsInStatus, &afsOutStatus, &volSync);
1850
1851         } while (cm_Analyze(connp, userp, reqp,
1852                             &scp->fid, &volSync, NULL, NULL, code));
1853         code = cm_MapRPCError(code, reqp);
1854
1855         osi_Log1(afsd_logp, "CALL StoreStatus DONE, code %d", code);
1856
1857         lock_ObtainMutex(&scp->mx);
1858         cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_STORESTATUS);
1859         if (code == 0)
1860                 cm_MergeStatus(scp, &afsOutStatus, &volSync, userp,
1861                                 CM_MERGEFLAG_FORCE);
1862
1863         /* if we're changing the mode bits, discard the ACL cache,
1864          * since we changed the mode bits.
1865          */
1866         if (afsInStatus.Mask & AFS_SETMODE) cm_FreeAllACLEnts(scp);
1867         lock_ReleaseMutex(&scp->mx);
1868         return code;
1869 }
1870
1871 long cm_Create(cm_scache_t *dscp, char *namep, long flags, cm_attr_t *attrp,
1872         cm_scache_t **scpp, cm_user_t *userp, cm_req_t *reqp)
1873 {
1874         cm_conn_t *connp;
1875         long code;
1876         AFSFid dirAFSFid;
1877         cm_callbackRequest_t cbReq;
1878         AFSFid newAFSFid;
1879         cm_fid_t newFid;
1880         cm_scache_t *scp;
1881         int didEnd;
1882         AFSStoreStatus inStatus;
1883         AFSFetchStatus updatedDirStatus;
1884         AFSFetchStatus newFileStatus;
1885         AFSCallBack newFileCallback;
1886         AFSVolSync volSync;
1887
1888         /* can't create names with @sys in them; must expand it manually first.
1889          * return "invalid request" if they try.
1890          */
1891         if (cm_ExpandSysName(namep, NULL, 0)) {
1892                 return CM_ERROR_ATSYS;
1893         }
1894
1895         /* before starting the RPC, mark that we're changing the file data, so
1896          * that someone who does a chmod will know to wait until our call
1897          * completes.
1898          */
1899         lock_ObtainMutex(&dscp->mx);
1900         code = cm_SyncOp(dscp, NULL, userp, reqp, 0, CM_SCACHESYNC_STOREDATA);
1901         if (code == 0) {
1902                 cm_StartCallbackGrantingCall(NULL, &cbReq);
1903         }
1904         lock_ReleaseMutex(&dscp->mx);
1905         if (code) {
1906                 return code;
1907         }
1908         didEnd = 0;
1909
1910         cm_StatusFromAttr(&inStatus, NULL, attrp);
1911
1912         /* try the RPC now */
1913         do {
1914                 code = cm_Conn(&dscp->fid, userp, reqp, &connp);
1915                 if (code) continue;
1916
1917                 dirAFSFid.Volume = dscp->fid.volume;
1918                 dirAFSFid.Vnode = dscp->fid.vnode;
1919                 dirAFSFid.Unique = dscp->fid.unique;
1920                 code = RXAFS_CreateFile(connp->callp, &dirAFSFid, namep,
1921                                         &inStatus, &newAFSFid, &newFileStatus,
1922                                         &updatedDirStatus, &newFileCallback,
1923                                         &volSync);
1924         } while (cm_Analyze(connp, userp, reqp,
1925                             &dscp->fid, &volSync, NULL, &cbReq, code));
1926         code = cm_MapRPCError(code, reqp);
1927
1928         lock_ObtainMutex(&dscp->mx);
1929         cm_SyncOpDone(dscp, NULL, CM_SCACHESYNC_STOREDATA);
1930         if (code == 0) {
1931                 cm_MergeStatus(dscp, &updatedDirStatus, &volSync, userp, 0);
1932         }
1933         lock_ReleaseMutex(&dscp->mx);
1934
1935         /* now try to create the file's entry, too, but be careful to
1936          * make sure that we don't merge in old info.  Since we weren't locking
1937          * out any requests during the file's creation, we may have pretty old
1938          * info.
1939          */
1940         if (code == 0) {
1941                 newFid.cell = dscp->fid.cell;
1942                 newFid.volume = dscp->fid.volume;
1943                 newFid.vnode = newAFSFid.Vnode;
1944                 newFid.unique = newAFSFid.Unique;
1945                 code = cm_GetSCache(&newFid, &scp, userp, reqp);
1946                 if (code == 0) {
1947                         lock_ObtainMutex(&scp->mx);
1948                         if (!cm_HaveCallback(scp)) {
1949                                 cm_MergeStatus(scp, &newFileStatus, &volSync,
1950                                                 userp, 0);
1951                                 cm_EndCallbackGrantingCall(scp, &cbReq,
1952                                                         &newFileCallback, 0);
1953                                 didEnd = 1;
1954                         }
1955                         lock_ReleaseMutex(&scp->mx);
1956                         *scpp = scp;
1957                 }
1958         }
1959
1960         /* make sure we end things properly */
1961         if (!didEnd)
1962                 cm_EndCallbackGrantingCall(NULL, NULL, NULL, 0);
1963
1964         return code;
1965 }
1966
1967 long cm_FSync(cm_scache_t *scp, cm_user_t *userp, cm_req_t *reqp)
1968 {
1969         long code;
1970
1971         lock_ObtainWrite(&scp->bufCreateLock);
1972         code = buf_CleanVnode(scp, userp, reqp);
1973         lock_ReleaseWrite(&scp->bufCreateLock);
1974         if (code == 0) {
1975                 lock_ObtainMutex(&scp->mx);
1976                 scp->flags &= ~(CM_SCACHEFLAG_OVERQUOTA
1977                                  | CM_SCACHEFLAG_OUTOFSPACE);
1978                 if (scp->mask & (CM_SCACHEMASK_TRUNCPOS
1979                                    | CM_SCACHEMASK_CLIENTMODTIME
1980                                    | CM_SCACHEMASK_LENGTH))
1981                         code = cm_StoreMini(scp, userp, reqp);
1982                 lock_ReleaseMutex(&scp->mx);
1983         }
1984         return code;
1985 }
1986
1987 long cm_MakeDir(cm_scache_t *dscp, char *namep, long flags, cm_attr_t *attrp,
1988         cm_user_t *userp, cm_req_t *reqp)
1989 {
1990         cm_conn_t *connp;
1991         long code;
1992         AFSFid dirAFSFid;
1993         cm_callbackRequest_t cbReq;
1994         AFSFid newAFSFid;
1995         cm_fid_t newFid;
1996         cm_scache_t *scp;
1997         int didEnd;
1998         AFSStoreStatus inStatus;
1999         AFSFetchStatus updatedDirStatus;
2000         AFSFetchStatus newDirStatus;
2001         AFSCallBack newDirCallback;
2002         AFSVolSync volSync;
2003
2004         /* can't create names with @sys in them; must expand it manually first.
2005          * return "invalid request" if they try.
2006          */
2007         if (cm_ExpandSysName(namep, NULL, 0)) {
2008                 return CM_ERROR_ATSYS;
2009         }
2010
2011         /* before starting the RPC, mark that we're changing the directory
2012          * data, so that someone who does a chmod on the dir will wait until
2013          * our call completes.
2014          */
2015         lock_ObtainMutex(&dscp->mx);
2016         code = cm_SyncOp(dscp, NULL, userp, reqp, 0, CM_SCACHESYNC_STOREDATA);
2017         if (code == 0) {
2018                 cm_StartCallbackGrantingCall(NULL, &cbReq);
2019         }
2020         lock_ReleaseMutex(&dscp->mx);
2021         if (code) {
2022                 return code;
2023         }
2024         didEnd = 0;
2025
2026         cm_StatusFromAttr(&inStatus, NULL, attrp);
2027
2028         /* try the RPC now */
2029         do {
2030                 code = cm_Conn(&dscp->fid, userp, reqp, &connp);
2031                 if (code) continue;
2032
2033                 dirAFSFid.Volume = dscp->fid.volume;
2034                 dirAFSFid.Vnode = dscp->fid.vnode;
2035                 dirAFSFid.Unique = dscp->fid.unique;
2036                 code = RXAFS_MakeDir(connp->callp, &dirAFSFid, namep,
2037                                      &inStatus, &newAFSFid, &newDirStatus,
2038                                      &updatedDirStatus, &newDirCallback,
2039                                      &volSync);
2040         } while (cm_Analyze(connp, userp, reqp,
2041                             &dscp->fid, &volSync, NULL, &cbReq, code));
2042         code = cm_MapRPCError(code, reqp);
2043
2044         lock_ObtainMutex(&dscp->mx);
2045         cm_SyncOpDone(dscp, NULL, CM_SCACHESYNC_STOREDATA);
2046         if (code == 0) {
2047                 cm_MergeStatus(dscp, &updatedDirStatus, &volSync, userp, 0);
2048         }
2049         lock_ReleaseMutex(&dscp->mx);
2050
2051         /* now try to create the new dir's entry, too, but be careful to
2052          * make sure that we don't merge in old info.  Since we weren't locking
2053          * out any requests during the file's creation, we may have pretty old
2054          * info.
2055          */
2056         if (code == 0) {
2057                 newFid.cell = dscp->fid.cell;
2058                 newFid.volume = dscp->fid.volume;
2059                 newFid.vnode = newAFSFid.Vnode;
2060                 newFid.unique = newAFSFid.Unique;
2061                 code = cm_GetSCache(&newFid, &scp, userp, reqp);
2062                 if (code == 0) {
2063                         lock_ObtainMutex(&scp->mx);
2064                         if (!cm_HaveCallback(scp)) {
2065                                 cm_MergeStatus(scp, &newDirStatus, &volSync,
2066                                                 userp, 0);
2067                                 cm_EndCallbackGrantingCall(scp, &cbReq,
2068                                                         &newDirCallback, 0);
2069                                 didEnd = 1;
2070                         }
2071                         lock_ReleaseMutex(&scp->mx);
2072                         cm_ReleaseSCache(scp);
2073                 }
2074         }
2075
2076         /* make sure we end things properly */
2077         if (!didEnd)
2078                 cm_EndCallbackGrantingCall(NULL, NULL, NULL, 0);
2079
2080         /* and return error code */
2081         return code;
2082 }
2083
2084 long cm_SymLink(cm_scache_t *dscp, char *namep, char *contentsp, long flags,
2085         cm_attr_t *attrp, cm_user_t *userp, cm_req_t *reqp)
2086 {
2087         cm_conn_t *connp;
2088         long code;
2089         AFSFid dirAFSFid;
2090         AFSFid newAFSFid;
2091         cm_fid_t newFid;
2092         cm_scache_t *scp;
2093         AFSStoreStatus inStatus;
2094         AFSFetchStatus updatedDirStatus;
2095         AFSFetchStatus newLinkStatus;
2096         AFSVolSync volSync;
2097
2098         /* before starting the RPC, mark that we're changing the directory data,
2099          * so that someone who does a chmod on the dir will wait until our
2100          * call completes.
2101          */
2102         lock_ObtainMutex(&dscp->mx);
2103         code = cm_SyncOp(dscp, NULL, userp, reqp, 0, CM_SCACHESYNC_STOREDATA);
2104         lock_ReleaseMutex(&dscp->mx);
2105         if (code) {
2106                 return code;
2107         }
2108
2109         cm_StatusFromAttr(&inStatus, NULL, attrp);
2110
2111         /* try the RPC now */
2112         do {
2113                 code = cm_Conn(&dscp->fid, userp, reqp, &connp);
2114                 if (code) continue;
2115
2116                 dirAFSFid.Volume = dscp->fid.volume;
2117                 dirAFSFid.Vnode = dscp->fid.vnode;
2118                 dirAFSFid.Unique = dscp->fid.unique;
2119                 code = RXAFS_Symlink(connp->callp, &dirAFSFid, namep, contentsp,
2120                                      &inStatus, &newAFSFid, &newLinkStatus,
2121                                      &updatedDirStatus, &volSync);
2122         } while (cm_Analyze(connp, userp, reqp,
2123                             &dscp->fid, &volSync, NULL, NULL, code));
2124         code = cm_MapRPCError(code, reqp);
2125
2126         lock_ObtainMutex(&dscp->mx);
2127         cm_SyncOpDone(dscp, NULL, CM_SCACHESYNC_STOREDATA);
2128         if (code == 0) {
2129                 cm_MergeStatus(dscp, &updatedDirStatus, &volSync, userp, 0);
2130         }
2131         lock_ReleaseMutex(&dscp->mx);
2132
2133         /* now try to create the new dir's entry, too, but be careful to
2134          * make sure that we don't merge in old info.  Since we weren't locking
2135          * out any requests during the file's creation, we may have pretty old
2136          * info.
2137          */
2138         if (code == 0) {
2139                 newFid.cell = dscp->fid.cell;
2140                 newFid.volume = dscp->fid.volume;
2141                 newFid.vnode = newAFSFid.Vnode;
2142                 newFid.unique = newAFSFid.Unique;
2143                 code = cm_GetSCache(&newFid, &scp, userp, reqp);
2144                 if (code == 0) {
2145                         lock_ObtainMutex(&scp->mx);
2146                         if (!cm_HaveCallback(scp)) {
2147                                 cm_MergeStatus(scp, &newLinkStatus, &volSync,
2148                                                 userp, 0);
2149                         }
2150                         lock_ReleaseMutex(&scp->mx);
2151                         cm_ReleaseSCache(scp);
2152                 }
2153         }
2154
2155         /* and return error code */
2156         return code;
2157 }
2158
2159 long cm_RemoveDir(cm_scache_t *dscp, char *namep, cm_user_t *userp,
2160         cm_req_t *reqp)
2161 {
2162         cm_conn_t *connp;
2163         long code;
2164         AFSFid dirAFSFid;
2165         int didEnd;
2166         AFSFetchStatus updatedDirStatus;
2167         AFSVolSync volSync;
2168
2169         /* before starting the RPC, mark that we're changing the directory data,
2170          * so that someone who does a chmod on the dir will wait until our
2171          * call completes.
2172          */
2173         lock_ObtainMutex(&dscp->mx);
2174         code = cm_SyncOp(dscp, NULL, userp, reqp, 0, CM_SCACHESYNC_STOREDATA);
2175         lock_ReleaseMutex(&dscp->mx);
2176         if (code) {
2177                 return code;
2178         }
2179         didEnd = 0;
2180
2181         /* try the RPC now */
2182         do {
2183                 code = cm_Conn(&dscp->fid, userp, reqp, &connp);
2184                 if (code) continue;
2185
2186                 dirAFSFid.Volume = dscp->fid.volume;
2187                 dirAFSFid.Vnode = dscp->fid.vnode;
2188                 dirAFSFid.Unique = dscp->fid.unique;
2189                 code = RXAFS_RemoveDir(connp->callp, &dirAFSFid, namep,
2190                                         &updatedDirStatus, &volSync);
2191         } while (cm_Analyze(connp, userp, reqp,
2192                             &dscp->fid, &volSync, NULL, NULL, code));
2193         code = cm_MapRPCErrorRmdir(code, reqp);
2194
2195         lock_ObtainMutex(&dscp->mx);
2196         cm_dnlcRemove(dscp, namep);
2197         cm_SyncOpDone(dscp, NULL, CM_SCACHESYNC_STOREDATA);
2198         if (code == 0) {
2199                 cm_MergeStatus(dscp, &updatedDirStatus, &volSync, userp, 0);
2200         }
2201         lock_ReleaseMutex(&dscp->mx);
2202
2203         /* and return error code */
2204         return code;
2205 }
2206
2207 long cm_Open(cm_scache_t *scp, int type, cm_user_t *userp)
2208 {
2209         /* grab mutex on contents */
2210         lock_ObtainMutex(&scp->mx);
2211
2212         /* reset the prefetch info */
2213         scp->prefetch.base.LowPart = 0;         /* base */
2214         scp->prefetch.base.HighPart = 0;
2215         scp->prefetch.end.LowPart = 0;          /* and end */
2216         scp->prefetch.end.HighPart = 0;
2217
2218         /* release mutex on contents */
2219         lock_ReleaseMutex(&scp->mx);
2220
2221         /* we're done */
2222         return 0;
2223 }
2224
2225 long cm_Rename(cm_scache_t *oldDscp, char *oldNamep, cm_scache_t *newDscp,
2226         char *newNamep, cm_user_t *userp, cm_req_t *reqp)
2227 {
2228         cm_conn_t *connp;
2229         long code;
2230         AFSFid oldDirAFSFid;
2231         AFSFid newDirAFSFid;
2232         int didEnd;
2233         AFSFetchStatus updatedOldDirStatus;
2234         AFSFetchStatus updatedNewDirStatus;
2235         AFSVolSync volSync;
2236         int oneDir;
2237
2238         /* before starting the RPC, mark that we're changing the directory data,
2239          * so that someone who does a chmod on the dir will wait until our call
2240          * completes.  We do this in vnode order so that we don't deadlock,
2241          * which makes the code a little verbose.
2242          */
2243         if (oldDscp == newDscp) {
2244                 /* check for identical names */
2245                 if (strcmp(oldNamep, newNamep) == 0)
2246                         return CM_ERROR_RENAME_IDENTICAL;
2247
2248                 oneDir = 1;
2249                 lock_ObtainMutex(&oldDscp->mx);
2250                 cm_dnlcRemove(oldDscp, oldNamep);
2251                 cm_dnlcRemove(oldDscp, newNamep);
2252                 code = cm_SyncOp(oldDscp, NULL, userp, reqp, 0,
2253                                  CM_SCACHESYNC_STOREDATA);
2254                 lock_ReleaseMutex(&oldDscp->mx);
2255         }
2256         else {
2257                 /* two distinct dir vnodes */
2258                 oneDir = 0;
2259                 if (oldDscp->fid.cell != newDscp->fid.cell ||
2260                         oldDscp->fid.volume != newDscp->fid.volume)
2261                                 return CM_ERROR_CROSSDEVLINK;
2262
2263                 /* shouldn't happen that we have distinct vnodes for two
2264                  * different files, but could due to deliberate attack, or
2265                  * stale info.  Avoid deadlocks and quit now.
2266                  */
2267                 if (oldDscp->fid.vnode == newDscp->fid.vnode)
2268                         return CM_ERROR_CROSSDEVLINK;
2269
2270                 if (oldDscp->fid.vnode < newDscp->fid.vnode) {
2271                         lock_ObtainMutex(&oldDscp->mx);
2272                         cm_dnlcRemove(oldDscp, oldNamep);
2273                         code = cm_SyncOp(oldDscp, NULL, userp, reqp, 0,
2274                                          CM_SCACHESYNC_STOREDATA);
2275                         lock_ReleaseMutex(&oldDscp->mx);
2276                         if (code == 0) {
2277                                 lock_ObtainMutex(&newDscp->mx);
2278                                 cm_dnlcRemove(newDscp, newNamep);
2279                                 code = cm_SyncOp(newDscp, NULL, userp, reqp, 0,
2280                                                  CM_SCACHESYNC_STOREDATA);
2281                                 lock_ReleaseMutex(&newDscp->mx);
2282                                 if (code) {
2283                                         /* cleanup first one */
2284                                         cm_SyncOpDone(oldDscp, NULL,
2285                                                       CM_SCACHESYNC_STOREDATA);
2286                                 }
2287                         }
2288                 }
2289                 else {
2290                         /* lock the new vnode entry first */
2291                         lock_ObtainMutex(&newDscp->mx);
2292                         cm_dnlcRemove(newDscp, newNamep);
2293                         code = cm_SyncOp(newDscp, NULL, userp, reqp, 0,
2294                                          CM_SCACHESYNC_STOREDATA);
2295                         lock_ReleaseMutex(&newDscp->mx);
2296                         if (code == 0) {
2297                                 lock_ObtainMutex(&oldDscp->mx);
2298                                 cm_dnlcRemove(oldDscp, oldNamep);
2299                                 code = cm_SyncOp(oldDscp, NULL, userp, reqp, 0,
2300                                                  CM_SCACHESYNC_STOREDATA);
2301                                 lock_ReleaseMutex(&oldDscp->mx);
2302                                 if (code) {
2303                                         /* cleanup first one */
2304                                         cm_SyncOpDone(newDscp, NULL,
2305                                                       CM_SCACHESYNC_STOREDATA);
2306                                 }
2307                         }
2308                 }
2309         }       /* two distinct vnodes */
2310
2311         if (code) {
2312                 return code;
2313         }
2314         didEnd = 0;
2315
2316         /* try the RPC now */
2317         do {
2318                 code = cm_Conn(&oldDscp->fid, userp, reqp, &connp);
2319                 if (code) continue;
2320
2321                 oldDirAFSFid.Volume = oldDscp->fid.volume;
2322                 oldDirAFSFid.Vnode = oldDscp->fid.vnode;
2323                 oldDirAFSFid.Unique = oldDscp->fid.unique;
2324                 newDirAFSFid.Volume = newDscp->fid.volume;
2325                 newDirAFSFid.Vnode = newDscp->fid.vnode;
2326                 newDirAFSFid.Unique = newDscp->fid.unique;
2327                 code = RXAFS_Rename(connp->callp, &oldDirAFSFid, oldNamep,
2328                         &newDirAFSFid, newNamep,
2329                         &updatedOldDirStatus, &updatedNewDirStatus,
2330                         &volSync);
2331         } while (cm_Analyze(connp, userp, reqp, &oldDscp->fid,
2332                             &volSync, NULL, NULL, code));
2333         code = cm_MapRPCError(code, reqp);
2334
2335         /* update the individual stat cache entries for the directories */
2336         lock_ObtainMutex(&oldDscp->mx);
2337         cm_SyncOpDone(oldDscp, NULL, CM_SCACHESYNC_STOREDATA);
2338         if (code == 0) {
2339                 cm_MergeStatus(oldDscp, &updatedOldDirStatus, &volSync,
2340                                 userp, 0);
2341         }
2342         lock_ReleaseMutex(&oldDscp->mx);
2343
2344         /* and update it for the new one, too, if necessary */
2345         if (!oneDir) {
2346                 lock_ObtainMutex(&newDscp->mx);
2347                 cm_SyncOpDone(newDscp, NULL, CM_SCACHESYNC_STOREDATA);
2348                 if (code == 0) {
2349                         cm_MergeStatus(newDscp, &updatedNewDirStatus, &volSync,
2350                                         userp, 0);
2351                 }
2352                 lock_ReleaseMutex(&newDscp->mx);
2353         }
2354
2355         /* and return error code */
2356         return code;
2357 }
2358
2359 long cm_Lock(cm_scache_t *scp, unsigned char LockType,
2360         LARGE_INTEGER LOffset, LARGE_INTEGER LLength,
2361         u_long Timeout, cm_user_t *userp, cm_req_t *reqp,
2362         void **lockpp)
2363 {
2364         long code;
2365         int Which = ((LockType & 0x1) ? LockRead : LockWrite);
2366         AFSFid tfid;
2367         AFSVolSync volSync;
2368         cm_conn_t *connp;
2369         cm_file_lock_t *fileLock;
2370         osi_queue_t *q;
2371         int found = 0;
2372
2373         /* Look for a conflict.  Also, if we are asking for a shared lock,
2374          * look for another shared lock, so we don't have to do an RPC.
2375          */
2376         q = scp->fileLocks;
2377         while (q) {
2378                 fileLock = (cm_file_lock_t *)
2379                                 ((char *) q - offsetof(cm_file_lock_t, fileq));
2380                 if ((fileLock->flags &
2381                         (CM_FILELOCK_FLAG_INVALID | CM_FILELOCK_FLAG_WAITING))
2382                     == 0) {
2383                         if ((LockType & 0x1) == 0
2384                             || (fileLock->LockType & 0x1) == 0)
2385                                 return CM_ERROR_WOULDBLOCK;
2386                         found = 1;
2387                 }
2388                 q = osi_QNext(q);
2389         }
2390
2391         if (found)
2392                 code = 0;
2393         else {
2394                 tfid.Volume = scp->fid.volume;
2395                 tfid.Vnode = scp->fid.vnode;
2396                 tfid.Unique = scp->fid.unique;
2397                 lock_ReleaseMutex(&scp->mx);
2398                 do {
2399                         code = cm_Conn(&scp->fid, userp, reqp, &connp);
2400                         if (code) break;
2401                         code = RXAFS_SetLock(connp->callp, &tfid, Which,
2402                                              &volSync);
2403                 } while (cm_Analyze(connp, userp, reqp, &scp->fid, &volSync,
2404                                     NULL, NULL, code));
2405                 lock_ObtainMutex(&scp->mx);
2406                 code = cm_MapRPCError(code, reqp);
2407         }
2408
2409         if (code == 0 || Timeout != 0) {
2410                 fileLock = malloc(sizeof(cm_file_lock_t));
2411                 fileLock->LockType = LockType;
2412                 cm_HoldUser(userp);
2413                 fileLock->userp = userp;
2414                 fileLock->fid = scp->fid;
2415                 fileLock->LOffset = LOffset;
2416                 fileLock->LLength = LLength;
2417                 fileLock->flags = (code == 0 ? 0 : CM_FILELOCK_FLAG_WAITING);
2418                 osi_QAdd(&scp->fileLocks, &fileLock->fileq);
2419                 lock_ObtainWrite(&cm_scacheLock);
2420                 osi_QAdd(&cm_allFileLocks, &fileLock->q);
2421                 lock_ReleaseWrite(&cm_scacheLock);
2422                 if (code != 0) *lockpp = fileLock;
2423         }
2424         return code;
2425 }
2426
2427 long cm_Unlock(cm_scache_t *scp, unsigned char LockType,
2428         LARGE_INTEGER LOffset, LARGE_INTEGER LLength,
2429         cm_user_t *userp, cm_req_t *reqp)
2430 {
2431         long code = 0;
2432         int Which = ((LockType & 0x1) ? LockRead : LockWrite);
2433         AFSFid tfid;
2434         AFSVolSync volSync;
2435         cm_conn_t *connp;
2436         cm_file_lock_t *fileLock, *ourLock;
2437         osi_queue_t *q, *qq;
2438         int anotherReader = 0;
2439         int smallLock = 0;
2440         int found = 0;
2441
2442         if (LargeIntegerLessThan(LLength, scp->length))
2443                 smallLock = 1;
2444
2445         /* Look for our own lock on the list, so as to remove it.
2446          * Also, determine if we're the last reader; if not, avoid an RPC.
2447          */
2448         q = scp->fileLocks;
2449         while (q) {
2450                 fileLock = (cm_file_lock_t *)
2451             ((char *) q - offsetof(cm_file_lock_t, fileq));
2452                 if (!found
2453                     && fileLock->userp == userp
2454                     && LargeIntegerEqualTo(fileLock->LOffset, LOffset)
2455                     && LargeIntegerEqualTo(fileLock->LLength, LLength)) {
2456                         found = 1;
2457                         ourLock = fileLock;
2458                         qq = q;
2459                 }
2460                 else if (fileLock->LockType & 0x1)
2461                         anotherReader = 1;
2462                 q = osi_QNext(q);
2463         }
2464
2465         /* ignore byte ranges */
2466         if (smallLock && !found)
2467                 return 0;
2468
2469         /* don't try to unlock other people's locks */
2470         if (!found)
2471                 return CM_ERROR_WOULDBLOCK;
2472
2473         /* discard lock record */
2474         osi_QRemove(&scp->fileLocks, qq);
2475         /*
2476          * Don't delete it here; let the daemon delete it, to simplify
2477          * the daemon's traversal of the list.
2478          */
2479         lock_ObtainWrite(&cm_scacheLock);
2480         ourLock->flags |= CM_FILELOCK_FLAG_INVALID;
2481         cm_ReleaseUser(ourLock->userp);
2482         lock_ReleaseWrite(&cm_scacheLock);
2483
2484         if (!anotherReader) {
2485                 tfid.Volume = scp->fid.volume;
2486                 tfid.Vnode = scp->fid.vnode;
2487                 tfid.Unique = scp->fid.unique;
2488                 lock_ReleaseMutex(&scp->mx);
2489                 do {
2490                         code = cm_Conn(&scp->fid, userp, reqp, &connp);
2491                         if (code)
2492                 break;
2493                         code = RXAFS_ReleaseLock(connp->callp, &tfid, &volSync);
2494                 } while (cm_Analyze(connp, userp, reqp, &scp->fid, &volSync,
2495                                     NULL, NULL, code));
2496                 code = cm_MapRPCError(code, reqp);
2497                 lock_ObtainMutex(&scp->mx);
2498         }
2499
2500         return code;
2501 }
2502
2503 void cm_CheckLocks()
2504 {
2505         osi_queue_t *q, *nq;
2506         cm_file_lock_t *fileLock;
2507         cm_req_t req;
2508         AFSFid tfid;
2509         AFSVolSync volSync;
2510         cm_conn_t *connp;
2511         long code;
2512
2513         cm_InitReq(&req);
2514
2515         lock_ObtainWrite(&cm_scacheLock);
2516         q = cm_allFileLocks;
2517         while (q) {
2518                 fileLock = (cm_file_lock_t *) q;
2519                 nq = osi_QNext(q);
2520                 if (fileLock->flags & CM_FILELOCK_FLAG_INVALID) {
2521                         osi_QRemove(&cm_allFileLocks, q);
2522                         free(fileLock);
2523                 }
2524                 else if (!(fileLock->flags & CM_FILELOCK_FLAG_WAITING)) {
2525                         tfid.Volume = fileLock->fid.volume;
2526                         tfid.Vnode = fileLock->fid.vnode;
2527                         tfid.Unique = fileLock->fid.unique;
2528                         lock_ReleaseWrite(&cm_scacheLock);
2529                         do {
2530                                 code = cm_Conn(&fileLock->fid, fileLock->userp,
2531                                                 &req, &connp);
2532                                 if (code) break;
2533                                 code = RXAFS_ExtendLock(connp->callp, &tfid,
2534                                                         &volSync);
2535                         } while (cm_Analyze(connp, fileLock->userp, &req,
2536                                             &fileLock->fid, &volSync, NULL, NULL,
2537                                             code));
2538                         code = cm_MapRPCError(code, &req);
2539                         lock_ObtainWrite(&cm_scacheLock);
2540                 }
2541                 q = nq;
2542         }
2543         lock_ReleaseWrite(&cm_scacheLock);
2544 }
2545
2546 long cm_RetryLock(cm_file_lock_t *oldFileLock, int vcp_is_dead)
2547 {
2548         long code;
2549         int Which = ((oldFileLock->LockType & 0x1) ? LockRead : LockWrite);
2550         cm_scache_t *scp;
2551         AFSFid tfid;
2552         AFSVolSync volSync;
2553         cm_conn_t *connp;
2554         cm_file_lock_t *fileLock;
2555         osi_queue_t *q;
2556         cm_req_t req;
2557         int found = 0;
2558
2559         if (vcp_is_dead) {
2560                 code = CM_ERROR_TIMEDOUT;
2561                 goto handleCode;
2562         }
2563
2564         cm_InitReq(&req);
2565
2566         /* Look for a conflict.  Also, if we are asking for a shared lock,
2567          * look for another shared lock, so we don't have to do an RPC.
2568          */
2569         code = cm_GetSCache(&oldFileLock->fid, &scp, oldFileLock->userp, &req);
2570         if (code)
2571                 return code;
2572
2573         q = scp->fileLocks;
2574         while (q) {
2575                 fileLock = (cm_file_lock_t *)
2576                                 ((char *) q - offsetof(cm_file_lock_t, fileq));
2577                 if ((fileLock->flags &
2578                         (CM_FILELOCK_FLAG_INVALID | CM_FILELOCK_FLAG_WAITING))
2579                     == 0) {
2580                         if ((oldFileLock->LockType & 0x1) == 0
2581                             || (fileLock->LockType & 0x1) == 0) {
2582                                 cm_ReleaseSCache(scp);
2583                                 return CM_ERROR_WOULDBLOCK;
2584                         }
2585                         found = 1;
2586                 }
2587                 q = osi_QNext(q);
2588         }
2589
2590         if (found)
2591                 code = 0;
2592         else {
2593                 tfid.Volume = oldFileLock->fid.volume;
2594                 tfid.Vnode = oldFileLock->fid.vnode;
2595                 tfid.Unique = oldFileLock->fid.unique;
2596                 do {
2597                         code = cm_Conn(&oldFileLock->fid, oldFileLock->userp,
2598                                        &req, &connp);
2599                         if (code) break;
2600                         code = RXAFS_SetLock(connp->callp, &tfid, Which,
2601                                              &volSync);
2602                 } while (cm_Analyze(connp, oldFileLock->userp, &req,
2603                                     &oldFileLock->fid, &volSync,
2604                                     NULL, NULL, code));
2605                 code = cm_MapRPCError(code, &req);
2606         }
2607
2608   handleCode:
2609         if (code != 0 && code != CM_ERROR_WOULDBLOCK) {
2610                 lock_ObtainMutex(&scp->mx);
2611                 osi_QRemove(&scp->fileLocks, &oldFileLock->fileq);
2612                 lock_ReleaseMutex(&scp->mx);
2613         }
2614         lock_ObtainWrite(&cm_scacheLock);
2615         if (code == 0)
2616                 oldFileLock->flags = 0;
2617         else if (code != CM_ERROR_WOULDBLOCK) {
2618                 oldFileLock->flags |= CM_FILELOCK_FLAG_INVALID;
2619                 cm_ReleaseUser(oldFileLock->userp);
2620         oldFileLock->userp = NULL;
2621         }
2622         lock_ReleaseWrite(&cm_scacheLock);
2623
2624         return code;
2625 }