src/WINNT/afsrdr/kernel/lib/AFSLockControl.cpp

   1 /*
   2  * Copyright (c) 2008, 2009, 2010, 2011 Kernel Drivers, LLC.
   3  * Copyright (c) 2009, 2010, 2011 Your File System, Inc.
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  *
  10  * - Redistributions of source code must retain the above copyright notice,
  11  *   this list of conditions and the following disclaimer.
  12  * - Redistributions in binary form must reproduce the above copyright
  13  *   notice,
  14  *   this list of conditions and the following disclaimer in the
  15  *   documentation
  16  *   and/or other materials provided with the distribution.
  17  * - Neither the names of Kernel Drivers, LLC and Your File System, Inc.
  18  *   nor the names of their contributors may be used to endorse or promote
  19  *   products derived from this software without specific prior written
  20  *   permission from Kernel Drivers, LLC and Your File System, Inc.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  23  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  24  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
  25  * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
  26  * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  27  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  28  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  29  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  30  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  31  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  32  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  33  */
  34
  35 //
  36 // File: AFSLockControl.cpp
  37 //
  38
  39 #include "AFSCommon.h"
  40
  41 NTSTATUS
  42 AFSLockControl( IN PDEVICE_OBJECT LibDeviceObject,
  43                   IN PIRP Irp)
  44 {
  45
  46     NTSTATUS ntStatus = STATUS_SUCCESS;
  47     ULONG ulRequestType = 0;
  48     IO_STACK_LOCATION *pIrpSp = IoGetCurrentIrpStackLocation( Irp);
  49     AFSFcb *pFcb = NULL;
  50     AFSCcb *pCcb = NULL;
  51     BOOLEAN bCompleteRequest = TRUE;
  52     AFSByteRangeLockRequestCB  stLockRequestCB;
  53     AFSByteRangeLockResultCB  stLockResultCB;
  54     AFSByteRangeUnlockRequestCB stUnlockRequestCB;
  55     AFSByteRangeUnlockResultCB stUnlockResultCB;
  56     ULONG           ulResultLen = 0;
  57     BOOLEAN         bReleaseResource = FALSE;
  58     IO_STATUS_BLOCK stIoStatus;
  59
  60     __try
  61     {
  62
  63         pFcb = (AFSFcb *)pIrpSp->FileObject->FsContext;
  64
  65         pCcb = (AFSCcb *)pIrpSp->FileObject->FsContext2;
  66
  67         if( pFcb == NULL)
  68         {
  69
  70             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
  71                           AFS_TRACE_LEVEL_ERROR,
  72                           "AFSLockControl Attempted access (%08lX) when pFcb == NULL\n",
  73                           Irp);
  74
  75             try_return( ntStatus = STATUS_INVALID_DEVICE_REQUEST);
  76         }
  77
  78         //
  79         // Acquire the main shared for adding the lock control to the list
  80         //
  81
  82         AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
  83                       AFS_TRACE_LEVEL_VERBOSE,
  84                       "AFSLockControl Acquiring Fcb lock %08lX SHARED %08lX\n",
  85                       &pFcb->NPFcb->Resource,
  86                       PsGetCurrentThread());
  87
  88         AFSAcquireShared( &pFcb->NPFcb->Resource,
  89                           TRUE);
  90
  91         bReleaseResource = TRUE;
  92
  93         if( pFcb->Header.NodeTypeCode == AFS_IOCTL_FCB)
  94         {
  95
  96             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
  97                           AFS_TRACE_LEVEL_ERROR,
  98                           "AFSLockControl Failing request against PIOCtl Fcb\n");
  99
 100             try_return( ntStatus = STATUS_INVALID_DEVICE_REQUEST);
 101         }
 102         else if( pFcb->Header.NodeTypeCode == AFS_SPECIAL_SHARE_FCB)
 103         {
 104
 105             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 106                           AFS_TRACE_LEVEL_ERROR,
 107                           "AFSLockControl Failing request against SpecialShare Fcb\n");
 108
 109             try_return( ntStatus = STATUS_INVALID_DEVICE_REQUEST);
 110         }
 111         else if( pFcb->Header.NodeTypeCode == AFS_INVALID_FCB)
 112         {
 113
 114             AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
 115                           AFS_TRACE_LEVEL_ERROR,
 116                           "AFSLockControl Failing request against Invalid Fcb\n");
 117
 118             try_return( ntStatus = STATUS_INVALID_DEVICE_REQUEST);
 119         }
 120
 121         //
 122         // Post the request to the service for checks
 123         //
 124
 125         switch( pIrpSp->MinorFunction)
 126         {
 127
 128             case IRP_MN_LOCK:
 129             {
 130
 131                 stLockRequestCB.Count = 1;
 132
 133                 stLockRequestCB.ProcessId = (ULONGLONG)PsGetCurrentProcessId();
 134
 135                 stLockRequestCB.Request[ 0].LockType = AFS_BYTE_RANGE_LOCK_TYPE_EXCL;
 136
 137                 stLockRequestCB.Request[ 0].Offset = pIrpSp->Parameters.LockControl.ByteOffset;
 138
 139                 stLockRequestCB.Request[ 0].Length.QuadPart = pIrpSp->Parameters.LockControl.Length->QuadPart;
 140
 141                 ulResultLen = sizeof( AFSByteRangeLockResultCB);
 142
 143                 ntStatus = AFSProcessRequest( AFS_REQUEST_TYPE_BYTE_RANGE_LOCK,
 144                                               AFS_REQUEST_FLAG_SYNCHRONOUS,
 145                                               &pCcb->AuthGroup,
 146                                               &pCcb->DirectoryCB->NameInformation.FileName,
 147                                               &pFcb->ObjectInformation->FileId,
 148                                               &stLockRequestCB,
 149                                               sizeof( AFSByteRangeLockRequestCB),
 150                                               &stLockResultCB,
 151                                               &ulResultLen);
 152
 153                 if( !NT_SUCCESS( ntStatus))
 154                 {
 155
 156                     try_return( ntStatus);
 157                 }
 158
 159                 break;
 160             }
 161
 162             case IRP_MN_UNLOCK_ALL:
 163             case IRP_MN_UNLOCK_ALL_BY_KEY:
 164             {
 165                 //
 166                 // Flush data and then release the locks on the file server
 167                 //
 168
 169                 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
 170                               AFS_TRACE_LEVEL_VERBOSE,
 171                               "AFSLockControl Acquiring Fcb SectionObject lock %08lX SHARED %08lX\n",
 172                               &pFcb->NPFcb->SectionObjectResource,
 173                               PsGetCurrentThread());
 174
 175                 AFSAcquireShared( &pFcb->NPFcb->SectionObjectResource,
 176                                   TRUE);
 177
 178                 CcFlushCache( &pFcb->NPFcb->SectionObjectPointers,
 179                               NULL,
 180                               0,
 181                               &stIoStatus);
 182
 183                 if( !NT_SUCCESS( stIoStatus.Status))
 184                 {
 185
 186                     AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
 187                                   AFS_TRACE_LEVEL_ERROR,
 188                                   "AFSLockControl CcFlushCache [1] failure FID %08lX-%08lX-%08lX-%08lX Status 0x%08lX Bytes 0x%08lX\n",
 189                                   pFcb->ObjectInformation->FileId.Cell,
 190                                   pFcb->ObjectInformation->FileId.Volume,
 191                                   pFcb->ObjectInformation->FileId.Vnode,
 192                                   pFcb->ObjectInformation->FileId.Unique,
 193                                   stIoStatus.Status,
 194                                   stIoStatus.Information);
 195
 196                     ntStatus = stIoStatus.Status;
 197                 }
 198
 199                 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
 200                               AFS_TRACE_LEVEL_VERBOSE,
 201                               "AFSLockControl Releasing Fcb SectionObject lock %08lX SHARED %08lX\n",
 202                               &pFcb->NPFcb->SectionObjectResource,
 203                               PsGetCurrentThread());
 204
 205                 AFSReleaseResource( &pFcb->NPFcb->SectionObjectResource);
 206
 207                 RtlZeroMemory( &stUnlockRequestCB,
 208                                sizeof( AFSByteRangeUnlockRequestCB));
 209
 210                 stUnlockRequestCB.ProcessId = (ULONGLONG)PsGetCurrentProcessId();
 211
 212                 ntStatus = AFSProcessRequest( AFS_REQUEST_TYPE_BYTE_RANGE_UNLOCK_ALL,
 213                                               AFS_REQUEST_FLAG_SYNCHRONOUS,
 214                                               &pCcb->AuthGroup,
 215                                               &pCcb->DirectoryCB->NameInformation.FileName,
 216                                               &pFcb->ObjectInformation->FileId,
 217                                               (void *)&stUnlockRequestCB,
 218                                               sizeof( AFSByteRangeUnlockRequestCB),
 219                                               NULL,
 220                                               NULL);
 221
 222                 //
 223                 // Even on a failure we need to notify the rtl package of the unlock
 224                 //
 225
 226                 break;
 227             }
 228
 229             case IRP_MN_UNLOCK_SINGLE:
 230             {
 231                 //
 232                 // Flush the data and then release the file server locks
 233                 //
 234
 235                 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
 236                               AFS_TRACE_LEVEL_VERBOSE,
 237                               "AFSLockControl Acquiring Fcb SectionObject lock %08lX SHARED %08lX\n",
 238                               &pFcb->NPFcb->SectionObjectResource,
 239                               PsGetCurrentThread());
 240
 241                 AFSAcquireShared( &pFcb->NPFcb->SectionObjectResource,
 242                                   TRUE);
 243                 CcFlushCache( &pFcb->NPFcb->SectionObjectPointers,
 244                               &pIrpSp->Parameters.LockControl.ByteOffset,
 245                               pIrpSp->Parameters.LockControl.Length->LowPart,
 246                               &stIoStatus);
 247
 248                 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
 249                               AFS_TRACE_LEVEL_VERBOSE,
 250                               "AFSLockControl Releasing Fcb SectionObject lock %08lX SHARED %08lX\n",
 251                               &pFcb->NPFcb->SectionObjectResource,
 252                               PsGetCurrentThread());
 253
 254                 AFSReleaseResource( &pFcb->NPFcb->SectionObjectResource);
 255
 256                 if( !NT_SUCCESS( stIoStatus.Status))
 257                 {
 258
 259                     AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
 260                                   AFS_TRACE_LEVEL_ERROR,
 261                                   "AFSLockControl CcFlushCache [2] failure FID %08lX-%08lX-%08lX-%08lX Status 0x%08lX Bytes 0x%08lX\n",
 262                                   pFcb->ObjectInformation->FileId.Cell,
 263                                   pFcb->ObjectInformation->FileId.Volume,
 264                                   pFcb->ObjectInformation->FileId.Vnode,
 265                                   pFcb->ObjectInformation->FileId.Unique,
 266                                   stIoStatus.Status,
 267                                   stIoStatus.Information);
 268
 269                     ntStatus = stIoStatus.Status;
 270                 }
 271
 272                 stUnlockRequestCB.Count = 1;
 273
 274                 stUnlockRequestCB.ProcessId = (ULONGLONG)PsGetCurrentProcessId();
 275
 276                 stUnlockRequestCB.Request[ 0].LockType = AFS_BYTE_RANGE_LOCK_TYPE_EXCL;
 277
 278                 stUnlockRequestCB.Request[ 0].Offset = pIrpSp->Parameters.LockControl.ByteOffset;
 279
 280                 stUnlockRequestCB.Request[ 0].Length.QuadPart = pIrpSp->Parameters.LockControl.Length->QuadPart;
 281
 282                 ulResultLen = sizeof( AFSByteRangeUnlockResultCB);
 283
 284                 ntStatus = AFSProcessRequest( AFS_REQUEST_TYPE_BYTE_RANGE_UNLOCK,
 285                                               AFS_REQUEST_FLAG_SYNCHRONOUS,
 286                                               &pCcb->AuthGroup,
 287                                               &pCcb->DirectoryCB->NameInformation.FileName,
 288                                               &pFcb->ObjectInformation->FileId,
 289                                               (void *)&stUnlockRequestCB,
 290                                               sizeof( AFSByteRangeUnlockRequestCB),
 291                                               (void *)&stUnlockResultCB,
 292                                               &ulResultLen);
 293
 294                 break;
 295             }
 296
 297             default:
 298
 299                 break;
 300         }
 301
 302         //
 303         // Below here we won't complete the request, it is handled by the lock package
 304         //
 305
 306         bCompleteRequest = FALSE;
 307
 308         //
 309         //  Now call the system package for actually processing the lock request
 310         //
 311
 312         ntStatus = FsRtlProcessFileLock( &pFcb->Specific.File.FileLock,
 313                                          Irp,
 314                                          NULL);
 315
 316 try_exit:
 317
 318         if( bReleaseResource)
 319         {
 320
 321             //
 322             // And drop it
 323             //
 324
 325             AFSReleaseResource( &pFcb->NPFcb->Resource);
 326         }
 327
 328         if( bCompleteRequest)
 329         {
 330
 331             AFSCompleteRequest( Irp,
 332                                 ntStatus);
 333         }
 334     }
 335     __except( AFSExceptionFilter( __FUNCTION__, GetExceptionCode(), GetExceptionInformation()))
 336     {
 337
 338         AFSDbgLogMsg( 0,
 339                       0,
 340                       "EXCEPTION - AFSLockControl\n");
 341
 342         AFSDumpTraceFilesFnc();
 343
 344         //
 345         // Again, there is little point in failing this request but pass back some type of failure status
 346         //
 347
 348         ntStatus = STATUS_UNSUCCESSFUL;
 349
 350         AFSCompleteRequest( Irp,
 351                             ntStatus);
 352     }
 353
 354     return ntStatus;
 355 }