test_hmm.c 38 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * This is a module to test the HMM (Heterogeneous Memory Management)
  4. * mirror and zone device private memory migration APIs of the kernel.
  5. * Userspace programs can register with the driver to mirror their own address
  6. * space and can use the device to read/write any valid virtual address.
  7. */
  8. #include <linux/init.h>
  9. #include <linux/fs.h>
  10. #include <linux/mm.h>
  11. #include <linux/module.h>
  12. #include <linux/kernel.h>
  13. #include <linux/cdev.h>
  14. #include <linux/device.h>
  15. #include <linux/memremap.h>
  16. #include <linux/mutex.h>
  17. #include <linux/rwsem.h>
  18. #include <linux/sched.h>
  19. #include <linux/slab.h>
  20. #include <linux/highmem.h>
  21. #include <linux/delay.h>
  22. #include <linux/pagemap.h>
  23. #include <linux/hmm.h>
  24. #include <linux/vmalloc.h>
  25. #include <linux/swap.h>
  26. #include <linux/swapops.h>
  27. #include <linux/sched/mm.h>
  28. #include <linux/platform_device.h>
  29. #include <linux/rmap.h>
  30. #include <linux/mmu_notifier.h>
  31. #include <linux/migrate.h>
  32. #include "test_hmm_uapi.h"
  33. #define DMIRROR_NDEVICES 4
  34. #define DMIRROR_RANGE_FAULT_TIMEOUT 1000
  35. #define DEVMEM_CHUNK_SIZE (256 * 1024 * 1024U)
  36. #define DEVMEM_CHUNKS_RESERVE 16
  37. /*
  38. * For device_private pages, dpage is just a dummy struct page
  39. * representing a piece of device memory. dmirror_devmem_alloc_page
  40. * allocates a real system memory page as backing storage to fake a
  41. * real device. zone_device_data points to that backing page. But
  42. * for device_coherent memory, the struct page represents real
  43. * physical CPU-accessible memory that we can use directly.
  44. */
  45. #define BACKING_PAGE(page) (is_device_private_page((page)) ? \
  46. (page)->zone_device_data : (page))
  47. static unsigned long spm_addr_dev0;
  48. module_param(spm_addr_dev0, long, 0644);
  49. MODULE_PARM_DESC(spm_addr_dev0,
  50. "Specify start address for SPM (special purpose memory) used for device 0. By setting this Coherent device type will be used. Make sure spm_addr_dev1 is set too. Minimum SPM size should be DEVMEM_CHUNK_SIZE.");
  51. static unsigned long spm_addr_dev1;
  52. module_param(spm_addr_dev1, long, 0644);
  53. MODULE_PARM_DESC(spm_addr_dev1,
  54. "Specify start address for SPM (special purpose memory) used for device 1. By setting this Coherent device type will be used. Make sure spm_addr_dev0 is set too. Minimum SPM size should be DEVMEM_CHUNK_SIZE.");
  55. static const struct dev_pagemap_ops dmirror_devmem_ops;
  56. static const struct mmu_interval_notifier_ops dmirror_min_ops;
  57. static dev_t dmirror_dev;
  58. struct dmirror_device;
  59. struct dmirror_bounce {
  60. void *ptr;
  61. unsigned long size;
  62. unsigned long addr;
  63. unsigned long cpages;
  64. };
  65. #define DPT_XA_TAG_ATOMIC 1UL
  66. #define DPT_XA_TAG_WRITE 3UL
  67. /*
  68. * Data structure to track address ranges and register for mmu interval
  69. * notifier updates.
  70. */
  71. struct dmirror_interval {
  72. struct mmu_interval_notifier notifier;
  73. struct dmirror *dmirror;
  74. };
  75. /*
  76. * Data attached to the open device file.
  77. * Note that it might be shared after a fork().
  78. */
  79. struct dmirror {
  80. struct dmirror_device *mdevice;
  81. struct xarray pt;
  82. struct mmu_interval_notifier notifier;
  83. struct mutex mutex;
  84. };
  85. /*
  86. * ZONE_DEVICE pages for migration and simulating device memory.
  87. */
  88. struct dmirror_chunk {
  89. struct dev_pagemap pagemap;
  90. struct dmirror_device *mdevice;
  91. bool remove;
  92. };
  93. /*
  94. * Per device data.
  95. */
  96. struct dmirror_device {
  97. struct cdev cdevice;
  98. unsigned int zone_device_type;
  99. struct device device;
  100. unsigned int devmem_capacity;
  101. unsigned int devmem_count;
  102. struct dmirror_chunk **devmem_chunks;
  103. struct mutex devmem_lock; /* protects the above */
  104. unsigned long calloc;
  105. unsigned long cfree;
  106. struct page *free_pages;
  107. spinlock_t lock; /* protects the above */
  108. };
  109. static struct dmirror_device dmirror_devices[DMIRROR_NDEVICES];
  110. static int dmirror_bounce_init(struct dmirror_bounce *bounce,
  111. unsigned long addr,
  112. unsigned long size)
  113. {
  114. bounce->addr = addr;
  115. bounce->size = size;
  116. bounce->cpages = 0;
  117. bounce->ptr = vmalloc(size);
  118. if (!bounce->ptr)
  119. return -ENOMEM;
  120. return 0;
  121. }
  122. static bool dmirror_is_private_zone(struct dmirror_device *mdevice)
  123. {
  124. return (mdevice->zone_device_type ==
  125. HMM_DMIRROR_MEMORY_DEVICE_PRIVATE) ? true : false;
  126. }
  127. static enum migrate_vma_direction
  128. dmirror_select_device(struct dmirror *dmirror)
  129. {
  130. return (dmirror->mdevice->zone_device_type ==
  131. HMM_DMIRROR_MEMORY_DEVICE_PRIVATE) ?
  132. MIGRATE_VMA_SELECT_DEVICE_PRIVATE :
  133. MIGRATE_VMA_SELECT_DEVICE_COHERENT;
  134. }
  135. static void dmirror_bounce_fini(struct dmirror_bounce *bounce)
  136. {
  137. vfree(bounce->ptr);
  138. }
  139. static int dmirror_fops_open(struct inode *inode, struct file *filp)
  140. {
  141. struct cdev *cdev = inode->i_cdev;
  142. struct dmirror *dmirror;
  143. int ret;
  144. /* Mirror this process address space */
  145. dmirror = kzalloc(sizeof(*dmirror), GFP_KERNEL);
  146. if (dmirror == NULL)
  147. return -ENOMEM;
  148. dmirror->mdevice = container_of(cdev, struct dmirror_device, cdevice);
  149. mutex_init(&dmirror->mutex);
  150. xa_init(&dmirror->pt);
  151. ret = mmu_interval_notifier_insert(&dmirror->notifier, current->mm,
  152. 0, ULONG_MAX & PAGE_MASK, &dmirror_min_ops);
  153. if (ret) {
  154. kfree(dmirror);
  155. return ret;
  156. }
  157. filp->private_data = dmirror;
  158. return 0;
  159. }
  160. static int dmirror_fops_release(struct inode *inode, struct file *filp)
  161. {
  162. struct dmirror *dmirror = filp->private_data;
  163. mmu_interval_notifier_remove(&dmirror->notifier);
  164. xa_destroy(&dmirror->pt);
  165. kfree(dmirror);
  166. return 0;
  167. }
  168. static struct dmirror_chunk *dmirror_page_to_chunk(struct page *page)
  169. {
  170. return container_of(page->pgmap, struct dmirror_chunk, pagemap);
  171. }
  172. static struct dmirror_device *dmirror_page_to_device(struct page *page)
  173. {
  174. return dmirror_page_to_chunk(page)->mdevice;
  175. }
  176. static int dmirror_do_fault(struct dmirror *dmirror, struct hmm_range *range)
  177. {
  178. unsigned long *pfns = range->hmm_pfns;
  179. unsigned long pfn;
  180. for (pfn = (range->start >> PAGE_SHIFT);
  181. pfn < (range->end >> PAGE_SHIFT);
  182. pfn++, pfns++) {
  183. struct page *page;
  184. void *entry;
  185. /*
  186. * Since we asked for hmm_range_fault() to populate pages,
  187. * it shouldn't return an error entry on success.
  188. */
  189. WARN_ON(*pfns & HMM_PFN_ERROR);
  190. WARN_ON(!(*pfns & HMM_PFN_VALID));
  191. page = hmm_pfn_to_page(*pfns);
  192. WARN_ON(!page);
  193. entry = page;
  194. if (*pfns & HMM_PFN_WRITE)
  195. entry = xa_tag_pointer(entry, DPT_XA_TAG_WRITE);
  196. else if (WARN_ON(range->default_flags & HMM_PFN_WRITE))
  197. return -EFAULT;
  198. entry = xa_store(&dmirror->pt, pfn, entry, GFP_ATOMIC);
  199. if (xa_is_err(entry))
  200. return xa_err(entry);
  201. }
  202. return 0;
  203. }
  204. static void dmirror_do_update(struct dmirror *dmirror, unsigned long start,
  205. unsigned long end)
  206. {
  207. unsigned long pfn;
  208. void *entry;
  209. /*
  210. * The XArray doesn't hold references to pages since it relies on
  211. * the mmu notifier to clear page pointers when they become stale.
  212. * Therefore, it is OK to just clear the entry.
  213. */
  214. xa_for_each_range(&dmirror->pt, pfn, entry, start >> PAGE_SHIFT,
  215. end >> PAGE_SHIFT)
  216. xa_erase(&dmirror->pt, pfn);
  217. }
  218. static bool dmirror_interval_invalidate(struct mmu_interval_notifier *mni,
  219. const struct mmu_notifier_range *range,
  220. unsigned long cur_seq)
  221. {
  222. struct dmirror *dmirror = container_of(mni, struct dmirror, notifier);
  223. /*
  224. * Ignore invalidation callbacks for device private pages since
  225. * the invalidation is handled as part of the migration process.
  226. */
  227. if (range->event == MMU_NOTIFY_MIGRATE &&
  228. range->owner == dmirror->mdevice)
  229. return true;
  230. if (mmu_notifier_range_blockable(range))
  231. mutex_lock(&dmirror->mutex);
  232. else if (!mutex_trylock(&dmirror->mutex))
  233. return false;
  234. mmu_interval_set_seq(mni, cur_seq);
  235. dmirror_do_update(dmirror, range->start, range->end);
  236. mutex_unlock(&dmirror->mutex);
  237. return true;
  238. }
  239. static const struct mmu_interval_notifier_ops dmirror_min_ops = {
  240. .invalidate = dmirror_interval_invalidate,
  241. };
  242. static int dmirror_range_fault(struct dmirror *dmirror,
  243. struct hmm_range *range)
  244. {
  245. struct mm_struct *mm = dmirror->notifier.mm;
  246. unsigned long timeout =
  247. jiffies + msecs_to_jiffies(HMM_RANGE_DEFAULT_TIMEOUT);
  248. int ret;
  249. while (true) {
  250. if (time_after(jiffies, timeout)) {
  251. ret = -EBUSY;
  252. goto out;
  253. }
  254. range->notifier_seq = mmu_interval_read_begin(range->notifier);
  255. mmap_read_lock(mm);
  256. ret = hmm_range_fault(range);
  257. mmap_read_unlock(mm);
  258. if (ret) {
  259. if (ret == -EBUSY)
  260. continue;
  261. goto out;
  262. }
  263. mutex_lock(&dmirror->mutex);
  264. if (mmu_interval_read_retry(range->notifier,
  265. range->notifier_seq)) {
  266. mutex_unlock(&dmirror->mutex);
  267. continue;
  268. }
  269. break;
  270. }
  271. ret = dmirror_do_fault(dmirror, range);
  272. mutex_unlock(&dmirror->mutex);
  273. out:
  274. return ret;
  275. }
  276. static int dmirror_fault(struct dmirror *dmirror, unsigned long start,
  277. unsigned long end, bool write)
  278. {
  279. struct mm_struct *mm = dmirror->notifier.mm;
  280. unsigned long addr;
  281. unsigned long pfns[64];
  282. struct hmm_range range = {
  283. .notifier = &dmirror->notifier,
  284. .hmm_pfns = pfns,
  285. .pfn_flags_mask = 0,
  286. .default_flags =
  287. HMM_PFN_REQ_FAULT | (write ? HMM_PFN_REQ_WRITE : 0),
  288. .dev_private_owner = dmirror->mdevice,
  289. };
  290. int ret = 0;
  291. /* Since the mm is for the mirrored process, get a reference first. */
  292. if (!mmget_not_zero(mm))
  293. return 0;
  294. for (addr = start; addr < end; addr = range.end) {
  295. range.start = addr;
  296. range.end = min(addr + (ARRAY_SIZE(pfns) << PAGE_SHIFT), end);
  297. ret = dmirror_range_fault(dmirror, &range);
  298. if (ret)
  299. break;
  300. }
  301. mmput(mm);
  302. return ret;
  303. }
  304. static int dmirror_do_read(struct dmirror *dmirror, unsigned long start,
  305. unsigned long end, struct dmirror_bounce *bounce)
  306. {
  307. unsigned long pfn;
  308. void *ptr;
  309. ptr = bounce->ptr + ((start - bounce->addr) & PAGE_MASK);
  310. for (pfn = start >> PAGE_SHIFT; pfn < (end >> PAGE_SHIFT); pfn++) {
  311. void *entry;
  312. struct page *page;
  313. void *tmp;
  314. entry = xa_load(&dmirror->pt, pfn);
  315. page = xa_untag_pointer(entry);
  316. if (!page)
  317. return -ENOENT;
  318. tmp = kmap(page);
  319. memcpy(ptr, tmp, PAGE_SIZE);
  320. kunmap(page);
  321. ptr += PAGE_SIZE;
  322. bounce->cpages++;
  323. }
  324. return 0;
  325. }
  326. static int dmirror_read(struct dmirror *dmirror, struct hmm_dmirror_cmd *cmd)
  327. {
  328. struct dmirror_bounce bounce;
  329. unsigned long start, end;
  330. unsigned long size = cmd->npages << PAGE_SHIFT;
  331. int ret;
  332. start = cmd->addr;
  333. end = start + size;
  334. if (end < start)
  335. return -EINVAL;
  336. ret = dmirror_bounce_init(&bounce, start, size);
  337. if (ret)
  338. return ret;
  339. while (1) {
  340. mutex_lock(&dmirror->mutex);
  341. ret = dmirror_do_read(dmirror, start, end, &bounce);
  342. mutex_unlock(&dmirror->mutex);
  343. if (ret != -ENOENT)
  344. break;
  345. start = cmd->addr + (bounce.cpages << PAGE_SHIFT);
  346. ret = dmirror_fault(dmirror, start, end, false);
  347. if (ret)
  348. break;
  349. cmd->faults++;
  350. }
  351. if (ret == 0) {
  352. if (copy_to_user(u64_to_user_ptr(cmd->ptr), bounce.ptr,
  353. bounce.size))
  354. ret = -EFAULT;
  355. }
  356. cmd->cpages = bounce.cpages;
  357. dmirror_bounce_fini(&bounce);
  358. return ret;
  359. }
  360. static int dmirror_do_write(struct dmirror *dmirror, unsigned long start,
  361. unsigned long end, struct dmirror_bounce *bounce)
  362. {
  363. unsigned long pfn;
  364. void *ptr;
  365. ptr = bounce->ptr + ((start - bounce->addr) & PAGE_MASK);
  366. for (pfn = start >> PAGE_SHIFT; pfn < (end >> PAGE_SHIFT); pfn++) {
  367. void *entry;
  368. struct page *page;
  369. void *tmp;
  370. entry = xa_load(&dmirror->pt, pfn);
  371. page = xa_untag_pointer(entry);
  372. if (!page || xa_pointer_tag(entry) != DPT_XA_TAG_WRITE)
  373. return -ENOENT;
  374. tmp = kmap(page);
  375. memcpy(tmp, ptr, PAGE_SIZE);
  376. kunmap(page);
  377. ptr += PAGE_SIZE;
  378. bounce->cpages++;
  379. }
  380. return 0;
  381. }
  382. static int dmirror_write(struct dmirror *dmirror, struct hmm_dmirror_cmd *cmd)
  383. {
  384. struct dmirror_bounce bounce;
  385. unsigned long start, end;
  386. unsigned long size = cmd->npages << PAGE_SHIFT;
  387. int ret;
  388. start = cmd->addr;
  389. end = start + size;
  390. if (end < start)
  391. return -EINVAL;
  392. ret = dmirror_bounce_init(&bounce, start, size);
  393. if (ret)
  394. return ret;
  395. if (copy_from_user(bounce.ptr, u64_to_user_ptr(cmd->ptr),
  396. bounce.size)) {
  397. ret = -EFAULT;
  398. goto fini;
  399. }
  400. while (1) {
  401. mutex_lock(&dmirror->mutex);
  402. ret = dmirror_do_write(dmirror, start, end, &bounce);
  403. mutex_unlock(&dmirror->mutex);
  404. if (ret != -ENOENT)
  405. break;
  406. start = cmd->addr + (bounce.cpages << PAGE_SHIFT);
  407. ret = dmirror_fault(dmirror, start, end, true);
  408. if (ret)
  409. break;
  410. cmd->faults++;
  411. }
  412. fini:
  413. cmd->cpages = bounce.cpages;
  414. dmirror_bounce_fini(&bounce);
  415. return ret;
  416. }
  417. static int dmirror_allocate_chunk(struct dmirror_device *mdevice,
  418. struct page **ppage)
  419. {
  420. struct dmirror_chunk *devmem;
  421. struct resource *res = NULL;
  422. unsigned long pfn;
  423. unsigned long pfn_first;
  424. unsigned long pfn_last;
  425. void *ptr;
  426. int ret = -ENOMEM;
  427. devmem = kzalloc(sizeof(*devmem), GFP_KERNEL);
  428. if (!devmem)
  429. return ret;
  430. switch (mdevice->zone_device_type) {
  431. case HMM_DMIRROR_MEMORY_DEVICE_PRIVATE:
  432. res = request_free_mem_region(&iomem_resource, DEVMEM_CHUNK_SIZE,
  433. "hmm_dmirror");
  434. if (IS_ERR_OR_NULL(res))
  435. goto err_devmem;
  436. devmem->pagemap.range.start = res->start;
  437. devmem->pagemap.range.end = res->end;
  438. devmem->pagemap.type = MEMORY_DEVICE_PRIVATE;
  439. break;
  440. case HMM_DMIRROR_MEMORY_DEVICE_COHERENT:
  441. devmem->pagemap.range.start = (MINOR(mdevice->cdevice.dev) - 2) ?
  442. spm_addr_dev0 :
  443. spm_addr_dev1;
  444. devmem->pagemap.range.end = devmem->pagemap.range.start +
  445. DEVMEM_CHUNK_SIZE - 1;
  446. devmem->pagemap.type = MEMORY_DEVICE_COHERENT;
  447. break;
  448. default:
  449. ret = -EINVAL;
  450. goto err_devmem;
  451. }
  452. devmem->pagemap.nr_range = 1;
  453. devmem->pagemap.ops = &dmirror_devmem_ops;
  454. devmem->pagemap.owner = mdevice;
  455. mutex_lock(&mdevice->devmem_lock);
  456. if (mdevice->devmem_count == mdevice->devmem_capacity) {
  457. struct dmirror_chunk **new_chunks;
  458. unsigned int new_capacity;
  459. new_capacity = mdevice->devmem_capacity +
  460. DEVMEM_CHUNKS_RESERVE;
  461. new_chunks = krealloc(mdevice->devmem_chunks,
  462. sizeof(new_chunks[0]) * new_capacity,
  463. GFP_KERNEL);
  464. if (!new_chunks)
  465. goto err_release;
  466. mdevice->devmem_capacity = new_capacity;
  467. mdevice->devmem_chunks = new_chunks;
  468. }
  469. ptr = memremap_pages(&devmem->pagemap, numa_node_id());
  470. if (IS_ERR_OR_NULL(ptr)) {
  471. if (ptr)
  472. ret = PTR_ERR(ptr);
  473. else
  474. ret = -EFAULT;
  475. goto err_release;
  476. }
  477. devmem->mdevice = mdevice;
  478. pfn_first = devmem->pagemap.range.start >> PAGE_SHIFT;
  479. pfn_last = pfn_first + (range_len(&devmem->pagemap.range) >> PAGE_SHIFT);
  480. mdevice->devmem_chunks[mdevice->devmem_count++] = devmem;
  481. mutex_unlock(&mdevice->devmem_lock);
  482. pr_info("added new %u MB chunk (total %u chunks, %u MB) PFNs [0x%lx 0x%lx)\n",
  483. DEVMEM_CHUNK_SIZE / (1024 * 1024),
  484. mdevice->devmem_count,
  485. mdevice->devmem_count * (DEVMEM_CHUNK_SIZE / (1024 * 1024)),
  486. pfn_first, pfn_last);
  487. spin_lock(&mdevice->lock);
  488. for (pfn = pfn_first; pfn < pfn_last; pfn++) {
  489. struct page *page = pfn_to_page(pfn);
  490. page->zone_device_data = mdevice->free_pages;
  491. mdevice->free_pages = page;
  492. }
  493. if (ppage) {
  494. *ppage = mdevice->free_pages;
  495. mdevice->free_pages = (*ppage)->zone_device_data;
  496. mdevice->calloc++;
  497. }
  498. spin_unlock(&mdevice->lock);
  499. return 0;
  500. err_release:
  501. mutex_unlock(&mdevice->devmem_lock);
  502. if (res && devmem->pagemap.type == MEMORY_DEVICE_PRIVATE)
  503. release_mem_region(devmem->pagemap.range.start,
  504. range_len(&devmem->pagemap.range));
  505. err_devmem:
  506. kfree(devmem);
  507. return ret;
  508. }
  509. static struct page *dmirror_devmem_alloc_page(struct dmirror_device *mdevice)
  510. {
  511. struct page *dpage = NULL;
  512. struct page *rpage = NULL;
  513. /*
  514. * For ZONE_DEVICE private type, this is a fake device so we allocate
  515. * real system memory to store our device memory.
  516. * For ZONE_DEVICE coherent type we use the actual dpage to store the
  517. * data and ignore rpage.
  518. */
  519. if (dmirror_is_private_zone(mdevice)) {
  520. rpage = alloc_page(GFP_HIGHUSER);
  521. if (!rpage)
  522. return NULL;
  523. }
  524. spin_lock(&mdevice->lock);
  525. if (mdevice->free_pages) {
  526. dpage = mdevice->free_pages;
  527. mdevice->free_pages = dpage->zone_device_data;
  528. mdevice->calloc++;
  529. spin_unlock(&mdevice->lock);
  530. } else {
  531. spin_unlock(&mdevice->lock);
  532. if (dmirror_allocate_chunk(mdevice, &dpage))
  533. goto error;
  534. }
  535. zone_device_page_init(dpage);
  536. dpage->zone_device_data = rpage;
  537. return dpage;
  538. error:
  539. if (rpage)
  540. __free_page(rpage);
  541. return NULL;
  542. }
  543. static void dmirror_migrate_alloc_and_copy(struct migrate_vma *args,
  544. struct dmirror *dmirror)
  545. {
  546. struct dmirror_device *mdevice = dmirror->mdevice;
  547. const unsigned long *src = args->src;
  548. unsigned long *dst = args->dst;
  549. unsigned long addr;
  550. for (addr = args->start; addr < args->end; addr += PAGE_SIZE,
  551. src++, dst++) {
  552. struct page *spage;
  553. struct page *dpage;
  554. struct page *rpage;
  555. if (!(*src & MIGRATE_PFN_MIGRATE))
  556. continue;
  557. /*
  558. * Note that spage might be NULL which is OK since it is an
  559. * unallocated pte_none() or read-only zero page.
  560. */
  561. spage = migrate_pfn_to_page(*src);
  562. if (WARN(spage && is_zone_device_page(spage),
  563. "page already in device spage pfn: 0x%lx\n",
  564. page_to_pfn(spage)))
  565. continue;
  566. dpage = dmirror_devmem_alloc_page(mdevice);
  567. if (!dpage)
  568. continue;
  569. rpage = BACKING_PAGE(dpage);
  570. if (spage)
  571. copy_highpage(rpage, spage);
  572. else
  573. clear_highpage(rpage);
  574. /*
  575. * Normally, a device would use the page->zone_device_data to
  576. * point to the mirror but here we use it to hold the page for
  577. * the simulated device memory and that page holds the pointer
  578. * to the mirror.
  579. */
  580. rpage->zone_device_data = dmirror;
  581. pr_debug("migrating from sys to dev pfn src: 0x%lx pfn dst: 0x%lx\n",
  582. page_to_pfn(spage), page_to_pfn(dpage));
  583. *dst = migrate_pfn(page_to_pfn(dpage));
  584. if ((*src & MIGRATE_PFN_WRITE) ||
  585. (!spage && args->vma->vm_flags & VM_WRITE))
  586. *dst |= MIGRATE_PFN_WRITE;
  587. }
  588. }
  589. static int dmirror_check_atomic(struct dmirror *dmirror, unsigned long start,
  590. unsigned long end)
  591. {
  592. unsigned long pfn;
  593. for (pfn = start >> PAGE_SHIFT; pfn < (end >> PAGE_SHIFT); pfn++) {
  594. void *entry;
  595. entry = xa_load(&dmirror->pt, pfn);
  596. if (xa_pointer_tag(entry) == DPT_XA_TAG_ATOMIC)
  597. return -EPERM;
  598. }
  599. return 0;
  600. }
  601. static int dmirror_atomic_map(unsigned long start, unsigned long end,
  602. struct page **pages, struct dmirror *dmirror)
  603. {
  604. unsigned long pfn, mapped = 0;
  605. int i;
  606. /* Map the migrated pages into the device's page tables. */
  607. mutex_lock(&dmirror->mutex);
  608. for (i = 0, pfn = start >> PAGE_SHIFT; pfn < (end >> PAGE_SHIFT); pfn++, i++) {
  609. void *entry;
  610. if (!pages[i])
  611. continue;
  612. entry = pages[i];
  613. entry = xa_tag_pointer(entry, DPT_XA_TAG_ATOMIC);
  614. entry = xa_store(&dmirror->pt, pfn, entry, GFP_ATOMIC);
  615. if (xa_is_err(entry)) {
  616. mutex_unlock(&dmirror->mutex);
  617. return xa_err(entry);
  618. }
  619. mapped++;
  620. }
  621. mutex_unlock(&dmirror->mutex);
  622. return mapped;
  623. }
  624. static int dmirror_migrate_finalize_and_map(struct migrate_vma *args,
  625. struct dmirror *dmirror)
  626. {
  627. unsigned long start = args->start;
  628. unsigned long end = args->end;
  629. const unsigned long *src = args->src;
  630. const unsigned long *dst = args->dst;
  631. unsigned long pfn;
  632. /* Map the migrated pages into the device's page tables. */
  633. mutex_lock(&dmirror->mutex);
  634. for (pfn = start >> PAGE_SHIFT; pfn < (end >> PAGE_SHIFT); pfn++,
  635. src++, dst++) {
  636. struct page *dpage;
  637. void *entry;
  638. if (!(*src & MIGRATE_PFN_MIGRATE))
  639. continue;
  640. dpage = migrate_pfn_to_page(*dst);
  641. if (!dpage)
  642. continue;
  643. entry = BACKING_PAGE(dpage);
  644. if (*dst & MIGRATE_PFN_WRITE)
  645. entry = xa_tag_pointer(entry, DPT_XA_TAG_WRITE);
  646. entry = xa_store(&dmirror->pt, pfn, entry, GFP_ATOMIC);
  647. if (xa_is_err(entry)) {
  648. mutex_unlock(&dmirror->mutex);
  649. return xa_err(entry);
  650. }
  651. }
  652. mutex_unlock(&dmirror->mutex);
  653. return 0;
  654. }
  655. static int dmirror_exclusive(struct dmirror *dmirror,
  656. struct hmm_dmirror_cmd *cmd)
  657. {
  658. unsigned long start, end, addr;
  659. unsigned long size = cmd->npages << PAGE_SHIFT;
  660. struct mm_struct *mm = dmirror->notifier.mm;
  661. struct page *pages[64];
  662. struct dmirror_bounce bounce;
  663. unsigned long next;
  664. int ret;
  665. start = cmd->addr;
  666. end = start + size;
  667. if (end < start)
  668. return -EINVAL;
  669. /* Since the mm is for the mirrored process, get a reference first. */
  670. if (!mmget_not_zero(mm))
  671. return -EINVAL;
  672. mmap_read_lock(mm);
  673. for (addr = start; addr < end; addr = next) {
  674. unsigned long mapped = 0;
  675. int i;
  676. if (end < addr + (ARRAY_SIZE(pages) << PAGE_SHIFT))
  677. next = end;
  678. else
  679. next = addr + (ARRAY_SIZE(pages) << PAGE_SHIFT);
  680. ret = make_device_exclusive_range(mm, addr, next, pages, NULL);
  681. /*
  682. * Do dmirror_atomic_map() iff all pages are marked for
  683. * exclusive access to avoid accessing uninitialized
  684. * fields of pages.
  685. */
  686. if (ret == (next - addr) >> PAGE_SHIFT)
  687. mapped = dmirror_atomic_map(addr, next, pages, dmirror);
  688. for (i = 0; i < ret; i++) {
  689. if (pages[i]) {
  690. unlock_page(pages[i]);
  691. put_page(pages[i]);
  692. }
  693. }
  694. if (addr + (mapped << PAGE_SHIFT) < next) {
  695. mmap_read_unlock(mm);
  696. mmput(mm);
  697. return -EBUSY;
  698. }
  699. }
  700. mmap_read_unlock(mm);
  701. mmput(mm);
  702. /* Return the migrated data for verification. */
  703. ret = dmirror_bounce_init(&bounce, start, size);
  704. if (ret)
  705. return ret;
  706. mutex_lock(&dmirror->mutex);
  707. ret = dmirror_do_read(dmirror, start, end, &bounce);
  708. mutex_unlock(&dmirror->mutex);
  709. if (ret == 0) {
  710. if (copy_to_user(u64_to_user_ptr(cmd->ptr), bounce.ptr,
  711. bounce.size))
  712. ret = -EFAULT;
  713. }
  714. cmd->cpages = bounce.cpages;
  715. dmirror_bounce_fini(&bounce);
  716. return ret;
  717. }
  718. static vm_fault_t dmirror_devmem_fault_alloc_and_copy(struct migrate_vma *args,
  719. struct dmirror *dmirror)
  720. {
  721. const unsigned long *src = args->src;
  722. unsigned long *dst = args->dst;
  723. unsigned long start = args->start;
  724. unsigned long end = args->end;
  725. unsigned long addr;
  726. for (addr = start; addr < end; addr += PAGE_SIZE,
  727. src++, dst++) {
  728. struct page *dpage, *spage;
  729. spage = migrate_pfn_to_page(*src);
  730. if (!spage || !(*src & MIGRATE_PFN_MIGRATE))
  731. continue;
  732. if (WARN_ON(!is_device_private_page(spage) &&
  733. !is_device_coherent_page(spage)))
  734. continue;
  735. spage = BACKING_PAGE(spage);
  736. dpage = alloc_page_vma(GFP_HIGHUSER_MOVABLE, args->vma, addr);
  737. if (!dpage)
  738. continue;
  739. pr_debug("migrating from dev to sys pfn src: 0x%lx pfn dst: 0x%lx\n",
  740. page_to_pfn(spage), page_to_pfn(dpage));
  741. lock_page(dpage);
  742. xa_erase(&dmirror->pt, addr >> PAGE_SHIFT);
  743. copy_highpage(dpage, spage);
  744. *dst = migrate_pfn(page_to_pfn(dpage));
  745. if (*src & MIGRATE_PFN_WRITE)
  746. *dst |= MIGRATE_PFN_WRITE;
  747. }
  748. return 0;
  749. }
  750. static unsigned long
  751. dmirror_successful_migrated_pages(struct migrate_vma *migrate)
  752. {
  753. unsigned long cpages = 0;
  754. unsigned long i;
  755. for (i = 0; i < migrate->npages; i++) {
  756. if (migrate->src[i] & MIGRATE_PFN_VALID &&
  757. migrate->src[i] & MIGRATE_PFN_MIGRATE)
  758. cpages++;
  759. }
  760. return cpages;
  761. }
  762. static int dmirror_migrate_to_system(struct dmirror *dmirror,
  763. struct hmm_dmirror_cmd *cmd)
  764. {
  765. unsigned long start, end, addr;
  766. unsigned long size = cmd->npages << PAGE_SHIFT;
  767. struct mm_struct *mm = dmirror->notifier.mm;
  768. struct vm_area_struct *vma;
  769. unsigned long src_pfns[64] = { 0 };
  770. unsigned long dst_pfns[64] = { 0 };
  771. struct migrate_vma args = { 0 };
  772. unsigned long next;
  773. int ret;
  774. start = cmd->addr;
  775. end = start + size;
  776. if (end < start)
  777. return -EINVAL;
  778. /* Since the mm is for the mirrored process, get a reference first. */
  779. if (!mmget_not_zero(mm))
  780. return -EINVAL;
  781. cmd->cpages = 0;
  782. mmap_read_lock(mm);
  783. for (addr = start; addr < end; addr = next) {
  784. vma = vma_lookup(mm, addr);
  785. if (!vma || !(vma->vm_flags & VM_READ)) {
  786. ret = -EINVAL;
  787. goto out;
  788. }
  789. next = min(end, addr + (ARRAY_SIZE(src_pfns) << PAGE_SHIFT));
  790. if (next > vma->vm_end)
  791. next = vma->vm_end;
  792. args.vma = vma;
  793. args.src = src_pfns;
  794. args.dst = dst_pfns;
  795. args.start = addr;
  796. args.end = next;
  797. args.pgmap_owner = dmirror->mdevice;
  798. args.flags = dmirror_select_device(dmirror);
  799. ret = migrate_vma_setup(&args);
  800. if (ret)
  801. goto out;
  802. pr_debug("Migrating from device mem to sys mem\n");
  803. dmirror_devmem_fault_alloc_and_copy(&args, dmirror);
  804. migrate_vma_pages(&args);
  805. cmd->cpages += dmirror_successful_migrated_pages(&args);
  806. migrate_vma_finalize(&args);
  807. }
  808. out:
  809. mmap_read_unlock(mm);
  810. mmput(mm);
  811. return ret;
  812. }
  813. static int dmirror_migrate_to_device(struct dmirror *dmirror,
  814. struct hmm_dmirror_cmd *cmd)
  815. {
  816. unsigned long start, end, addr;
  817. unsigned long size = cmd->npages << PAGE_SHIFT;
  818. struct mm_struct *mm = dmirror->notifier.mm;
  819. struct vm_area_struct *vma;
  820. unsigned long src_pfns[64] = { 0 };
  821. unsigned long dst_pfns[64] = { 0 };
  822. struct dmirror_bounce bounce;
  823. struct migrate_vma args = { 0 };
  824. unsigned long next;
  825. int ret;
  826. start = cmd->addr;
  827. end = start + size;
  828. if (end < start)
  829. return -EINVAL;
  830. /* Since the mm is for the mirrored process, get a reference first. */
  831. if (!mmget_not_zero(mm))
  832. return -EINVAL;
  833. mmap_read_lock(mm);
  834. for (addr = start; addr < end; addr = next) {
  835. vma = vma_lookup(mm, addr);
  836. if (!vma || !(vma->vm_flags & VM_READ)) {
  837. ret = -EINVAL;
  838. goto out;
  839. }
  840. next = min(end, addr + (ARRAY_SIZE(src_pfns) << PAGE_SHIFT));
  841. if (next > vma->vm_end)
  842. next = vma->vm_end;
  843. args.vma = vma;
  844. args.src = src_pfns;
  845. args.dst = dst_pfns;
  846. args.start = addr;
  847. args.end = next;
  848. args.pgmap_owner = dmirror->mdevice;
  849. args.flags = MIGRATE_VMA_SELECT_SYSTEM;
  850. ret = migrate_vma_setup(&args);
  851. if (ret)
  852. goto out;
  853. pr_debug("Migrating from sys mem to device mem\n");
  854. dmirror_migrate_alloc_and_copy(&args, dmirror);
  855. migrate_vma_pages(&args);
  856. dmirror_migrate_finalize_and_map(&args, dmirror);
  857. migrate_vma_finalize(&args);
  858. }
  859. mmap_read_unlock(mm);
  860. mmput(mm);
  861. /*
  862. * Return the migrated data for verification.
  863. * Only for pages in device zone
  864. */
  865. ret = dmirror_bounce_init(&bounce, start, size);
  866. if (ret)
  867. return ret;
  868. mutex_lock(&dmirror->mutex);
  869. ret = dmirror_do_read(dmirror, start, end, &bounce);
  870. mutex_unlock(&dmirror->mutex);
  871. if (ret == 0) {
  872. if (copy_to_user(u64_to_user_ptr(cmd->ptr), bounce.ptr,
  873. bounce.size))
  874. ret = -EFAULT;
  875. }
  876. cmd->cpages = bounce.cpages;
  877. dmirror_bounce_fini(&bounce);
  878. return ret;
  879. out:
  880. mmap_read_unlock(mm);
  881. mmput(mm);
  882. return ret;
  883. }
  884. static void dmirror_mkentry(struct dmirror *dmirror, struct hmm_range *range,
  885. unsigned char *perm, unsigned long entry)
  886. {
  887. struct page *page;
  888. if (entry & HMM_PFN_ERROR) {
  889. *perm = HMM_DMIRROR_PROT_ERROR;
  890. return;
  891. }
  892. if (!(entry & HMM_PFN_VALID)) {
  893. *perm = HMM_DMIRROR_PROT_NONE;
  894. return;
  895. }
  896. page = hmm_pfn_to_page(entry);
  897. if (is_device_private_page(page)) {
  898. /* Is the page migrated to this device or some other? */
  899. if (dmirror->mdevice == dmirror_page_to_device(page))
  900. *perm = HMM_DMIRROR_PROT_DEV_PRIVATE_LOCAL;
  901. else
  902. *perm = HMM_DMIRROR_PROT_DEV_PRIVATE_REMOTE;
  903. } else if (is_device_coherent_page(page)) {
  904. /* Is the page migrated to this device or some other? */
  905. if (dmirror->mdevice == dmirror_page_to_device(page))
  906. *perm = HMM_DMIRROR_PROT_DEV_COHERENT_LOCAL;
  907. else
  908. *perm = HMM_DMIRROR_PROT_DEV_COHERENT_REMOTE;
  909. } else if (is_zero_pfn(page_to_pfn(page)))
  910. *perm = HMM_DMIRROR_PROT_ZERO;
  911. else
  912. *perm = HMM_DMIRROR_PROT_NONE;
  913. if (entry & HMM_PFN_WRITE)
  914. *perm |= HMM_DMIRROR_PROT_WRITE;
  915. else
  916. *perm |= HMM_DMIRROR_PROT_READ;
  917. if (hmm_pfn_to_map_order(entry) + PAGE_SHIFT == PMD_SHIFT)
  918. *perm |= HMM_DMIRROR_PROT_PMD;
  919. else if (hmm_pfn_to_map_order(entry) + PAGE_SHIFT == PUD_SHIFT)
  920. *perm |= HMM_DMIRROR_PROT_PUD;
  921. }
  922. static bool dmirror_snapshot_invalidate(struct mmu_interval_notifier *mni,
  923. const struct mmu_notifier_range *range,
  924. unsigned long cur_seq)
  925. {
  926. struct dmirror_interval *dmi =
  927. container_of(mni, struct dmirror_interval, notifier);
  928. struct dmirror *dmirror = dmi->dmirror;
  929. if (mmu_notifier_range_blockable(range))
  930. mutex_lock(&dmirror->mutex);
  931. else if (!mutex_trylock(&dmirror->mutex))
  932. return false;
  933. /*
  934. * Snapshots only need to set the sequence number since any
  935. * invalidation in the interval invalidates the whole snapshot.
  936. */
  937. mmu_interval_set_seq(mni, cur_seq);
  938. mutex_unlock(&dmirror->mutex);
  939. return true;
  940. }
  941. static const struct mmu_interval_notifier_ops dmirror_mrn_ops = {
  942. .invalidate = dmirror_snapshot_invalidate,
  943. };
  944. static int dmirror_range_snapshot(struct dmirror *dmirror,
  945. struct hmm_range *range,
  946. unsigned char *perm)
  947. {
  948. struct mm_struct *mm = dmirror->notifier.mm;
  949. struct dmirror_interval notifier;
  950. unsigned long timeout =
  951. jiffies + msecs_to_jiffies(HMM_RANGE_DEFAULT_TIMEOUT);
  952. unsigned long i;
  953. unsigned long n;
  954. int ret = 0;
  955. notifier.dmirror = dmirror;
  956. range->notifier = &notifier.notifier;
  957. ret = mmu_interval_notifier_insert(range->notifier, mm,
  958. range->start, range->end - range->start,
  959. &dmirror_mrn_ops);
  960. if (ret)
  961. return ret;
  962. while (true) {
  963. if (time_after(jiffies, timeout)) {
  964. ret = -EBUSY;
  965. goto out;
  966. }
  967. range->notifier_seq = mmu_interval_read_begin(range->notifier);
  968. mmap_read_lock(mm);
  969. ret = hmm_range_fault(range);
  970. mmap_read_unlock(mm);
  971. if (ret) {
  972. if (ret == -EBUSY)
  973. continue;
  974. goto out;
  975. }
  976. mutex_lock(&dmirror->mutex);
  977. if (mmu_interval_read_retry(range->notifier,
  978. range->notifier_seq)) {
  979. mutex_unlock(&dmirror->mutex);
  980. continue;
  981. }
  982. break;
  983. }
  984. n = (range->end - range->start) >> PAGE_SHIFT;
  985. for (i = 0; i < n; i++)
  986. dmirror_mkentry(dmirror, range, perm + i, range->hmm_pfns[i]);
  987. mutex_unlock(&dmirror->mutex);
  988. out:
  989. mmu_interval_notifier_remove(range->notifier);
  990. return ret;
  991. }
  992. static int dmirror_snapshot(struct dmirror *dmirror,
  993. struct hmm_dmirror_cmd *cmd)
  994. {
  995. struct mm_struct *mm = dmirror->notifier.mm;
  996. unsigned long start, end;
  997. unsigned long size = cmd->npages << PAGE_SHIFT;
  998. unsigned long addr;
  999. unsigned long next;
  1000. unsigned long pfns[64];
  1001. unsigned char perm[64];
  1002. char __user *uptr;
  1003. struct hmm_range range = {
  1004. .hmm_pfns = pfns,
  1005. .dev_private_owner = dmirror->mdevice,
  1006. };
  1007. int ret = 0;
  1008. start = cmd->addr;
  1009. end = start + size;
  1010. if (end < start)
  1011. return -EINVAL;
  1012. /* Since the mm is for the mirrored process, get a reference first. */
  1013. if (!mmget_not_zero(mm))
  1014. return -EINVAL;
  1015. /*
  1016. * Register a temporary notifier to detect invalidations even if it
  1017. * overlaps with other mmu_interval_notifiers.
  1018. */
  1019. uptr = u64_to_user_ptr(cmd->ptr);
  1020. for (addr = start; addr < end; addr = next) {
  1021. unsigned long n;
  1022. next = min(addr + (ARRAY_SIZE(pfns) << PAGE_SHIFT), end);
  1023. range.start = addr;
  1024. range.end = next;
  1025. ret = dmirror_range_snapshot(dmirror, &range, perm);
  1026. if (ret)
  1027. break;
  1028. n = (range.end - range.start) >> PAGE_SHIFT;
  1029. if (copy_to_user(uptr, perm, n)) {
  1030. ret = -EFAULT;
  1031. break;
  1032. }
  1033. cmd->cpages += n;
  1034. uptr += n;
  1035. }
  1036. mmput(mm);
  1037. return ret;
  1038. }
  1039. static void dmirror_device_evict_chunk(struct dmirror_chunk *chunk)
  1040. {
  1041. unsigned long start_pfn = chunk->pagemap.range.start >> PAGE_SHIFT;
  1042. unsigned long end_pfn = chunk->pagemap.range.end >> PAGE_SHIFT;
  1043. unsigned long npages = end_pfn - start_pfn + 1;
  1044. unsigned long i;
  1045. unsigned long *src_pfns;
  1046. unsigned long *dst_pfns;
  1047. src_pfns = kcalloc(npages, sizeof(*src_pfns), GFP_KERNEL);
  1048. dst_pfns = kcalloc(npages, sizeof(*dst_pfns), GFP_KERNEL);
  1049. migrate_device_range(src_pfns, start_pfn, npages);
  1050. for (i = 0; i < npages; i++) {
  1051. struct page *dpage, *spage;
  1052. spage = migrate_pfn_to_page(src_pfns[i]);
  1053. if (!spage || !(src_pfns[i] & MIGRATE_PFN_MIGRATE))
  1054. continue;
  1055. if (WARN_ON(!is_device_private_page(spage) &&
  1056. !is_device_coherent_page(spage)))
  1057. continue;
  1058. spage = BACKING_PAGE(spage);
  1059. dpage = alloc_page(GFP_HIGHUSER_MOVABLE | __GFP_NOFAIL);
  1060. lock_page(dpage);
  1061. copy_highpage(dpage, spage);
  1062. dst_pfns[i] = migrate_pfn(page_to_pfn(dpage));
  1063. if (src_pfns[i] & MIGRATE_PFN_WRITE)
  1064. dst_pfns[i] |= MIGRATE_PFN_WRITE;
  1065. }
  1066. migrate_device_pages(src_pfns, dst_pfns, npages);
  1067. migrate_device_finalize(src_pfns, dst_pfns, npages);
  1068. kfree(src_pfns);
  1069. kfree(dst_pfns);
  1070. }
  1071. /* Removes free pages from the free list so they can't be re-allocated */
  1072. static void dmirror_remove_free_pages(struct dmirror_chunk *devmem)
  1073. {
  1074. struct dmirror_device *mdevice = devmem->mdevice;
  1075. struct page *page;
  1076. for (page = mdevice->free_pages; page; page = page->zone_device_data)
  1077. if (dmirror_page_to_chunk(page) == devmem)
  1078. mdevice->free_pages = page->zone_device_data;
  1079. }
  1080. static void dmirror_device_remove_chunks(struct dmirror_device *mdevice)
  1081. {
  1082. unsigned int i;
  1083. mutex_lock(&mdevice->devmem_lock);
  1084. if (mdevice->devmem_chunks) {
  1085. for (i = 0; i < mdevice->devmem_count; i++) {
  1086. struct dmirror_chunk *devmem =
  1087. mdevice->devmem_chunks[i];
  1088. spin_lock(&mdevice->lock);
  1089. devmem->remove = true;
  1090. dmirror_remove_free_pages(devmem);
  1091. spin_unlock(&mdevice->lock);
  1092. dmirror_device_evict_chunk(devmem);
  1093. memunmap_pages(&devmem->pagemap);
  1094. if (devmem->pagemap.type == MEMORY_DEVICE_PRIVATE)
  1095. release_mem_region(devmem->pagemap.range.start,
  1096. range_len(&devmem->pagemap.range));
  1097. kfree(devmem);
  1098. }
  1099. mdevice->devmem_count = 0;
  1100. mdevice->devmem_capacity = 0;
  1101. mdevice->free_pages = NULL;
  1102. kfree(mdevice->devmem_chunks);
  1103. mdevice->devmem_chunks = NULL;
  1104. }
  1105. mutex_unlock(&mdevice->devmem_lock);
  1106. }
  1107. static long dmirror_fops_unlocked_ioctl(struct file *filp,
  1108. unsigned int command,
  1109. unsigned long arg)
  1110. {
  1111. void __user *uarg = (void __user *)arg;
  1112. struct hmm_dmirror_cmd cmd;
  1113. struct dmirror *dmirror;
  1114. int ret;
  1115. dmirror = filp->private_data;
  1116. if (!dmirror)
  1117. return -EINVAL;
  1118. if (copy_from_user(&cmd, uarg, sizeof(cmd)))
  1119. return -EFAULT;
  1120. if (cmd.addr & ~PAGE_MASK)
  1121. return -EINVAL;
  1122. if (cmd.addr >= (cmd.addr + (cmd.npages << PAGE_SHIFT)))
  1123. return -EINVAL;
  1124. cmd.cpages = 0;
  1125. cmd.faults = 0;
  1126. switch (command) {
  1127. case HMM_DMIRROR_READ:
  1128. ret = dmirror_read(dmirror, &cmd);
  1129. break;
  1130. case HMM_DMIRROR_WRITE:
  1131. ret = dmirror_write(dmirror, &cmd);
  1132. break;
  1133. case HMM_DMIRROR_MIGRATE_TO_DEV:
  1134. ret = dmirror_migrate_to_device(dmirror, &cmd);
  1135. break;
  1136. case HMM_DMIRROR_MIGRATE_TO_SYS:
  1137. ret = dmirror_migrate_to_system(dmirror, &cmd);
  1138. break;
  1139. case HMM_DMIRROR_EXCLUSIVE:
  1140. ret = dmirror_exclusive(dmirror, &cmd);
  1141. break;
  1142. case HMM_DMIRROR_CHECK_EXCLUSIVE:
  1143. ret = dmirror_check_atomic(dmirror, cmd.addr,
  1144. cmd.addr + (cmd.npages << PAGE_SHIFT));
  1145. break;
  1146. case HMM_DMIRROR_SNAPSHOT:
  1147. ret = dmirror_snapshot(dmirror, &cmd);
  1148. break;
  1149. case HMM_DMIRROR_RELEASE:
  1150. dmirror_device_remove_chunks(dmirror->mdevice);
  1151. ret = 0;
  1152. break;
  1153. default:
  1154. return -EINVAL;
  1155. }
  1156. if (ret)
  1157. return ret;
  1158. if (copy_to_user(uarg, &cmd, sizeof(cmd)))
  1159. return -EFAULT;
  1160. return 0;
  1161. }
  1162. static int dmirror_fops_mmap(struct file *file, struct vm_area_struct *vma)
  1163. {
  1164. unsigned long addr;
  1165. for (addr = vma->vm_start; addr < vma->vm_end; addr += PAGE_SIZE) {
  1166. struct page *page;
  1167. int ret;
  1168. page = alloc_page(GFP_KERNEL | __GFP_ZERO);
  1169. if (!page)
  1170. return -ENOMEM;
  1171. ret = vm_insert_page(vma, addr, page);
  1172. if (ret) {
  1173. __free_page(page);
  1174. return ret;
  1175. }
  1176. put_page(page);
  1177. }
  1178. return 0;
  1179. }
  1180. static const struct file_operations dmirror_fops = {
  1181. .open = dmirror_fops_open,
  1182. .release = dmirror_fops_release,
  1183. .mmap = dmirror_fops_mmap,
  1184. .unlocked_ioctl = dmirror_fops_unlocked_ioctl,
  1185. .llseek = default_llseek,
  1186. .owner = THIS_MODULE,
  1187. };
  1188. static void dmirror_devmem_free(struct page *page)
  1189. {
  1190. struct page *rpage = BACKING_PAGE(page);
  1191. struct dmirror_device *mdevice;
  1192. if (rpage != page)
  1193. __free_page(rpage);
  1194. mdevice = dmirror_page_to_device(page);
  1195. spin_lock(&mdevice->lock);
  1196. /* Return page to our allocator if not freeing the chunk */
  1197. if (!dmirror_page_to_chunk(page)->remove) {
  1198. mdevice->cfree++;
  1199. page->zone_device_data = mdevice->free_pages;
  1200. mdevice->free_pages = page;
  1201. }
  1202. spin_unlock(&mdevice->lock);
  1203. }
  1204. static vm_fault_t dmirror_devmem_fault(struct vm_fault *vmf)
  1205. {
  1206. struct migrate_vma args = { 0 };
  1207. unsigned long src_pfns = 0;
  1208. unsigned long dst_pfns = 0;
  1209. struct page *rpage;
  1210. struct dmirror *dmirror;
  1211. vm_fault_t ret;
  1212. /*
  1213. * Normally, a device would use the page->zone_device_data to point to
  1214. * the mirror but here we use it to hold the page for the simulated
  1215. * device memory and that page holds the pointer to the mirror.
  1216. */
  1217. rpage = vmf->page->zone_device_data;
  1218. dmirror = rpage->zone_device_data;
  1219. /* FIXME demonstrate how we can adjust migrate range */
  1220. args.vma = vmf->vma;
  1221. args.start = vmf->address;
  1222. args.end = args.start + PAGE_SIZE;
  1223. args.src = &src_pfns;
  1224. args.dst = &dst_pfns;
  1225. args.pgmap_owner = dmirror->mdevice;
  1226. args.flags = dmirror_select_device(dmirror);
  1227. args.fault_page = vmf->page;
  1228. if (migrate_vma_setup(&args))
  1229. return VM_FAULT_SIGBUS;
  1230. ret = dmirror_devmem_fault_alloc_and_copy(&args, dmirror);
  1231. if (ret)
  1232. return ret;
  1233. migrate_vma_pages(&args);
  1234. /*
  1235. * No device finalize step is needed since
  1236. * dmirror_devmem_fault_alloc_and_copy() will have already
  1237. * invalidated the device page table.
  1238. */
  1239. migrate_vma_finalize(&args);
  1240. return 0;
  1241. }
  1242. static const struct dev_pagemap_ops dmirror_devmem_ops = {
  1243. .page_free = dmirror_devmem_free,
  1244. .migrate_to_ram = dmirror_devmem_fault,
  1245. };
  1246. static int dmirror_device_init(struct dmirror_device *mdevice, int id)
  1247. {
  1248. dev_t dev;
  1249. int ret;
  1250. dev = MKDEV(MAJOR(dmirror_dev), id);
  1251. mutex_init(&mdevice->devmem_lock);
  1252. spin_lock_init(&mdevice->lock);
  1253. cdev_init(&mdevice->cdevice, &dmirror_fops);
  1254. mdevice->cdevice.owner = THIS_MODULE;
  1255. device_initialize(&mdevice->device);
  1256. mdevice->device.devt = dev;
  1257. ret = dev_set_name(&mdevice->device, "hmm_dmirror%u", id);
  1258. if (ret)
  1259. return ret;
  1260. ret = cdev_device_add(&mdevice->cdevice, &mdevice->device);
  1261. if (ret)
  1262. return ret;
  1263. /* Build a list of free ZONE_DEVICE struct pages */
  1264. return dmirror_allocate_chunk(mdevice, NULL);
  1265. }
  1266. static void dmirror_device_remove(struct dmirror_device *mdevice)
  1267. {
  1268. dmirror_device_remove_chunks(mdevice);
  1269. cdev_device_del(&mdevice->cdevice, &mdevice->device);
  1270. }
  1271. static int __init hmm_dmirror_init(void)
  1272. {
  1273. int ret;
  1274. int id = 0;
  1275. int ndevices = 0;
  1276. ret = alloc_chrdev_region(&dmirror_dev, 0, DMIRROR_NDEVICES,
  1277. "HMM_DMIRROR");
  1278. if (ret)
  1279. goto err_unreg;
  1280. memset(dmirror_devices, 0, DMIRROR_NDEVICES * sizeof(dmirror_devices[0]));
  1281. dmirror_devices[ndevices++].zone_device_type =
  1282. HMM_DMIRROR_MEMORY_DEVICE_PRIVATE;
  1283. dmirror_devices[ndevices++].zone_device_type =
  1284. HMM_DMIRROR_MEMORY_DEVICE_PRIVATE;
  1285. if (spm_addr_dev0 && spm_addr_dev1) {
  1286. dmirror_devices[ndevices++].zone_device_type =
  1287. HMM_DMIRROR_MEMORY_DEVICE_COHERENT;
  1288. dmirror_devices[ndevices++].zone_device_type =
  1289. HMM_DMIRROR_MEMORY_DEVICE_COHERENT;
  1290. }
  1291. for (id = 0; id < ndevices; id++) {
  1292. ret = dmirror_device_init(dmirror_devices + id, id);
  1293. if (ret)
  1294. goto err_chrdev;
  1295. }
  1296. pr_info("HMM test module loaded. This is only for testing HMM.\n");
  1297. return 0;
  1298. err_chrdev:
  1299. while (--id >= 0)
  1300. dmirror_device_remove(dmirror_devices + id);
  1301. unregister_chrdev_region(dmirror_dev, DMIRROR_NDEVICES);
  1302. err_unreg:
  1303. return ret;
  1304. }
  1305. static void __exit hmm_dmirror_exit(void)
  1306. {
  1307. int id;
  1308. for (id = 0; id < DMIRROR_NDEVICES; id++)
  1309. if (dmirror_devices[id].zone_device_type)
  1310. dmirror_device_remove(dmirror_devices + id);
  1311. unregister_chrdev_region(dmirror_dev, DMIRROR_NDEVICES);
  1312. }
  1313. module_init(hmm_dmirror_init);
  1314. module_exit(hmm_dmirror_exit);
  1315. MODULE_LICENSE("GPL");