ntoskrnl/fs/filelock.c

   1 /* $Id$
   2  *
   3  * reactos/ntoskrnl/fs/filelock.c
   4  *
   5  */
   6 #include <ntos.h>
   7 #include <ddk/ntifs.h>
   8
   9
  10 /**********************************************************************
  11  * NAME                                                 EXPORTED
  12  *      FsRtlCheckLockForReadAccess@8
  13  *
  14  * DESCRIPTION
  15  *
  16  * ARGUMENTS
  17  *
  18  * RETURN VALUE
  19  *
  20  * NOTE (Bo Branten)
  21  *      All this really does is pick out the lock parameters from
  22  *      the irp (io stack location?), get IoGetRequestorProcess,
  23  *      and pass values on to FsRtlFastCheckLockForRead.
  24  *
  25  */
  26 BOOLEAN
  27 STDCALL
  28 FsRtlCheckLockForReadAccess (
  29     IN PFILE_LOCK   FileLock,
  30     IN PIRP         Irp
  31     )
  32 {
  33         return FALSE;
  34 }
  35
  36
  37 /**********************************************************************
  38  * NAME                                                 EXPORTED
  39  *      FsRtlCheckLockForWriteAccess@8
  40  *
  41  * DESCRIPTION
  42  *
  43  * ARGUMENTS
  44  *
  45  * RETURN VALUE
  46  *
  47  * NOTE (Bo Branten)
  48  *      All this really does is pick out the lock parameters from
  49  *      the irp (io stack location?), get IoGetRequestorProcess,
  50  *      and pass values on to FsRtlFastCheckLockForWrite.
  51  */
  52 BOOLEAN
  53 STDCALL
  54 FsRtlCheckLockForWriteAccess (
  55     IN PFILE_LOCK   FileLock,
  56     IN PIRP         Irp
  57     )
  58 {
  59         return FALSE;
  60 }
  61
  62
  63 /**********************************************************************
  64  * NAME                                                 EXPORTED
  65  *      FsRtlFastCheckLockForRead@24
  66  *
  67  * DESCRIPTION
  68  *
  69  * ARGUMENTS
  70  *
  71  * RETURN VALUE
  72  *
  73  */
  74 BOOLEAN
  75 STDCALL
  76 FsRtlFastCheckLockForRead (
  77     IN PFILE_LOCK           FileLock,
  78     IN PLARGE_INTEGER       FileOffset,
  79     IN PLARGE_INTEGER       Length,
  80     IN ULONG                Key,
  81     IN PFILE_OBJECT         FileObject,
  82     IN PEPROCESS            Process
  83     )
  84 {
  85         return FALSE;
  86 }
  87
  88
  89 /**********************************************************************
  90  * NAME                                                 EXPORTED
  91  *      FsRtlFastCheckLockForWrite@24
  92  *
  93  * DESCRIPTION
  94  *
  95  * ARGUMENTS
  96  *
  97  * RETURN VALUE
  98  *
  99  */
 100 BOOLEAN
 101 STDCALL
 102 FsRtlFastCheckLockForWrite (
 103     IN PFILE_LOCK           FileLock,
 104     IN PLARGE_INTEGER       FileOffset,
 105     IN PLARGE_INTEGER       Length,
 106     IN ULONG                Key,
 107     IN PFILE_OBJECT         FileObject,
 108     IN PEPROCESS            Process
 109     )
 110 {
 111         return FALSE;
 112 }
 113
 114
 115 /**********************************************************************
 116  * NAME                                                 EXPORTED
 117  *      FsRtlFastUnlockAll@16
 118  *      FsRtlFastUnlockAllByKey@20
 119  *
 120  * DESCRIPTION
 121  *
 122  * ARGUMENTS
 123  *
 124  * RETURN VALUE
 125  *
 126  */
 127 static
 128 NTSTATUS
 129 STDCALL
 130 FsRtlpFastUnlockAllByKey (
 131     IN PFILE_LOCK           FileLock,
 132     IN PFILE_OBJECT         FileObject,
 133     IN PEPROCESS            Process,
 134     IN DWORD                Key,      /* FIXME: guess */
 135     IN BOOLEAN              UseKey,   /* FIXME: guess */
 136     IN PVOID                Context OPTIONAL
 137     )
 138 {
 139         /* FIXME: */
 140         return (STATUS_RANGE_NOT_LOCKED);
 141 }
 142
 143
 144 NTSTATUS
 145 STDCALL
 146 FsRtlFastUnlockAll (
 147     IN PFILE_LOCK           FileLock,
 148     IN PFILE_OBJECT         FileObject,
 149     IN PEPROCESS            Process,
 150     IN PVOID                Context OPTIONAL
 151     )
 152 {
 153         return FsRtlpFastUnlockAllByKey (
 154                         FileLock,
 155                         FileObject,
 156                         Process,
 157                         0,     /* Key */
 158                         FALSE, /* Do NOT use Key */
 159                         Context
 160                         );
 161 }
 162
 163
 164 NTSTATUS
 165 STDCALL
 166 FsRtlFastUnlockAllByKey (
 167     IN PFILE_LOCK           FileLock,
 168     IN PFILE_OBJECT         FileObject,
 169     IN PEPROCESS            Process,
 170     IN ULONG                Key,
 171     IN PVOID                Context OPTIONAL
 172     )
 173 {
 174         return FsRtlpFastUnlockAllByKey (
 175                         FileLock,
 176                         FileObject,
 177                         Process,
 178                         Key,
 179                         TRUE, /* Use Key */
 180                         Context
 181                         );
 182 }
 183
 184
 185 /**********************************************************************
 186  * NAME                                                 EXPORTED
 187  *      FsRtlFastUnlockSingle@32
 188  *
 189  * DESCRIPTION
 190  *
 191  * ARGUMENTS
 192  *
 193  * RETURN VALUE
 194  *
 195  */
 196 NTSTATUS
 197 STDCALL
 198 FsRtlFastUnlockSingle (
 199     IN PFILE_LOCK           FileLock,
 200     IN PFILE_OBJECT         FileObject,
 201     IN PLARGE_INTEGER       FileOffset,
 202     IN PLARGE_INTEGER       Length,
 203     IN PEPROCESS            Process,
 204     IN ULONG                Key,
 205     IN PVOID                Context OPTIONAL,
 206     IN BOOLEAN              AlreadySynchronized
 207     )
 208 {
 209         return (STATUS_RANGE_NOT_LOCKED);
 210 }
 211
 212
 213 /**********************************************************************
 214  * NAME                                                 EXPORTED
 215  *      FsRtlGetNextFileLock@8
 216  *
 217  * DESCRIPTION
 218  *
 219  * ARGUMENTS
 220  *
 221  * RETURN VALUE
 222  *      NULL if no more locks.
 223  *
 224  * NOTE (Bo Branten)
 225  *      Internals: FsRtlGetNextFileLock uses
 226  *      FileLock->LastReturnedLockInfo and FileLock->LastReturnedLock
 227  *      as storage. LastReturnedLock is a pointer to the 'raw' lock
 228  *      inkl. double linked list, and FsRtlGetNextFileLock needs this
 229  *      to get next lock on subsequent calls with Restart = FALSE.
 230  */
 231 PFILE_LOCK_INFO
 232 STDCALL
 233 FsRtlGetNextFileLock (
 234     IN PFILE_LOCK   FileLock,
 235     IN BOOLEAN      Restart
 236     )
 237 {
 238         return (NULL);
 239 }
 240
 241
 242 /**********************************************************************
 243  * NAME                                                 EXPORTED
 244  *      FsRtlInitializeFileLock@12
 245  *
 246  * DESCRIPTION
 247  *
 248  * ARGUMENTS
 249  *
 250  * RETURN VALUE
 251  *
 252  */
 253 VOID
 254 STDCALL
 255 FsRtlInitializeFileLock (
 256     IN PFILE_LOCK                   FileLock,
 257     IN PCOMPLETE_LOCK_IRP_ROUTINE   CompleteLockIrpRoutine OPTIONAL,
 258     IN PUNLOCK_ROUTINE              UnlockRoutine OPTIONAL
 259     )
 260 {
 261 }
 262
 263
 264 /**********************************************************************
 265  * NAME                                                 EXPORTED
 266  *      FsRtlPrivateLock@48
 267  *
 268  * DESCRIPTION
 269  *
 270  * ARGUMENTS
 271  *
 272  * RETURN VALUE
 273  *      IoStatus->Status: STATUS_PENDING, STATUS_LOCK_NOT_GRANTED
 274  *
 275  * NOTE (Bo Branten)
 276  *      -Calls IoCompleteRequest if Irp
 277  *      -Uses exception handling / ExRaiseStatus with
 278  *       STATUS_INSUFFICIENT_RESOURCES
 279  */
 280 BOOLEAN
 281 STDCALL
 282 FsRtlPrivateLock (
 283     IN PFILE_LOCK           FileLock,
 284     IN PFILE_OBJECT         FileObject,
 285     IN PLARGE_INTEGER       FileOffset,
 286     IN PLARGE_INTEGER       Length,
 287     IN PEPROCESS            Process,
 288     IN ULONG                Key,
 289     IN BOOLEAN              FailImmediately,
 290     IN BOOLEAN              ExclusiveLock,
 291     OUT PIO_STATUS_BLOCK    IoStatus,
 292     IN PIRP                 Irp OPTIONAL,
 293     IN PVOID                Context,
 294     IN BOOLEAN              AlreadySynchronized
 295     )
 296 {
 297         return FALSE;
 298 }
 299
 300
 301 /**********************************************************************
 302  * NAME                                                 EXPORTED
 303  *      FsRtlProcessFileLock@12
 304  *
 305  * DESCRIPTION
 306  *
 307  * ARGUMENTS
 308  *
 309  * RETURN VALUE
 310  *      -STATUS_INVALID_DEVICE_REQUEST
 311  *      -STATUS_RANGE_NOT_LOCKED from unlock routines.
 312  *      -STATUS_PENDING, STATUS_LOCK_NOT_GRANTED from FsRtlPrivateLock
 313  *       (redirected IoStatus->Status).
 314  *
 315  * NOTE (Bo Branten)
 316  *      -switch ( Irp->CurrentStackLocation->MinorFunction )
 317  *       lock: return FsRtlPrivateLock;
 318  *       unlocksingle: return FsRtlFastUnlockSingle;
 319  *       unlockall: return FsRtlFastUnlockAll;
 320  *       unlockallbykey: return FsRtlFastUnlockAllByKey;
 321  *       default: IofCompleteRequest with STATUS_INVALID_DEVICE_REQUEST;
 322  *        return STATUS_INVALID_DEVICE_REQUEST;
 323  *
 324  *      -'AllwaysZero' is passed thru as 'AllwaysZero' to lock / unlock routines.
 325  *      -'Irp' is passet thru as 'Irp' to FsRtlPrivateLock.
 326  */
 327 NTSTATUS
 328 STDCALL
 329 FsRtlProcessFileLock (
 330     IN PFILE_LOCK   FileLock,
 331     IN PIRP         Irp,
 332     IN PVOID        Context OPTIONAL
 333     )
 334 {
 335         return (STATUS_NOT_IMPLEMENTED);
 336 }
 337
 338
 339 /**********************************************************************
 340  * NAME                                                 EXPORTED
 341  *      FsRtlUninitializeFileLock@4
 342  *
 343  * DESCRIPTION
 344  *
 345  * ARGUMENTS
 346  *
 347  * RETURN VALUE
 348  *
 349  */
 350 VOID
 351 STDCALL
 352 FsRtlUninitializeFileLock (
 353     IN PFILE_LOCK FileLock
 354     )
 355 {
 356 }
 357
 358
 359 /**********************************************************************
 360  * NAME                                                 EXPORTED
 361  *      FsRtlAllocateFileLock@8
 362  *
 363  * DESCRIPTION
 364  *      Only present in NT 5.0 or later.
 365  *
 366  * ARGUMENTS
 367  *
 368  * RETURN VALUE
 369  *
 370  */
 371 PFILE_LOCK
 372 STDCALL
 373 FsRtlAllocateFileLock (
 374     IN PCOMPLETE_LOCK_IRP_ROUTINE   CompleteLockIrpRoutine OPTIONAL,
 375     IN PUNLOCK_ROUTINE              UnlockRoutine OPTIONAL
 376     )
 377 {
 378         return NULL;
 379 }
 380
 381 /* EOF */