On 11/9/22 3:34 PM, David Hildenbrand wrote: > On 09.11.22 11:23, Muhammad Usama Anjum wrote: [...] >> Some non-dirty pages get marked as dirty because of the kernel's >> internal activity (such as VMA merging as soft-dirty bit difference isn't >> considered while deciding to merge VMAs). The dirty bit of the pages is >> stored in the VMA flags and in the per page flags. If any of these two bits >> are set, the page is considered to be soft dirty. Suppose you have cleared >> the soft dirty bit of half of VMA which will be done by splitting the VMA >> and clearing soft dirty bit flag in the half VMA and the pages in it. Now >> kernel may decide to merge the VMAs again. So the half VMA becomes dirty >> again. This splitting/merging costs performance. The application receives >> a lot of pages which aren't dirty in reality but marked as dirty. >> Performance is lost again here. Also sometimes user doesn't want the newly >> allocated memory to be marked as dirty. PAGEMAP_NO_REUSED_REGIONS flag >> solves both the problems. It is used to not depend on the soft dirty flag >> in the VMA flags. So VMA splitting and merging doesn't happen. It only >> depends on the soft dirty bit of the individual pages. Thus by using this >> flag, there may be a scenerio such that the new memory regions which are >> just created, doesn't look dirty when seen with the IOCTL, but look dirty >> when seen from procfs. This seems okay as the user of this flag know the >> implication of using it. The soft-dirtiness is stored in the PTE. VMA is marked dirty to store the dirtiness for reused regions. Clearing the soft-dirty status of whole process is straight forward. When we want to clear/monitor the soft-dirtiness of a part of the virtual memory, there is a lot of internal noise. We don't want the non-dirty pages to become dirty because of how the soft-dirty feature has been working. Soft-dirty feature wasn't being used the way we want to use now. While monitoring a part of memory, it is not acceptable to get non-dirty pages as dirty. Non-dirty pages become dirty when the two VMAs are merged without considering if they both are dirty or not (34228d473efe). To monitor changes over the memory, sometimes VMAs are split to clear the soft-dirty bit in the VMA flags. But sometimes kernel decide to merge them backup. It is so waste of resources. To keep things consistent, the default behavior of the IOCTL is to output even the extra non-dirty pages as dirty from the kernel noise. A optional PAGEMAP_NO_REUSED_REGIONS flag is added for those use cases which aren't tolerant of extra non-dirty pages. This flag can be considered as something which is by-passing the already present buggy implementation in the kernel. It is not buggy per say as the issue can be solved if we don't allow the two VMA which have different soft-dirty bits to get merged. But we are allowing that so that the total number of VMAs doesn't increase. This was acceptable at the time, but now with the use case of monitoring a part of memory for soft-dirty doesn't want this merging. So either we need to revert 34228d473efe and PAGEMAP_NO_REUSED_REGIONS flag will not be needed or we should allow PAGEMAP_NO_REUSED_REGIONS or similar mechanism to ignore the extra dirty pages which aren't dirty in reality. When PAGEMAP_NO_REUSED_REGIONS flag is used, only the PTEs are checked to find if the pages are dirty. So re-used regions cannot be detected. This has the only side-effect of not checking the VMAs. So this is limitation of using this flag which should be acceptable in the current state of code. This limitation is okay for the users as they can clear the soft-dirty bit of the VMA before starting to monitor a range of memory for soft-dirtiness. > Please separate that part out from the other changes; I am still not > convinced that we want this and what the semantical implications are. > > Let's take a look at an example: can_change_pte_writable() > > /* Do we need write faults for softdirty tracking? */ > if (vma_soft_dirty_enabled(vma) && !pte_soft_dirty(pte)) > return false; > > We care about PTE softdirty tracking, if it is enabled for the VMA. > Tracking is enabled if: vma_soft_dirty_enabled() > > /* > * Soft-dirty is kind of special: its tracking is enabled when > * the vma flags not set. > */ > return !(vma->vm_flags & VM_SOFTDIRTY); > > Consequently, if VM_SOFTDIRTY is set, we are not considering the soft_dirty > PTE bits accordingly. Sorry, I'm unable to completely grasp the meaning of the example. We have followed clear_refs_write() to write the soft-dirty bit clearing code in the current patch. Dirtiness of the VMA and the PTE may be set independently. Newer allocated memory has dirty bit set in the VMA. When something is written the memory, the soft dirty bit is set in the PTEs as well regardless if the soft dirty bit is set in the VMA or not. > > > I'd suggest moving forward without this controversial > PAGEMAP_NO_REUSED_REGIONS functionality for now, and preparing it as a > clear add-on we can discuss separately.Like I've described above, I've only added this flag to not get the non-dirty pages as dirty. Can there be some alternative to adding this flag? Please suggest. -- BR, Muhammad Usama Anjum
