pastebin - collaborative debugging tool
rovema.kpaste.net RSS


msnfs41client: Patch to add wrapper functions for memory mapping+page locking, 2025-10-21
Posted by Anonymous on Tue 21st Oct 2025 15:32
raw | new post

  1. From c9c63d3511086432569557eb5ff3f3ed8ff30d16 Mon Sep 17 00:00:00 2001
  2. From: Roland Mainz <roland.mainz@nrubsig.org>
  3. Date: Tue, 21 Oct 2025 16:01:08 +0200
  4. Subject: [PATCH] sys: Add wrapper functions for memory mapping/page locking
  5.  
  6. Add wrapper functions for memory mapping/page locking to simplify code.
  7.  
  8. Signed-off-by: Cedric Blancher <cedric.blancher@gmail.com>
  9. ---
  10. sys/nfs41sys_dir.c        | 54 ++++++++++++---------------
  11.  sys/nfs41sys_fsctl.c      | 64 ++++++++++++++------------------
  12.  sys/nfs41sys_openclose.c  | 62 +++++++++++++++----------------
  13.  sys/nfs41sys_readwrite.c  | 76 ++++++++++++++++----------------------
  14.  sys/nfs41sys_updowncall.c | 12 ++++--
  15.  sys/nfs41sys_util.c       | 78 +++++++++++++++++++++++++++++++++++++++
  16.  sys/nfs41sys_util.h       | 14 ++++++-
  17.  7 files changed, 212 insertions(+), 148 deletions(-)
  18.  
  19. diff --git a/sys/nfs41sys_dir.c b/sys/nfs41sys_dir.c
  20. index 75b2820..6cdcbfc 100644
  21. --- a/sys/nfs41sys_dir.c
  22. +++ b/sys/nfs41sys_dir.c
  23. @@ -101,26 +101,20 @@ NTSTATUS marshal_nfs41_dirquery(
  24.      tmp += sizeof(BOOLEAN);
  25.      RtlCopyMemory(tmp, &entry->u.QueryFile.return_single, sizeof(BOOLEAN));
  26.      tmp += sizeof(BOOLEAN);
  27. -    __try {
  28. -        entry->u.QueryFile.mdl_buf =
  29. -            MmMapLockedPagesSpecifyCache(entry->u.QueryFile.mdl,
  30. -                UserMode, MmCached, NULL, FALSE,
  31. -                NormalPagePriority|MdlMappingNoExecute);
  32. -        if (entry->u.QueryFile.mdl_buf == NULL) {
  33. -            print_error("marshal_nfs41_dirquery: "
  34. -                "MmMapLockedPagesSpecifyCache() failed to map pages\n");
  35. -            status = STATUS_INSUFFICIENT_RESOURCES;
  36. -            goto out;
  37. -        }
  38. -    } __except(EXCEPTION_EXECUTE_HANDLER) {
  39. -        NTSTATUS code;
  40. -        code = GetExceptionCode();
  41. -        print_error("marshal_nfs41_dirquery: Call to "
  42. -            "MmMapLockedPagesSpecifyCache() failed "
  43. -            "due to exception 0x%lx\n", (long)code);
  44. -        status = STATUS_ACCESS_VIOLATION;
  45. +
  46. +    status = nfs41_MapLockedPagesInNfsDaemonAddressSpace(
  47. +        &entry->u.QueryFile.mdl_buf,
  48. +        entry->u.QueryFile.mdl,
  49. +        MmCached,
  50. +        NormalPagePriority|MdlMappingNoExecute);
  51. +    if (status != STATUS_SUCCESS) {
  52. +        print_error("marshal_nfs41_dirquery: "
  53. +            "nfs41_MapLockedPagesInNfsDaemonAddressSpace() failed, "
  54. +            "status=0x%lx\n",
  55. +            (long)status);
  56.          goto out;
  57.      }
  58. +
  59.      RtlCopyMemory(tmp, &entry->u.QueryFile.mdl_buf, sizeof(HANDLE));
  60.      *len = header_len;
  61.  
  62. @@ -147,16 +141,9 @@ NTSTATUS unmarshal_nfs41_dirquery(
  63.      DbgP("unmarshal_nfs41_dirquery: reply size %d\n", buf_len);
  64.  #endif
  65.      *buf += sizeof(ULONG);
  66. -    __try {
  67. -        MmUnmapLockedPages(cur->u.QueryFile.mdl_buf, cur->u.QueryFile.mdl);
  68. -        cur->u.QueryFile.mdl_buf = NULL;
  69. -    } __except(EXCEPTION_EXECUTE_HANDLER) {
  70. -        NTSTATUS code;
  71. -        code = GetExceptionCode();
  72. -        print_error("MmUnmapLockedPages thrown exception=0x%lx\n",
  73. -            (long)code);
  74. -        status = STATUS_ACCESS_VIOLATION;
  75. -    }
  76. +    (void)nfs41_UnmapLockedKernelPagesInNfsDaemonAddressSpace(
  77. +        cur->u.QueryFile.mdl_buf,
  78. +        cur->u.QueryFile.mdl);
  79.      if (buf_len > cur->buf_len)
  80.          cur->status = STATUS_BUFFER_TOO_SMALL;
  81.      cur->buf_len = buf_len;
  82. @@ -283,7 +270,14 @@ NTSTATUS nfs41_QueryDirectory(
  83.      entry->u.QueryFile.mdl->MdlFlags |= MDL_MAPPING_CAN_FAIL;
  84.  #pragma warning( pop )
  85.  
  86. -    MmProbeAndLockPages(entry->u.QueryFile.mdl, KernelMode, IoModifyAccess);
  87. +    status = nfs41_ProbeAndLockKernelPages(entry->u.QueryFile.mdl,
  88. +        IoModifyAccess);
  89. +    if (status) {
  90. +        DbgP("nfs41_QueryDirectory: "
  91. +            "nfs41_ProbeAndLockKernelPages() failed, status=0x%lx\n",
  92. +            (long)status);
  93. +        goto out;
  94. +    }
  95.  
  96.      entry->u.QueryFile.filter = Filter;
  97.      entry->u.QueryFile.initial_query = RxContext->QueryDirectory.InitialQuery;
  98. @@ -292,7 +286,7 @@ NTSTATUS nfs41_QueryDirectory(
  99.  
  100.      status = nfs41_UpcallWaitForReply(entry, pVNetRootContext->timeout);
  101.  
  102. -    MmUnlockPages(entry->u.QueryFile.mdl);
  103. +    (void)nfs41_UnlockKernelPages(entry->u.QueryFile.mdl);
  104.  
  105.      if (status) {
  106.          /* Timeout - |nfs41_downcall()| will free |entry|+contents */
  107. diff --git a/sys/nfs41sys_fsctl.c b/sys/nfs41sys_fsctl.c
  108. index 0e1ba89..de9eb2d 100644
  109. --- a/sys/nfs41sys_fsctl.c
  110. +++ b/sys/nfs41sys_fsctl.c
  111. @@ -186,9 +186,15 @@ NTSTATUS nfs41_QueryAllocatedRanges(
  112.      entry->u.QueryAllocatedRanges.BufferMdl->MdlFlags |=
  113.          MDL_MAPPING_CAN_FAIL;
  114.  #pragma warning( pop )
  115. -    MmProbeAndLockPages(entry->u.QueryAllocatedRanges.BufferMdl,
  116. -        KernelMode,
  117. +    status = nfs41_ProbeAndLockKernelPages(
  118. +        entry->u.QueryAllocatedRanges.BufferMdl,
  119.          IoModifyAccess);
  120. +    if (status) {
  121. +        DbgP("nfs41_QueryAllocatedRanges: "
  122. +            "nfs41_ProbeAndLockKernelPages() failed, status=0x%lx\n",
  123. +            (long)status);
  124. +        goto out;
  125. +    }
  126.  
  127.      status = nfs41_UpcallWaitForReply(entry, pVNetRootContext->timeout);
  128.      if (status) {
  129. @@ -229,7 +235,8 @@ NTSTATUS nfs41_QueryAllocatedRanges(
  130.  out:
  131.      if (entry) {
  132.          if (entry->u.QueryAllocatedRanges.BufferMdl) {
  133. -            MmUnlockPages(entry->u.QueryAllocatedRanges.BufferMdl);
  134. +            (void)nfs41_UnlockKernelPages(
  135. +                entry->u.QueryAllocatedRanges.BufferMdl);
  136.              IoFreeMdl(entry->u.QueryAllocatedRanges.BufferMdl);
  137.              entry->u.QueryAllocatedRanges.BufferMdl = NULL;
  138.          }
  139. @@ -270,27 +277,19 @@ NTSTATUS marshal_nfs41_queryallocatedranges(
  140.          sizeof(entry->u.QueryAllocatedRanges.BufferSize));
  141.      tmp += sizeof(entry->u.QueryAllocatedRanges.BufferSize);
  142.  
  143. -    __try {
  144. -        if (entry->u.QueryAllocatedRanges.BufferMdl) {
  145. -            entry->u.QueryAllocatedRanges.Buffer =
  146. -                MmMapLockedPagesSpecifyCache(
  147. -                    entry->u.QueryAllocatedRanges.BufferMdl,
  148. -                    UserMode, MmCached, NULL, FALSE,
  149. -                    NormalPagePriority|MdlMappingNoExecute);
  150. -            if (entry->u.QueryAllocatedRanges.Buffer == NULL) {
  151. -                print_error("marshal_nfs41_queryallocatedranges: "
  152. -                    "MmMapLockedPagesSpecifyCache() failed to "
  153. -                    "map pages\n");
  154. -                status = STATUS_INSUFFICIENT_RESOURCES;
  155. -                goto out;
  156. -            }
  157. +    if (entry->u.QueryAllocatedRanges.BufferMdl) {
  158. +        status = nfs41_MapLockedPagesInNfsDaemonAddressSpace(
  159. +            &entry->u.QueryAllocatedRanges.Buffer,
  160. +            entry->u.QueryAllocatedRanges.BufferMdl,
  161. +            MmCached,
  162. +            NormalPagePriority|MdlMappingNoExecute);
  163. +        if (status != STATUS_SUCCESS) {
  164. +            print_error("marshal_nfs41_queryallocatedranges: "
  165. +                "nfs41_MapLockedPagesInNfsDaemonAddressSpace() failed, "
  166. +                "status=0x%lx\n",
  167. +                (long)status);
  168. +            goto out;
  169.          }
  170. -    } __except(EXCEPTION_EXECUTE_HANDLER) {
  171. -        print_error("marshal_nfs41_queryallocatedranges: Call to "
  172. -            "MmMapLockedPagesSpecifyCache() failed "
  173. -            "due to exception 0x%lx\n", (long)GetExceptionCode());
  174. -        status = STATUS_ACCESS_VIOLATION;
  175. -        goto out;
  176.      }
  177.      RtlCopyMemory(tmp, &entry->u.QueryAllocatedRanges.Buffer,
  178.          sizeof(HANDLE));
  179. @@ -311,19 +310,11 @@ NTSTATUS unmarshal_nfs41_queryallocatedranges(
  180.  {
  181.      NTSTATUS status = STATUS_SUCCESS;
  182.  
  183. -    __try {
  184. -        if (cur->u.QueryAllocatedRanges.Buffer) {
  185. -            MmUnmapLockedPages(
  186. -                cur->u.QueryAllocatedRanges.Buffer,
  187. -                cur->u.QueryAllocatedRanges.BufferMdl);
  188. -            cur->u.QueryAllocatedRanges.Buffer = NULL;
  189. -        }
  190. -    } __except(EXCEPTION_EXECUTE_HANDLER) {
  191. -        print_error("unmarshal_nfs41_queryallocatedranges: "
  192. -            "MmUnmapLockedPages thrown exception=0x%lx\n",
  193. -            (long)GetExceptionCode());
  194. -        status = cur->status = STATUS_ACCESS_VIOLATION;
  195. -        goto out;
  196. +    if (cur->u.QueryAllocatedRanges.Buffer) {
  197. +        (void)nfs41_UnmapLockedKernelPagesInNfsDaemonAddressSpace(
  198. +            cur->u.QueryAllocatedRanges.Buffer,
  199. +            cur->u.QueryAllocatedRanges.BufferMdl);
  200. +        cur->u.QueryAllocatedRanges.Buffer = NULL;
  201.      }
  202.  
  203.      RtlCopyMemory(&cur->u.QueryAllocatedRanges.buffer_overflow,
  204. @@ -338,7 +329,6 @@ NTSTATUS unmarshal_nfs41_queryallocatedranges(
  205.          (int)cur->u.QueryAllocatedRanges.buffer_overflow,
  206.          cur->u.QueryAllocatedRanges.returned_size);
  207.  
  208. -out:
  209.      return status;
  210.  }
  211.  
  212. diff --git a/sys/nfs41sys_openclose.c b/sys/nfs41sys_openclose.c
  213. index a7dbcc2..4f71146 100644
  214. --- a/sys/nfs41sys_openclose.c
  215. +++ b/sys/nfs41sys_openclose.c
  216. @@ -158,26 +158,22 @@ NTSTATUS marshal_nfs41_open(
  217.      status = marshall_unicode_as_utf8(&tmp, &entry->u.Open.symlink);
  218.      if (status) goto out;
  219.  
  220. -    __try {
  221. -        if (entry->u.Open.EaMdl) {
  222. -            entry->u.Open.EaBuffer =
  223. -                MmMapLockedPagesSpecifyCache(entry->u.Open.EaMdl,
  224. -                    UserMode, MmCached, NULL, FALSE,
  225. -                    NormalPagePriority|MdlMappingNoExecute);
  226. -            if (entry->u.Open.EaBuffer == NULL) {
  227. -                print_error("marshal_nfs41_open: "
  228. -                    "MmMapLockedPagesSpecifyCache() failed to "
  229. -                    "map pages\n");
  230. -                status = STATUS_INSUFFICIENT_RESOURCES;
  231. -                goto out;
  232. -            }
  233. +    if (entry->u.Open.EaMdl) {
  234. +        status = nfs41_MapLockedPagesInNfsDaemonAddressSpace(
  235. +            &entry->u.Open.EaBuffer,
  236. +            entry->u.Open.EaMdl,
  237. +            MmCached,
  238. +            NormalPagePriority|MdlMappingNoExecute);
  239. +        if (status != STATUS_SUCCESS) {
  240. +            print_error("marshal_nfs41_open: "
  241. +                "nfs41_MapLockedPagesInNfsDaemonAddressSpace() failed, "
  242. +                "status=0x%lx\n",
  243. +                (long)status);
  244. +            goto out;
  245.          }
  246. -    } __except(EXCEPTION_EXECUTE_HANDLER) {
  247. -        print_error("marshal_nfs41_open: Call to "
  248. -            "MmMapLockedPagesSpecifyCache() failed "
  249. -            "due to exception 0x%lx\n", (long)GetExceptionCode());
  250. -        status = STATUS_ACCESS_VIOLATION;
  251. -        goto out;
  252. +    }
  253. +    else {
  254. +        entry->u.Open.EaBuffer = NULL;
  255.      }
  256.      RtlCopyMemory(tmp, &entry->u.Open.EaBuffer, sizeof(HANDLE));
  257.      *len = header_len;
  258. @@ -244,16 +240,10 @@ NTSTATUS unmarshal_nfs41_open(
  259.  {
  260.      NTSTATUS status = STATUS_SUCCESS;
  261.  
  262. -    __try {
  263. -        if (cur->u.Open.EaBuffer) {
  264. -            MmUnmapLockedPages(cur->u.Open.EaBuffer, cur->u.Open.EaMdl);
  265. -            cur->u.Open.EaBuffer = NULL;
  266. -        }
  267. -    } __except(EXCEPTION_EXECUTE_HANDLER) {
  268. -        print_error("MmUnmapLockedPages thrown exception=0x%lx\n",
  269. -            (long)GetExceptionCode());
  270. -        status = cur->status = STATUS_ACCESS_VIOLATION;
  271. -        goto out;
  272. +    if (cur->u.Open.EaBuffer) {
  273. +        (void)nfs41_UnmapLockedKernelPagesInNfsDaemonAddressSpace(
  274. +            cur->u.Open.EaBuffer, cur->u.Open.EaMdl);
  275. +        cur->u.Open.EaBuffer = NULL;
  276.      }
  277.  
  278.      RtlCopyMemory(&cur->u.Open.binfo, *buf, sizeof(FILE_BASIC_INFORMATION));
  279. @@ -741,13 +731,23 @@ retry_on_link:
  280.  #pragma warning (disable : 28145)
  281.          entry->u.Open.EaMdl->MdlFlags |= MDL_MAPPING_CAN_FAIL;
  282.  #pragma warning( pop )
  283. -        MmProbeAndLockPages(entry->u.Open.EaMdl, KernelMode, IoModifyAccess);
  284. +        status = nfs41_ProbeAndLockKernelPages(entry->u.Open.EaMdl,
  285. +            IoModifyAccess);
  286. +        if (status) {
  287. +            DbgP("nfs41_Create: "
  288. +                "nfs41_ProbeAndLockKernelPages() failed, status=0x%lx\n",
  289. +                (long)status);
  290. +            goto out;
  291. +        }
  292. +    }
  293. +    else {
  294. +        entry->u.Open.EaMdl = NULL;
  295.      }
  296.  
  297.      status = nfs41_UpcallWaitForReply(entry, pVNetRootContext->timeout);
  298.  
  299.      if (entry->u.Open.EaMdl) {
  300. -        MmUnlockPages(entry->u.Open.EaMdl);
  301. +        (void)nfs41_UnlockKernelPages(entry->u.Open.EaMdl);
  302.          IoFreeMdl(entry->u.Open.EaMdl);
  303.          entry->u.Open.EaMdl = NULL;
  304.      }
  305. diff --git a/sys/nfs41sys_readwrite.c b/sys/nfs41sys_readwrite.c
  306. index f1eface..f0c8beb 100644
  307. --- a/sys/nfs41sys_readwrite.c
  308. +++ b/sys/nfs41sys_readwrite.c
  309. @@ -109,43 +109,37 @@ NTSTATUS marshal_nfs41_rw(
  310.      RtlCopyMemory(tmp, &entry->u.ReadWrite.offset,
  311.          sizeof(entry->u.ReadWrite.offset));
  312.      tmp += sizeof(entry->u.ReadWrite.offset);
  313. -    __try {
  314. +
  315.  #pragma warning( push )
  316.  /*
  317.   * C28145: "The opaque MDL structure should not be modified by a
  318.   * driver.", |MDL_MAPPING_CAN_FAIL| is the exception
  319.   */
  320.  #pragma warning (disable : 28145)
  321. -        entry->u.ReadWrite.MdlAddress->MdlFlags |= MDL_MAPPING_CAN_FAIL;
  322. +    entry->u.ReadWrite.MdlAddress->MdlFlags |= MDL_MAPPING_CAN_FAIL;
  323.  #pragma warning( pop )
  324. -        ULONG prio_writeflags = 0;
  325. -
  326. -        /*
  327. -         * The userland daemon will only read from this memory for
  328. -         * "write" requests, so make it read-only
  329. -         */
  330. -        if (entry->opcode == NFS41_SYSOP_WRITE)
  331. -            prio_writeflags |= MdlMappingNoWrite;
  332. -
  333. -        entry->buf =
  334. -            MmMapLockedPagesSpecifyCache(entry->u.ReadWrite.MdlAddress,
  335. -                UserMode, MmCached, NULL, FALSE,
  336. -                (NormalPagePriority|prio_writeflags));
  337. -        if (entry->buf == NULL) {
  338. -            print_error("marshal_nfs41_rw: "
  339. -                "MmMapLockedPagesSpecifyCache() failed to map pages\n");
  340. -            status = STATUS_INSUFFICIENT_RESOURCES;
  341. -            goto out;
  342. -        }
  343. -    } __except(EXCEPTION_EXECUTE_HANDLER) {
  344. -        NTSTATUS code;
  345. -        code = GetExceptionCode();
  346. -        print_error("marshal_nfs41_rw: Call to "
  347. -            "MmMapLockedPagesSpecifyCache() failed due to "
  348. -            "exception 0x%lx\n", (long)code);
  349. -        status = STATUS_ACCESS_VIOLATION;
  350. +    ULONG prio_writeflags = 0;
  351. +
  352. +    /*
  353. +     * The userland daemon will only read from this memory for
  354. +     * "write" requests, so make it read-only
  355. +     */
  356. +    if (entry->opcode == NFS41_SYSOP_WRITE)
  357. +        prio_writeflags |= MdlMappingNoWrite;
  358. +
  359. +    status = nfs41_MapLockedPagesInNfsDaemonAddressSpace(
  360. +        &entry->buf,
  361. +        entry->u.ReadWrite.MdlAddress,
  362. +        MmCached,
  363. +        (NormalPagePriority|prio_writeflags));
  364. +    if (status != STATUS_SUCCESS) {
  365. +        print_error("marshal_nfs41_rw: "
  366. +            "nfs41_MapLockedPagesInNfsDaemonAddressSpace() failed, "
  367. +            "status=0x%lx\n",
  368. +            (long)status);
  369.          goto out;
  370.      }
  371. +
  372.      RtlCopyMemory(tmp, &entry->buf, sizeof(HANDLE));
  373.      *len = header_len;
  374.  
  375. @@ -174,23 +168,15 @@ NTSTATUS unmarshal_nfs41_rw(
  376.          cur->buf_len, cur->ChangeTime);
  377.  #endif
  378.  #if 1
  379. -    /* 08/27/2010: it looks like we really don't need to call
  380. -        * MmUnmapLockedPages() eventhough we called
  381. -        * MmMapLockedPagesSpecifyCache() as the MDL passed to us
  382. -        * is already locked.
  383. -        */
  384. -    __try {
  385. -        if (cur->buf) {
  386. -            MmUnmapLockedPages(cur->buf, cur->u.ReadWrite.MdlAddress);
  387. -            cur->buf = NULL;
  388. -        }
  389. -    } __except(EXCEPTION_EXECUTE_HANDLER) {
  390. -        NTSTATUS code;
  391. -        code = GetExceptionCode();
  392. -        print_error("unmarshal_nfs41_rw: Call to MmUnmapLockedPages() "
  393. -            "failed due to exception 0x%0x\n", (long)code);
  394. -        status = STATUS_ACCESS_VIOLATION;
  395. -    }
  396. +    /*
  397. +     * 08/27/2010: it looks like we really don't need to call
  398. +     * MmUnmapLockedPages() eventhough we called
  399. +     * MmMapLockedPagesSpecifyCache() as the MDL passed to us
  400. +     * is already locked.
  401. +     */
  402. +    (void)nfs41_UnmapLockedKernelPagesInNfsDaemonAddressSpace(cur->buf,
  403. +        cur->u.ReadWrite.MdlAddress);
  404. +    cur->buf = NULL;
  405.  #endif
  406.      return status;
  407.  }
  408. diff --git a/sys/nfs41sys_updowncall.c b/sys/nfs41sys_updowncall.c
  409. index 30a5793..aba635b 100644
  410. --- a/sys/nfs41sys_updowncall.c
  411. +++ b/sys/nfs41sys_updowncall.c
  412. @@ -681,13 +681,16 @@ NTSTATUS nfs41_downcall(
  413.          case NFS41_SYSOP_WRITE:
  414.          case NFS41_SYSOP_READ:
  415.              if (cur->buf) {
  416. -                MmUnmapLockedPages(cur->buf, cur->u.ReadWrite.MdlAddress);
  417. +                (void)nfs41_UnmapLockedKernelPagesInNfsDaemonAddressSpace(
  418. +                    cur->buf,
  419. +                    cur->u.ReadWrite.MdlAddress);
  420.                  cur->buf = NULL;
  421.              }
  422.              break;
  423.          case NFS41_SYSOP_DIR_QUERY:
  424.              if (cur->u.QueryFile.mdl) {
  425. -                MmUnmapLockedPages(cur->u.QueryFile.mdl_buf,
  426. +                (void)nfs41_UnmapLockedKernelPagesInNfsDaemonAddressSpace(
  427. +                    cur->u.QueryFile.mdl_buf,
  428.                      cur->u.QueryFile.mdl);
  429.                  IoFreeMdl(cur->u.QueryFile.mdl);
  430.                  cur->u.QueryFile.mdl_buf = NULL;
  431. @@ -696,7 +699,8 @@ NTSTATUS nfs41_downcall(
  432.              break;
  433.          case NFS41_SYSOP_OPEN:
  434.              if (cur->u.Open.EaMdl) {
  435. -                MmUnmapLockedPages(cur->u.Open.EaBuffer,
  436. +                (void)nfs41_UnmapLockedKernelPagesInNfsDaemonAddressSpace(
  437. +                    cur->u.Open.EaBuffer,
  438.                      cur->u.Open.EaMdl);
  439.                  IoFreeMdl(cur->u.Open.EaMdl);
  440.                  cur->u.Open.EaBuffer = NULL;
  441. @@ -705,7 +709,7 @@ NTSTATUS nfs41_downcall(
  442.              break;
  443.          case NFS41_SYSOP_FSCTL_QUERYALLOCATEDRANGES:
  444.              if (cur->u.QueryAllocatedRanges.BufferMdl) {
  445. -                MmUnmapLockedPages(
  446. +                (void)nfs41_UnmapLockedKernelPagesInNfsDaemonAddressSpace(
  447.                      cur->u.QueryAllocatedRanges.Buffer,
  448.                      cur->u.QueryAllocatedRanges.BufferMdl);
  449.                  IoFreeMdl(cur->u.QueryAllocatedRanges.BufferMdl);
  450. diff --git a/sys/nfs41sys_util.c b/sys/nfs41sys_util.c
  451. index e6876b4..65c1990 100644
  452. --- a/sys/nfs41sys_util.c
  453. +++ b/sys/nfs41sys_util.c
  454. @@ -116,3 +116,81 @@ BOOLEAN is_root_directory(
  455.  
  456.      return RxContext->CurrentIrpSp->FileObject->FileName.Length <= RootPathLen;
  457.  }
  458. +
  459. +NTSTATUS nfs41_ProbeAndLockKernelPages(
  460. +    __inout PMDL    MemoryDescriptorList,
  461. +    __in    LOCK_OPERATION  Operation)
  462. +{
  463. +    NTSTATUS status = STATUS_SUCCESS;
  464. +
  465. +    __try {
  466. +        MmProbeAndLockPages(MemoryDescriptorList, KernelMode, Operation);
  467. +    } __except(EXCEPTION_EXECUTE_HANDLER) {
  468. +        NTSTATUS code;
  469. +        code = GetExceptionCode();
  470. +        print_error("marshal_nfs41_dirquery: Call to "
  471. +            "MmMapLockedPagesSpecifyCache() failed "
  472. +            "due to exception 0x%lx\n", (long)code);
  473. +        status = STATUS_ACCESS_VIOLATION;
  474. +    }
  475. +
  476. +    return status;
  477. +}
  478. +
  479. +NTSTATUS nfs41_UnlockKernelPages(
  480. +    __inout PMDL    MemoryDescriptorList)
  481. +{
  482. +    NTSTATUS status = STATUS_SUCCESS;
  483. +    MmUnlockPages(MemoryDescriptorList);
  484. +    return status;
  485. +}
  486. +
  487. +NTSTATUS nfs41_MapLockedPagesInNfsDaemonAddressSpace(
  488. +    __inout PVOID               *outbuf,
  489. +    __in    PMDL                MemoryDescriptorList,
  490. +    __in    MEMORY_CACHING_TYPE CacheType,
  491. +    __in    ULONG               Priority)
  492. +{
  493. +    NTSTATUS status = STATUS_SUCCESS;
  494. +
  495. +    *outbuf = NULL;
  496. +
  497. +    __try {
  498. +        *outbuf =
  499. +            MmMapLockedPagesSpecifyCache(MemoryDescriptorList,
  500. +                UserMode, CacheType, NULL, FALSE, Priority);
  501. +        if (*outbuf == NULL)
  502. +            status = STATUS_INSUFFICIENT_RESOURCES;
  503. +    } __except(EXCEPTION_EXECUTE_HANDLER) {
  504. +        NTSTATUS code;
  505. +        code = GetExceptionCode();
  506. +        print_error("nfs41_MapLockedPagesInNfsDaemonAddressSpace: "
  507. +            "Call to MmMapLockedPagesSpecifyCache() failed "
  508. +            "due to exception 0x%lx\n", (long)code);
  509. +        status = STATUS_ACCESS_VIOLATION;
  510. +        goto out;
  511. +    }
  512. +
  513. +out:
  514. +    return status;
  515. +}
  516. +
  517. +NTSTATUS nfs41_UnmapLockedKernelPagesInNfsDaemonAddressSpace(
  518. +    __in PVOID BaseAddress,
  519. +    __in PMDL  MemoryDescriptorList)
  520. +{
  521. +    NTSTATUS status = STATUS_SUCCESS;
  522. +
  523. +    __try {
  524. +        MmUnmapLockedPages(BaseAddress, MemoryDescriptorList);
  525. +    } __except(EXCEPTION_EXECUTE_HANDLER) {
  526. +        NTSTATUS code;
  527. +        code = GetExceptionCode();
  528. +        print_error("nfs41_UnmapLockedKernelPages: "
  529. +            "MmUnmapLockedPages thrown exception=0x%lx\n",
  530. +            (long)code);
  531. +        status = STATUS_ACCESS_VIOLATION;
  532. +    }
  533. +
  534. +    return status;
  535. +}
  536. diff --git a/sys/nfs41sys_util.h b/sys/nfs41sys_util.h
  537. index c1ade4c..6157195 100644
  538. --- a/sys/nfs41sys_util.h
  539. +++ b/sys/nfs41sys_util.h
  540. @@ -52,5 +52,17 @@ BOOLEAN isStream(
  541.      PUNICODE_STRING name);
  542.  BOOLEAN is_root_directory(
  543.      PRX_CONTEXT RxContext);
  544. -
  545. +NTSTATUS nfs41_ProbeAndLockKernelPages(
  546. +    __inout PMDL    MemoryDescriptorList,
  547. +    __in    LOCK_OPERATION  Operation);
  548. +NTSTATUS nfs41_UnlockKernelPages(
  549. +    __inout PMDL    MemoryDescriptorList);
  550. +NTSTATUS nfs41_MapLockedPagesInNfsDaemonAddressSpace(
  551. +    __inout PVOID               *outbuf,
  552. +    __in    PMDL                MemoryDescriptorList,
  553. +    __in    MEMORY_CACHING_TYPE CacheType,
  554. +    __in    ULONG               Priority);
  555. +NTSTATUS nfs41_UnmapLockedKernelPagesInNfsDaemonAddressSpace(
  556. +    __in PVOID BaseAddress,
  557. +    __in PMDL  MemoryDescriptorList);
  558.  #endif /* !_NFS41SYS_UTIL_H_ */
  559. --
  560. 2.51.0

Submit a correction or amendment below (click here to make a fresh posting)
After submitting an amendment, you'll be able to view the differences between the old and new posts easily.

Syntax highlighting:

To highlight particular lines, prefix each line with {%HIGHLIGHT}




All content is user-submitted.
The administrators of this site (kpaste.net) are not responsible for their content.
Abuse reports should be emailed to us at