device-dax: make pgmap optional for instance creation

+15 -14

drivers/dax/bus.c

··· 271 271 struct device_attribute *attr, char *buf) 272 272 { 273 273 struct dev_dax *dev_dax = to_dev_dax(dev); 274 - unsigned long long size = resource_size(&dev_dax->region->res); 274 + unsigned long long size = range_len(&dev_dax->range); 275 275 276 276 return sprintf(buf, "%llu\n", size); 277 277 } ··· 293 293 } 294 294 static DEVICE_ATTR_RO(target_node); 295 295 296 - static unsigned long long dev_dax_resource(struct dev_dax *dev_dax) 297 - { 298 - struct dax_region *dax_region = dev_dax->region; 299 - 300 - return dax_region->res.start; 301 - } 302 - 303 296 static ssize_t resource_show(struct device *dev, 304 297 struct device_attribute *attr, char *buf) 305 298 { 306 299 struct dev_dax *dev_dax = to_dev_dax(dev); 307 300 308 - return sprintf(buf, "%#llx\n", dev_dax_resource(dev_dax)); 301 + return sprintf(buf, "%#llx\n", dev_dax->range.start); 309 302 } 310 303 static DEVICE_ATTR(resource, 0400, resource_show, NULL); 311 304 ··· 369 376 370 377 dax_region_put(dax_region); 371 378 put_dax(dax_dev); 379 + kfree(dev_dax->pgmap); 372 380 kfree(dev_dax); 373 381 } 374 382 ··· 406 412 if (!dev_dax) 407 413 return ERR_PTR(-ENOMEM); 408 414 409 - memcpy(&dev_dax->pgmap, data->pgmap, sizeof(struct dev_pagemap)); 415 + if (data->pgmap) { 416 + dev_dax->pgmap = kmemdup(data->pgmap, 417 + sizeof(struct dev_pagemap), GFP_KERNEL); 418 + if (!dev_dax->pgmap) 419 + goto err_pgmap; 420 + } 410 421 411 422 /* 412 423 * No 'host' or dax_operations since there is no access to this ··· 420 421 dax_dev = alloc_dax(dev_dax, NULL, NULL, DAXDEV_F_SYNC); 421 422 if (IS_ERR(dax_dev)) { 422 423 rc = PTR_ERR(dax_dev); 423 - goto err; 424 + goto err_alloc_dax; 424 425 } 425 426 426 427 /* a device_dax instance is dead while the driver is not attached */ 427 428 kill_dax(dax_dev); 428 429 429 - /* from here on we're committed to teardown via dax_dev_release() */ 430 + /* from here on we're committed to teardown via dev_dax_release() */ 430 431 dev = &dev_dax->dev; 431 432 device_initialize(dev); 432 433 433 434 dev_dax->dax_dev = dax_dev; 434 435 dev_dax->region = dax_region; 436 + dev_dax->range = data->range; 435 437 dev_dax->target_node = dax_region->target_node; 436 438 kref_get(&dax_region->kref); 437 439 ··· 458 458 return ERR_PTR(rc); 459 459 460 460 return dev_dax; 461 - 462 - err: 461 + err_alloc_dax: 462 + kfree(dev_dax->pgmap); 463 + err_pgmap: 463 464 kfree(dev_dax); 464 465 465 466 return ERR_PTR(rc);

+2

drivers/dax/bus.h

··· 3 3 #ifndef __DAX_BUS_H__ 4 4 #define __DAX_BUS_H__ 5 5 #include <linux/device.h> 6 + #include <linux/range.h> 6 7 7 8 struct dev_dax; 8 9 struct resource; ··· 22 21 struct dax_region *dax_region; 23 22 struct dev_pagemap *pgmap; 24 23 enum dev_dax_subsys subsys; 24 + struct range range; 25 25 int id; 26 26 }; 27 27

+8 -1

drivers/dax/dax-private.h

··· 41 41 * @target_node: effective numa node if dev_dax memory range is onlined 42 42 * @dev - device core 43 43 * @pgmap - pgmap for memmap setup / lifetime (driver owned) 44 + * @range: resource range for the instance 44 45 * @dax_mem_res: physical address range of hotadded DAX memory 45 46 * @dax_mem_name: name for hotadded DAX memory via add_memory_driver_managed() 46 47 */ ··· 50 49 struct dax_device *dax_dev; 51 50 int target_node; 52 51 struct device dev; 53 - struct dev_pagemap pgmap; 52 + struct dev_pagemap *pgmap; 53 + struct range range; 54 54 struct resource *dax_kmem_res; 55 55 }; 56 + 57 + static inline u64 range_len(struct range *range) 58 + { 59 + return range->end - range->start + 1; 60 + } 56 61 57 62 static inline struct dev_dax *to_dev_dax(struct device *dev) 58 63 {

+19 -9

drivers/dax/device.c

··· 55 55 __weak phys_addr_t dax_pgoff_to_phys(struct dev_dax *dev_dax, pgoff_t pgoff, 56 56 unsigned long size) 57 57 { 58 - struct resource *res = &dev_dax->region->res; 58 + struct range *range = &dev_dax->range; 59 59 phys_addr_t phys; 60 60 61 - phys = pgoff * PAGE_SIZE + res->start; 62 - if (phys >= res->start && phys <= res->end) { 63 - if (phys + size - 1 <= res->end) 61 + phys = pgoff * PAGE_SIZE + range->start; 62 + if (phys >= range->start && phys <= range->end) { 63 + if (phys + size - 1 <= range->end) 64 64 return phys; 65 65 } 66 66 ··· 396 396 { 397 397 struct dev_dax *dev_dax = to_dev_dax(dev); 398 398 struct dax_device *dax_dev = dev_dax->dax_dev; 399 - struct resource *res = &dev_dax->region->res; 399 + struct range *range = &dev_dax->range; 400 + struct dev_pagemap *pgmap; 400 401 struct inode *inode; 401 402 struct cdev *cdev; 402 403 void *addr; 403 404 int rc; 404 405 405 406 /* 1:1 map region resource range to device-dax instance range */ 406 - if (!devm_request_mem_region(dev, res->start, resource_size(res), 407 + if (!devm_request_mem_region(dev, range->start, range_len(range), 407 408 dev_name(dev))) { 408 - dev_warn(dev, "could not reserve region %pR\n", res); 409 + dev_warn(dev, "could not reserve range: %#llx - %#llx\n", 410 + range->start, range->end); 409 411 return -EBUSY; 410 412 } 411 413 412 - dev_dax->pgmap.type = MEMORY_DEVICE_GENERIC; 413 - addr = devm_memremap_pages(dev, &dev_dax->pgmap); 414 + pgmap = dev_dax->pgmap; 415 + if (!pgmap) { 416 + pgmap = devm_kzalloc(dev, sizeof(*pgmap), GFP_KERNEL); 417 + if (!pgmap) 418 + return -ENOMEM; 419 + pgmap->res.start = range->start; 420 + pgmap->res.end = range->end; 421 + } 422 + pgmap->type = MEMORY_DEVICE_GENERIC; 423 + addr = devm_memremap_pages(dev, pgmap); 414 424 if (IS_ERR(addr)) 415 425 return PTR_ERR(addr); 416 426

+4 -4

drivers/dax/hmem/hmem.c

··· 8 8 static int dax_hmem_probe(struct platform_device *pdev) 9 9 { 10 10 struct device *dev = &pdev->dev; 11 - struct dev_pagemap pgmap = { }; 12 11 struct dax_region *dax_region; 13 12 struct memregion_info *mri; 14 13 struct dev_dax_data data; ··· 19 20 return -ENOMEM; 20 21 21 22 mri = dev->platform_data; 22 - memcpy(&pgmap.res, res, sizeof(*res)); 23 - 24 23 dax_region = alloc_dax_region(dev, pdev->id, res, mri->target_node, 25 24 PMD_SIZE); 26 25 if (!dax_region) ··· 27 30 data = (struct dev_dax_data) { 28 31 .dax_region = dax_region, 29 32 .id = 0, 30 - .pgmap = &pgmap, 33 + .range = { 34 + .start = res->start, 35 + .end = res->end, 36 + }, 31 37 }; 32 38 dev_dax = devm_create_dev_dax(&data); 33 39 if (IS_ERR(dev_dax))

+6 -6

drivers/dax/kmem.c

··· 22 22 int dev_dax_kmem_probe(struct device *dev) 23 23 { 24 24 struct dev_dax *dev_dax = to_dev_dax(dev); 25 - struct resource *res = &dev_dax->region->res; 25 + struct range *range = &dev_dax->range; 26 26 resource_size_t kmem_start; 27 27 resource_size_t kmem_size; 28 28 resource_size_t kmem_end; ··· 39 39 */ 40 40 numa_node = dev_dax->target_node; 41 41 if (numa_node < 0) { 42 - dev_warn(dev, "rejecting DAX region %pR with invalid node: %d\n", 43 - res, numa_node); 42 + dev_warn(dev, "rejecting DAX region with invalid node: %d\n", 43 + numa_node); 44 44 return -EINVAL; 45 45 } 46 46 47 47 /* Hotplug starting at the beginning of the next block: */ 48 - kmem_start = ALIGN(res->start, memory_block_size_bytes()); 48 + kmem_start = ALIGN(range->start, memory_block_size_bytes()); 49 49 50 - kmem_size = resource_size(res); 50 + kmem_size = range_len(range); 51 51 /* Adjust the size down to compensate for moving up kmem_start: */ 52 - kmem_size -= kmem_start - res->start; 52 + kmem_size -= kmem_start - range->start; 53 53 /* Align the size down to cover only complete blocks: */ 54 54 kmem_size &= ~(memory_block_size_bytes() - 1); 55 55 kmem_end = kmem_start + kmem_size;

+4

drivers/dax/pmem/core.c

··· 63 63 .id = id, 64 64 .pgmap = &pgmap, 65 65 .subsys = subsys, 66 + .range = { 67 + .start = res.start, 68 + .end = res.end, 69 + }, 66 70 }; 67 71 dev_dax = devm_create_dev_dax(&data); 68 72

+4 -4

tools/testing/nvdimm/dax-dev.c

··· 9 9 phys_addr_t dax_pgoff_to_phys(struct dev_dax *dev_dax, pgoff_t pgoff, 10 10 unsigned long size) 11 11 { 12 - struct resource *res = &dev_dax->region->res; 12 + struct range *range = &dev_dax->range; 13 13 phys_addr_t addr; 14 14 15 - addr = pgoff * PAGE_SIZE + res->start; 16 - if (addr >= res->start && addr <= res->end) { 17 - if (addr + size - 1 <= res->end) { 15 + addr = pgoff * PAGE_SIZE + range->start; 16 + if (addr >= range->start && addr <= range->end) { 17 + if (addr + size - 1 <= range->end) { 18 18 if (get_nfit_res(addr)) { 19 19 struct page *page; 20 20

Configure Feed

Configure Feed