Quản Lý Bộ Nhớ Trong Lập Trình C Trên Windows

07:26:00  Unknown  0 comments

QUẢN LÝ BỘ NHỚ TRONG LẬP TRÌNH C TRÊN WINDOWS

Mỗi tiến trình trong Win32 đều có một vùng địa chỉ ảo 32-bit cho phép định vị vùng nhớ đến 4 GB. Địa chỉ ảo này không phải là vùng nhớ vật lý thực tế. Windows sử dụng một cấu trúc dữ liệu ánh xạ để chuyển đổi địa chỉ ảo thành vùng nhớ vật lý.
Vùng địa chỉ ảo của mỗi tiến trình thường lớn hơn rất nhiều so với vùng nhớ vật lý thực sự trên máy tính. Do đó, để tăng vùng nhớ cho các tiến trình đang thực hiện, hệ thống sử dụng vùng nhớ trống trên đĩa. Vùng nhớ vật lý và vùng địa chỉ ảo của mỗi tiến trình được tổ chức thành các trang, phụ thuộc vào họ máy tính. Ví dụ, đối với máy tính họ x86, mỗi trang có kích thước là 4 KB.
Để tăng khả năng linh động trong việc quản lý bộ nhớ, hệ thống có thể di chuyển các trang từ bộ nhớ chính vào đĩa và ngược lại. Các thao tác này được thực hiện chỉ bởi hệ thống, các ứng dụng chỉ việc gọi các hàm cấp phát và sử dụng vùng địa chỉ ảo.
Thư viện C chuẩn hỗ trợ các hàm cấp phát và giải phóng vùng nhớ như malloc, free, …, hoặc trong C++ là new, delete, …. Thế nhưng trong Windows 16 bits, các hàm này có thể gây lỗi hệ thống. Trong Win32, ta có thể sử dụng chúng an toàn do hệ thống chỉ quản lý bộ nhớ qua các trang vật lý mà không ảnh hưởng đến địa chỉ ảo. Hơn nữa, Win32 cũng không phân biệt giữa con trỏ gần và con trỏ xa. Mặc dù vậy, các hàm trên không thể hiện đủ các khả năng hỗ trợ của việc quản lý bộ nhớ trong Win32. Chúng ta sẽ làm quen với các hàm Global và Local - sử dụng từ Windows 16 bits, và các hàm quản lý vùng nhớ ảo khác.

Các hàm Global và Local

Các hàm toàn cục (global) và địa phương (local) là các hàm heap Windows 16 bits. Tuy nhiên, quản lý bộ nhớ trong Win32 cũng hỗ trợ các hàm này để có thể sử dụng các chương trình, hoặc source code của các chương trình viết cho Windows 16 bits. Các hàm toàn cục và địa phương xử lý chậm và ít chức năng hơn các hàm quản lý bộ nhớ mới thiết kế cho Win32. Chúng ta sẽ làm quen các hàm mới ở phần sau.
Để cấp phát vùng nhớ cho một tiến trình, ta có thể sử dụng hàm GlobalAlloc hoặc LocalAlloc. Việc quản lý vùng nhớ trong Win32 không phân biệt hàm toàn cục hay cục bộ như trong Windows 16 bits. Do đó, không có sự phân biệt giữa các đối tượng vùng nhớ được cấp phát bởi hai hàm trên. Thêm vào đó, việc chuyển mô hình đoạn vùng nhớ 16 bits sang vùng địa chỉ ảo 32 bits thực hiện một số hàm toàn cục và địa phương với các chọn lựa (options) không cần thiết hoặc vô nghĩa. Ví dụ, vì cả cấp phát toàn cục và địa phương đều trả về địa chỉ ảo 32 bits, do đó không xác định dạng con trỏ gần hoặc xa trong các hàm trên.
Hai hàm này cấp phát một vùng nhớ theo kích thước nBytes trong heap. Có prototype như sau :
HGLOBAL GlobalAlloc(UINT uFlags, DWORD nBytes);
HLOCAL LocalAlloc(UINT uFlags, UINT nBytes);
Trong đó uFlags xác định cách thức cấp phát vùng nhớ. Ta có bảng sau :
Các cờ sử dụng trong các hàm GlobalAlloc và LocalAlloc
Toàn cụcĐịa phươngÝ nghĩa
GMEM_FIXEDLMEM_FIXEDCấp phát vùng nhớ cố định. Giá trị trả về là một con trỏ.
GMEM_MOVEABLELMEM_MOVEABLECấp phát vùng nhớ không cố định. Trong Win32, khối nhớ không bao giờ di chuyển trong vùng nhớ vật lý, nhưng trong heap mặc định. Hàm trả về handle của một đối tượng bộ nhớ. Ta dùng hàmGlobalLock hoặc LocalLock để chuyển handle sang con trỏ vùng nhớ.
GMEM_ZEROINITLMEM_ZEROINITKhởi tạo nội dung vùng nhớ với giá trị 0.
GPTRGMEM_FIXED | GMEM_ZEROINIT
GHNDGMEM_MOVEABLE | GMEM_ZEROINIT
LPTRLMEM_FIXED | LMEM_ZEROINIT
LHNDLMEM_MOVEABLE | LMEM_ZEROINIT
Chú ý : Không thể sử dụng giá trị GMEM_FIXED đồng thời với GMEM_MOVEABLE, hoặc LMEM_FIXED đồng thời với LMEM_MOVEABLE.
Nếu thành công, hàm trả về handle cho đối tượng vùng nhớ được cấp phát. Ngược lại, giá trị trả về là NULL.
Các đối tượng vùng nhớ được cấp phát bằng hàm GlobalAlloc và LocalAlloc là các trang riêng, truy cập đọc-ghi bởi chính tiến trình tạo nó. Các tiến trình khác không thể truy cập các đối tượng vùng nhớ này.
Khi dùng cách thức cấp phát GMEM_MOVEABLE hoặc LMEM_MOVEABLE, ta nhận được handle vùng nhớ. Để sử dụng vùng nhớ, ta dùng hàm GlobalLock hoặc LocalLock :
LPVOID GlobalLock(HGLOBAL hMem);
LPVOID LocalLock(HLOCAL hMem);
Nếu thành công hàm trả về con trỏ trỏ đến byte đầu tiên trong khối nhớ. Ngược lại, giá trị trả về là NULL.
Khi khoá (lock) vùng nhớ, các khối nhớ không thể dịch chuyển trong bộ nhớ máy tính. Sau khi sử dụng con trỏ vùng nhớ, cần mở khoá (unlock) chúng, để hệ thống có thể di chuyển và sử dụng các vùng nhớ linh động cho các tiến trình khác. Ta dùng hai hàm tương ứng là GlobalUnlock và LocalUnlock.
BOOL GlobalUnlock(HGLOBAL hMem);
BOOL LocalUnlock(HLOCAL hMem);
Mỗi lần khoá vùng nhớ, biến đếm tương ứng tăng một đơn vị. Mỗi lần mở khoá, biến đếm giảm một. Nếu vùng nhớ còn khoá, hàm trả về giá trị khác 0, ngược lại giá trị trả về là 0.
Kích thước thật sự của vùng nhớ được cấp phát có thể lớn hơn kích thước yêu cầu (nBytes). Để xác định số byte thật sự được cấp phát, ta dùng hàm GlobalSize và LocalSize.
DWORD GlobalSize(HGLOBAL hMem);
UINT LocalSize(HLOCAL hMem);
Nếu thành công, hàm trả về số byte kích thước vùng nhớ xác định bởi hMem. Ngược lại, giá trị trả về là 0.
Ngoài ra, ta có thể sử dụng hàm GlobalReAlloc và LocalReAlloc để cấp phát thay đổi kích thước hoặc thuộc tính vùng nhớ.
HGLOBAL GlobalReAlloc(HGLOBAL hMem, DWORD nBytes, UINT uFlags);
HLOCAL LocalReAlloc(HLOCAL hMem, UINT nBytes, UINT nFlags);
Trường nBytes xác định kích thước cấp phát lại cho vùng nhớ hMem. Tuy nhiên, khi nFlags chứa GMEM_MODIFY (hoặc LMEM_MODIFY), hệ thống bỏ qua giá trị này. Khi đó, hàm thay đổi các thuộc tính của vùng nhớ.
Để xác định handle của vùng nhớ khi biết con trỏ vùng nhớ, ta dùng hàm GlobalHandle và LocalHandle như sau :
HGLOBAL GlobalHandle(LPCVOID pMem);
HLOCAL LocalHandle(LPCVOID pMem);
Với pMem là con trỏ trỏ đến byte đầu tiên trong vùng nhớ. Nếu thành công, hàm trả về handle cần tìm. Ngược lại, giá trị trả về là NULL.
Sau khi sử dụng xong, ta dùng hàm GlobalFree và LocalFree để giải phóng các vùng nhớ đã được cấp phát.
HGLOBAL GlobalFree(HGLOBAL hMem);
HLOCAL LocalFree(HLOCAL hMem);
Nếu thành công, giá trị trả về là NULL. Ngược lại, hàm trả về giá trị handle của đối tượng ban đầu.
Đoạn chương trình sau minh họa cách hệ thống cấp phát một vùng nhớ với kích thước yêu cầu là 3500 bytes. Sau đó gán các giá trị vùng nhớ bằng 0x3C.
HANDLE hMem;
LPBYTE lpAddress;
int i, nSizeMem;
hMem = GlobalAlloc(GMEM_MOVEABLE, 3500);
if(hMem != NULL)
{
/* Vùng nhớ có thể lớn hơn 3500 */
nSizeMem = GlobalSize(hMem);
lpAddress = (LPBYTE)GlobalLock(hMem);
if(Address != NULL)
{
for(i=0; i<nSizeMem; i++)
lpAddress[i] = 0x3C;
GlobalUnlock(hMem);
/* … */
}
/* Nếu không dùng nữa thì gọi hàm
GlobalFree(hMem); */
}
Đoạn chương trình tiếp theo cấp phát lại vùng nhớ trên với kích thước là 5000 bytes, khởi gán các giá trị là 0x00 :
…
HANDLE hMemTmp;
hMemTmp = GlobalReAlloc(hMem, 5000,
GMEM_MOVEABLE|GMEM_ZEROINIT);
if(hMemTmp != NULL)
{
hMem = hMemTmp;
nSizeMem = GlobalSize(hMem);
/* … */
}
…
/* Khi kết thúc sử dụng, cần gọi hàm
GlobalFree(hMem); */

Các hàm Heap

Các hàm heap cho phép các tiến trình tạo một vùng heap riêng cho một hoặc một số trang trong vùng địa chỉ của tiến trình đang thực hiện. Sau đó tiến trình có thể sử dụng một tập các hàm khác nhau để quản lý vùng nhớ trong heap này. Ở đây không có sự phân biệt giữa vùng nhớ được cấp phát bởi hàm heap riêng hay dùng các hàm cấp phát khác.
Đầu tiên hàm HeapCreate tạo đối tượng heap cho một tiến trình. Vùng nhớ heap này chỉ được dùng cho tiến trình này mà thôi, và không chia sẻ cho các tiến trình khác, ngay cả các tiến trình trong thư viện liên kết động DLL (dynamic-link library).
HANDLE HeapCreate(DWORD flOptions, DWORD dwInitialSize, DWORD dwMaximumSize);
Trường flOptions xác định các thuộc tính được chọn cho vùng heap mới được khởi tạo. Có thể là HEAP_GENERATE_ EXCEPTIONS và HEAP_NO_SERIALIZE. Trường dwInitialSize xác định kích thước khởi tạo của heap, được làm tròn cho các trang vùng nhớ. Trường dwMaximumSize xác định vùng nhớ tối đa có thể cấp phát cho tiến trình bằng hàm HeapAlloc hoặc HeapReAlloc. Hàm trả về handle của đối tượng heap nếu thành công, ngược lại trả về NULL.
Để cấp phát vùng nhớ lần đầu, ta gọi hàm HeapAlloc. Nếu muốn cấp phát lại, dùng hàm HeapReAlloc.
LPVOID HeapAlloc(HANDLE hHeap, DWORD dwFlags, DWORD dwBytes);
Trường dwFlags có thể là HEAP_GENERATE_ EXCEPTIONS, HEAP_NO_SERIALIZE, và HEAP_ZERO_ MEMORY. Trường dwBytes xác định số bytes vùng heap được cấp phát. Nếu thành công, hàm trả về con trỏ đến vùng nhớ. Nếu thất bại, hàm trả về NULL nếu dwFlags không thiết lập HEAP_ GENERATE_EXCEPTIONS. Nếu có thiết lập, giá trị trả về là STATUS_NO_MEMORY (không có sẵn vùng nhớ hoặc lỗi vùng heap), hoặc STATUS_ACCESS_VIOLATION (Do lỗi vùng heap hoặc biến không chính xác).
LPVOID HeapReAlloc(HANDLE hHeap, DWORD dwFlags, LPVOID lpMem, DWORD dwBytes);
Trường lpMem trỏ đến vùng nhớ cần cấp phát lại. Vùng nhớ này đã được tạo bằng hàm HeapAlloc hoặc HeapReAlloc.
Trường dwBytes xác định kích thước vùng nhớ cần cấp phát. Giá trị này phải nhỏ hơn 0x7FFF8.
Để khoá và mở khoá vùng nhớ heap, ta dùng hàm HeapLock và HeapUnlock.
BOOL HeapLock(HANDLE hHeap);
BOOL HeapUnlock(HANDLE hHeap);
Nếu thành công, giá trị trả về khác 0. Ngược lại, hàm trả về 0.
Để xác định kích thước vùng heap, ta dùng hàm HeapSize.
DWORD HeapSize(HANDLE hHeap, DWORD dwFlags, LPCVOID lpMem);
Trong hàm này, dwFlags chỉ dùng với HEAP_NO_ SERIALIZE. Các trường khác tương tự các hàm khác. Nếu thành công, hàm trả về kích thước vùng nhớ. Nếu thất bại, hàm trả về giá trị là 0xFFFFFFFF.
Sau khi sử dụng, ta giải phóng vùng nhớ và hủy đối tượng heap bằng hàm HeapFree và HeapDestroy.
BOOL HeapFree(HANDLE hHeap, DWORD dwFlags, LPVOID lpMem);
BOOL HeapDestroy(HANDLE hHeap);
Trong đó, trường dwFlags được định nghĩa chỉ với giá trị HEAP_NO_SERIALIZE. Nếu thành công, hai hàm này đều trả về giá trị khác 0. Ngược lại, giá trị trả về là 0.
Chúng ta không minh họa các hàm sử dụng bộ nhớ heap trong tài liệu này.

Các hàm Virtual

Microsoft® Win32® API cung cấp một tập các hàm quản lý bộ nhớ ảo cho phép một tiến trình thao tác và xác định các trang trong vùng địa chỉ không gian ảo, gồm các chức năng sau :
  • Để dành vùng không gian địa chỉ ảo cho một tiến trình. Vùng không gian để dành không cấp phát vùng lưu trữ vật lý thật sự, nhưng ngăn không cho các thao tác cấp phát khác sử dụng vùng nhớ này. Nó không ảnh hưởng đến các tiến trình khác. Khi cần sử dụng, tiến trình sẽ cấp phát vùng lưu trữ vật lý cho không gian này.
  • Cấp phát xác nhận chuỗi các trang để dành trong không gian địa chỉ ảo của tiến trình để có thể sử dụng vùng lưu trữ vật lý (trong RAM hoặc đĩa).
  • Thiết lập các thuộc tính đọc-ghi, chỉ đọc, hoặc không được truy cập cho các trang đã xác nhận. Điều này khác với các hàm cấp phát chuẩn luôn cấp phát cấp phát các trang với thuộc tính là đọc-ghi.
  • Giải phóng chuỗi các trang để dành, để sẵn vùng địa chỉ ảo cho các thao tác cấp phát của tiến trình đang gọi.
  • Khử xác nhận các trang đã xác nhận bằng cách giải phóng vùng lưu trữ vật lý, để sẵn cho các thao tác cấp phát của các tiến trình khác.
  • Khoá một hoặc một vài trang vùng nhớ đã xác nhận vào vùng nhớ vật lý (RAM) để hệ thống có thể hoán chuyển các trang vào tập tin trang.
  • Nhận thông tin về chuỗi các trang trong vùng địa chỉ ảo của tiến trình đang gọi hoặc của một tiến trình xác định khác.
  • Thay đổi các chức năng bảo vệ truy cập cho chuỗi xác định các trang đạ xác nhận trong vùng địa chỉ ảo của tiến trình đang gọi hoặc tiến trình xác định khác.

Cấp phát vùng nhớ ảo

Các hàm quản lý bộ nhớ ảo thực hiện các thao tác trên các trang vùng nhớ. Để cấp phát các trang vùng nhớ ảo, ta dùng hàmVirtualAlloc, với các chức năng sau đây :
  • Để dành một hay nhiều trang trống.
  • Cấp phát xác nhận một hay nhiều trang để dành.
  • Để dành và cấp phát xác nhận một hay nhiều trang trống.
Chúng ta có thể chỉ định địa chỉ đầu của các trang để dành hay cấp phát, hoặc để cho hệ thống tự xác nhận địa chỉ. Hàm sẽ làm tròn địa chỉ chỉ định với biên trang thích hợp. Vùng nhớ được cấp phát được khởi gán bằng 0, nếu ta không thiết lập cờ MEM_RESET.
LPVOID VirtualAlloc(LPVOID lpAddress, DWORD dwSize, DWORD flAllocationType, DWORD flProtect);
Trường lpAddress xác định địa chỉ bắt đầu của vùng cấp phát. Nếu vùng nhớ đang để dành, địa chỉ chỉ định được làm tròn đến biên 64 KB kế tiếp. Nếu vùng nhớ đã để dành và đang được xác nhận, địa chỉ sẽ được làm tròn đến biên trang kế. Để xác định kích thước của trang, ta sử dụng hàm GetSystemInfo. Nếu biến này bằng NULL, hệ thống tự xác nhận địa chỉ vùng nhớ cấp phát.
Trường dwSize xác định số byte kích thước vùng nhớ. Nếu lpAddress bằng NULL, giá trị này sẽ được làm tròn đến biên trang kế. Nếu không, các trang cấp phát là các trang chứa một hay nhiều byte nằm trong khoảng từ lpAddress đến lpAddress+dwSize. Nghĩa là, nếu hai byte nằm ở hai trang thì cả hai trang đó đều nằm trong vùng cấp phát.
Trường flAllocationType xác định dạng cấp phát, có thể kết hợp từ các cờ :
Các cờ xác định dạng cấp phát flAllocationType.
CờÝ nghĩa
MEM_COMMITCấp phát vùng lưu trữ vật lý trong bộ nhớ hoặc đĩa. Các trang đã được cấp phát xác nhận hoặc khử cấp phát đều có thể được cấp phát lại mà không gây ra lỗi.
MEM_RESERVEĐể dành vùng không gian địa chỉ ảo của tiến trình. Không thể cấp phát vùng để dành bằng các hàm cấp phát bộ nhớ khác (malloc, GlobalAlloc, …) cho đến khi chúng được giải phóng. Chúng chỉ được cấp phát bằng hàm VirtualAlloc.
MEM_RESETÁp dụng cho Windows NT. Khi thiết lập với giá trị này, dữ liệu được xem như không quan trọng, có thể bị viết chồng lên. Ứng dụng không hoán chuyển dữ liệu từ bộ nhớ chính vào (ra) tập tin trang. Mặt khác, khi thiết lập giá trị này, hệ thống sẽ bỏ qua các giá trị của flProtect.
MEM_TOPDOWNCấp phát vùng nhớ tại địa chỉ cao nhất có thể.
Trường flProtect xác định cách thức bảo vệ truy cập vùng nhớ. Nếu các trang đã được cấp phát xác nhận, một trong các cờ sau có thể được thiết lập, kết hợp với các cờ PAGE_GUARD và PAGE_NOCACHE :
Các cờ xác định dạng bảo vệ truy cập flProtect.
CờÝ nghĩa
PAGE_READONLYChỉ cho phép đọc các trang cấp phát (không được ghi).
PAGE_READWRITECho phép truy cập đọc và ghi các trang vùng nhớ.
PAGE_EXECUTECho phép thực thi các tiến trình, nhưng không đọc và ghi.
PAGE_EXECUTE_READCho phép thực thi và đọc, nhưng không được ghi.
PAGE_EXECUTE_READWRITECho phép thực thi, đọc và ghi.
PAGE_GUARDCác trang trong vùng trở thành các trang "lính canh". Nếu ghi hoặc đọc các trang này, hệ thống sẽ phát sinh lỗi ngoại lệ STATUS_PAGE_GUARD và tắt tình trạng đó của trang “lính canh”. Xem thêm ở ví dụ trong phần 7.2.3.4.
PAGE_NOACCESSCấm truy cập (đọc, ghi, thực thi) các trang. Nếu truy cập, ta có lỗi bảo vệ chung.
PAGE_NOCACHEKhông dùng bộ nhớ đệm. Thích hợp với các chế độ bảo vệ trang hơn là NO_ACCESS.
Nếu thành công, hàm trả về địa chỉ cơ sở của các trang vùng cấp phát. Ngược lại giá trị trả về là NULL.

Giải phóng vùng nhớ ảo

Để giải phóng vùng nhớ ảo, ta dùng hàm VirtualFree. Hàm giải phóng hoặc khử cấp phát (hoặc cả hai) các trang trong không gian địa chỉ ảo của tiến trình đang gọi.
BOOL VirtualFree(LPVOID lpAddress, DWORD dwSize, DWORD dwType);
Trường lpAddress là con trỏ trỏ đến vùng các trang cần giải phóng. Nếu dwType chứa cờ MEM_RELEASE, đây phải là con trỏ trả về từ hàm VirtualAlloc.
Trường dwSize xác định số byte kích vùng nhớ cần giải phóng. Nếu dwType chứa cờ MEM_RELEASE, giá trị này cần thiết lập bằng 0. Trong các trường hợp khác, vùng ảnh hưởng sẽ là các trang có ít nhất một byte nằm trong đoạn lpAddress đến lpAddress + dwSize. Nghĩa là, nếu có 2 byte nằm ở biên hai trang khác nhau, thì cả hai trang đều được giải phóng.
Trường dwType xác định cách giải phóng, sử dụng giá trị MEM_DECOMMIT, hoặc MEM_RELEASE. Với giá trị đầu, hàm giải phóng các trang chỉ định (đã được xác nhận cấp phát). Nếu các trang chưa được cấp phát, ta vẫn có thể khử cấp phát (decommit) mà không gây ra lỗi. Với giá trị sau, hàm giải phóng vùng nhớ để dành. Trong trường hợp này, dwSize phải bằng 0, nếu không hàm thực hiện thất bại.
Nếu thành công, hàm trả về giá trị khác 0. Ngược lại, giá trị trả về là 0.
Lưu ý để giải phóng các trang, các trang phải cùng tình trạng (cấp phát hay để dành), và tất cả các trang để dành bằng hàm cấp phátVirtualAlloc cần giải phóng đồng thời. Nếu một số trang để dành ban đầu đã được xác nhận cấp phát, chúng cần được khử cấp phát trước khi gọi hàm VirtualFree để giải phóng.

Thao tác trên các trang vùng nhớ

Để xác định kích thước các trang trên máy tính, ta sử dụng hàm GetSystemInfo.
VOID GetSystemInfo(LPSYSTEM_INFO lpSystemInfo);
Trường lpSystemInfo trỏ đến cấu trúc SYSTEM_INFO chứa các thông tin hệ thống.
typedef struct _SYSTEM_INFO // sinf
{
union
{
DWORD dwOemId;
struct
{
WORD wProcessorArchitecture;
WORD wReserved;
}
};
DWORD dwPageSize;
LPVOID lpMinimumApplicationAddress;
LPVOID lpMaximumApplicationAddress;
DWORD dwActiveProcessorMask;
DWORD dwNumberOfProcessors;
DWORD dwProcessorType;
DWORD dwAllocationGranularity;
WORD wProcessorLevel;
WORD wProcessorRevision;
}SYSTEM_INFO;
Để xác định thông tin về bộ nhớ, ta chỉ khảo sát một số trường liên quan. Trường dwPageSize các định kích thước các trang theo dạng đã được cấp phát bằng hàm VirtualAlloc. Trường lpMinimumApplicationAddress trỏ đến địa chỉ vùng nhớ thấp nhất, và trường lpMaximumApplicationAddress trỏ đến địa chỉ vùng nhớ cao nhất có thể truy cập bởi các ứng dụng và thư viện liên kết động. Trường dwAllocationGranularity xác định độ phân nhỏ mà vùng nhớ ảo cấp phát. Cụ thể, hàm VirtualAlloc yêu cầu cấp phát một byte sẽ để dành một vùng không gian bộ nhớ có kích thước là dwAllocationGranularity byte.
Tiến trình có thể khoá một hay nhiều trang đã được cấp phát (xác nhận) vào vùng nhớ vật lý (RAM), ngăn chặn việc hệ thống hoán chuyển các trang vào (ra) tập tin trang bằng cách dùng hàm VirtualLock.
BOOL VirtualLock(LPVOID lpAddress, DWORD dwSize);
Để mở khoá các trang đã bị khoá, ta dùng hàm VirtualUnlock, cho phép các trang có thể được hoán chuyển vào (ra) tập tin trang trên đĩa.
BOOL VirtualUnlock(LPVOID lpAddress, DWORD dwSize);
Trường lpAddress trỏ đến địa chỉ cơ sở của vùng các trang cần được khoá. Trường dwSize xác định số byte vùng nhớ cần khoá, gồm các trang chứa tất cả các địa chỉ từ lpAddress đến lpAddress + dwSize.
Nếu thành công, giá trị trả về khác 0. Ngược lại, các hàm trả về 0.
Số trang mặc định được cấp phát tối đa là 30 trang. Tuy nhiên, chúng ta có cũng thể thay đổi số trang tối đa này.
Các trang cần mở khoá không nhất thiết phải là các trang của lần gọi khoá bằng hàm VirtualLock trước đó, nhưng đều phải là các trang đang bị khoá.
Khác với các hàm GlobalLock và LocalLock có dùng một biến đếm để đếm chuỗi các lần khoá vùng nhớ, hàm VirtualLock thì không. Do đó để mở khóa, ta chỉ cần gọi hàm VirtualUnlock một lần mà thôi.

Sử dụng các hàm quản lý bộ nhớ ảo

Trong phần này, chúng ta minh họa bằng ví dụ thực hiện thao tác để dành và xác nhận vùng nhớ, và ví dụ tạo trang "lính canh".
Trong ví dụ đầu tiên, ta sử dụng hàm VirtualAlloc và VirtualFree để cấp phát để dành và xác nhận vùng nhớ ảo. Đầu tiên, hàmVirtualAlloc được gọi để cấp phát để dành một khối các trang. Ta sử dụng giá trị NULL cho địa chỉ cơ sở, đồng nghĩa với việc để cho hệ thống tự xác định vị trí vùng cấp phát. Sau đó sử dụng lại hàm VirtualAlloc để cấp phát xác nhận các trang trong vùng để dành. Khi đó, ta cần chỉ định địa chỉ cơ sở cho các trang này.
Trong ví dụ này, ta sử dụng cấu trúc try-except để xác nhận các trang trong vùng để dành. Mỗi khi có lỗi trang xuất hiện trong quá trình thực hiện khối try, hàm lọc trước khối except sẽ được thực hiện. Nếu hàm lọc có thể cấp phát một trang khác, phần thực thi sẽ tiếp tục trong khối try tại cại điểm xuất hiện lỗi ngoại lệ. Ngược lại, các handler ngoại lệ trong khối except được thực thi.
Như một thay thế cho cấp phát động, tiến trình có thể đơn giản cấp phát xác nhận vùng còn lại thay vì chỉ để dành chúng. Tuy nhiên việc cấp phát xác nhận như vậy lại tạo nên các khối nhớ không cần thiết đáng ra được sử dụng cho các tiến trình khác.
Trong ví dụ này, ta sử dụng hàm VirtualFree để giải phóng vùng nhớ đã xác nhận lẫn vùng nhớ để dành sau khi hoàn tất công việc. Hàm này được gọi hai lần : lần đầu để khử cấp phát các trang đã được cấp phát xác nhận, và lần sau để giải phóng toàn bộ các trang dưới dạng để dành.
#define PAGELIMIT 80
#define PAGESIZE 0x1000
INT PageFaultExceptionFilter(DWORD);
VOID MyErrorExit(LPTSTR);
LPTSTR lpNxtPage;
DWORD dwPages = 0;
VOID UseDynamicVirtualAlloc(VOID)
{
LPVOID lpvBase;
LPTSTR lpPtr;
BOOL bSuccess;
DWORD i;
/* Để dành các trang trong không gian địa chỉ ảo của tiến trình */
lpvBase = VirtualAlloc(
NULL, // hệ thống tự xác định địa chỉ
PAGELIMIT*PAGESIZE,// kích thước vùng cấp phát
MEM_RESERVE, // cấp phát dưới dạng để dành
PAGE_NOACCESS); // cách thức bảo vệ = không truy cập
if (lpvBase == NULL )
MyErrorExit("VirtualAlloc reserve");
lpPtr = lpNxtPage = (LPTSTR) lpvBase;
/* Sử dụng cấu trúc xử lý ngoại lệ try-exception để truy cập các trang. Nếu lỗi trang xuất hiện, bộ lọc ngoại lệ sẽ thực thi để cấp phát xác nhận các trang kế tiếp trong khối để dành */
for (i=0; i < PAGELIMIT*PAGESIZE; i++)
{
try
{
lpPtr[i] = 'a'; // Ghi vào bộ nhớ
}
/* Nếu xuất hiện lỗi trang, cố gắng cấp phát xác nhận trang khác */
except ( PageFaultExceptionFilter(GetExceptionCode() ) )
{
/* Đoạn này chỉ thực hiện khi hàm lọc không thể xác nhận trang kế tiếp */
ExitProcess( GetLastError() );
}
}
/* Giải phóng các trang sau khi sử dụng. Đầu tiên là các trang đã được cấp phát xác nhận */
bSuccess = VirtualFree(
lpvBase, // địa chỉ cơ sở của khối nhớ
dwPages*PAGESIZE, // số byte các trang đã cấp phát
MEM_DECOMMIT); // hình thức là khử xác nhận
/* Cuối cùng, giải phóng toàn vùng nhớ (để dành) */
if (bSuccess)
{
bSuccess = VirtualFree(
lpvBase, // địa chỉ cơ sở của khối nhớ
0, // giải phóng toàn khối nhớ
MEM_RELEASE); // giải phóng (hoàn toàn)
}
}
INT PageFaultExceptionFilter(DWORD dwCode)
{
LPVOID lpvResult;
/* Nếu xuất hiện lỗi ngoại lệ, thoát chương trình */
if (dwCode != EXCEPTION_ACCESS_VIOLATION)
{
printf("exception code = %d\n", dwCode);
return EXCEPTION_EXECUTE_HANDLER;
}
printf("page fault\n");
/* Nếu các trang để dành đã được dùng thì thoát */
if (dwPages >= PAGELIMIT)
{
printf("out of pages\n");
return EXCEPTION_EXECUTE_HANDLER;
}
/* Ngược lại, cấp phát xác nhận một trang khác */
lpvResult = VirtualAlloc(
(LPVOID) lpNxtPage, // cấp phát trang tiếp theo
PAGESIZE, // số byte kích thuớc trang
MEM_COMMIT, // cấp phát xác nhận các trang
PAGE_READWRITE); // truy cập đọc-ghi
if (lpvResult == NULL )
{
printf("VirtualAlloc failed\n");
return EXCEPTION_EXECUTE_HANDLER;
}
/* Tăng trang đếm, và chuyển lpNxtPage đến trang tiếp */
dwPages++;
lpNxtPage += PAGESIZE;
/* Tiếp tục thực hiện nơi lỗi trang xuất hiện */
return EXCEPTION_CONTINUE_EXECUTION;
}
Đoạn chương trình tiếp theo thực hiện thao tác tạo trang "lính canh". Trang này cung cấp cảnh báo khi truy cập các trang vùng nhớ. Điều này rất hữu ích cho các ứng dụng cần quản lý sự mở rộng của cấu trúc dữ liệu động.
Để tạo trang “lính canh”, ta thiết lập cờ PAGE_GUARD trong hàm VirtualAlloc. Cờ này có thể dùng kết hợp với tất cả các cờ khác, trừ cờ PAGE_NOACCESS.
Nếu chương trình truy cập trang "lính canh", hệ thống sẽ phát sinh lỗi ngoại lệ STATUS_GUARD_PAGE (0x80000001). Hệ thống cũng xoá cờ PAGE_GUARD, loại bỏ tình trạng "lính canh" của trang vùng nhớ. Hệ thống sẽ không ngừng truy cập trang vùng nhớ với lỗi ngoại lệ STATUS_GUARD_PAGE.
Nếu một lỗi ngoại lệ xuất hiện trong suốt dịch vụ hệ thống, dịch vụ sẽ trả về giá trị xác định lỗi. Nếu sau đó ta truy cập lại trang này (mà chưa thiết lập lại tình trạng "lính canh"), thì sẽ không xảy ra lỗi ngoại lệ nữa.
Chương trình sau minh họa cách thực hiện của một trang lính canh, và hiện tượng xuất hiện lỗi dịch vụ hệ thống :
#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
int main()
{
LPVOID lpvAddr;
DWORD cbSize;
BOOL vLock;
LPVOID commit;
cbSize = 512; // Vùng nhớ cần cấp phát.
/* Gọi hàm cấp phát */
lpvAddr=VirtualAlloc(NULL,cbSize,MEM_RESERVE, PAGE_NOACCESS);
if(lpvAddr == NULL)
{
fprintf(stdout,"VirtualAlloc failed on
RESERVE with %ld\n", GetLastError());
}
/* Cấp phát xác nhận vùng nhớ */
commit = VirtualAlloc(NULL,cbSize,MEM_COMMIT,
PAGE_READONLY|PAGE_GUARD);
if(commit == NULL)
{
fprintf(stderr,"VirtualAlloc failed on
COMMIT with %ld\n", GetLastError());
}
else
{
fprintf(stderr,"Committed %lu bytes at address
%lp\n", cbSize,commit);
}
/* Khoá vùng nhớ đã xác nhận */
vLock = VirtualLock(commit,cbSize);
if(!vLock)
{
fprintf(stderr,"Cannot lock at %lp,
error = %lu\n", commit, GetLastError());
}
else fprintf(stderr,"Lock Achieved at %lp\n",commit);
/* Khoá vùng nhớ lần nữa */
vLock = VirtualLock(commit,cbSize);
if(!vLock)
{
fprintf(stderr,"Cannot get 2nd lock at %lp,
error = %lu\n", commit, GetLastError());
}
else fprintf(stderr,"2nd Lock Achieved at %lp\n",commit);
}
Chương trình trên cho kết quả tương tự kết quả sau :
Committed 512 bytes at address 003F0000
Cannot lock at 003F0000, error = 0x80000001
2nd Lock Achieved at 003F0000
Chú ý : Lần khoá thứ nhất thất bại, tạo lỗi ngoại lệ STATUS_GUARD_PAGE. Tuy nhiên, trong lần khoá thứ hai, hàm thực hiện thành công, do hệ thống đã loại bỏ tình trạng "lính canh" của trang.

Posted in:

0 Comment:

Đăng nhận xét

Thank you for your comments!