xpram.c 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * Xpram.c -- the S/390 expanded memory RAM-disk
  4. *
  5. * significant parts of this code are based on
  6. * the sbull device driver presented in
  7. * A. Rubini: Linux Device Drivers
  8. *
  9. * Author of XPRAM specific coding: Reinhard Buendgen
  10. * buendgen@de.ibm.com
  11. * Rewrite for 2.5: Martin Schwidefsky <schwidefsky@de.ibm.com>
  12. *
  13. * External interfaces:
  14. * Interfaces to linux kernel
  15. * xpram_setup: read kernel parameters
  16. * Device specific file operations
  17. * xpram_iotcl
  18. * xpram_open
  19. *
  20. * "ad-hoc" partitioning:
  21. * the expanded memory can be partitioned among several devices
  22. * (with different minors). The partitioning set up can be
  23. * set by kernel or module parameters (int devs & int sizes[])
  24. *
  25. * Potential future improvements:
  26. * generic hard disk support to replace ad-hoc partitioning
  27. */
  28. #define KMSG_COMPONENT "xpram"
  29. #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
  30. #include <linux/module.h>
  31. #include <linux/moduleparam.h>
  32. #include <linux/ctype.h> /* isdigit, isxdigit */
  33. #include <linux/errno.h>
  34. #include <linux/init.h>
  35. #include <linux/blkdev.h>
  36. #include <linux/blkpg.h>
  37. #include <linux/hdreg.h> /* HDIO_GETGEO */
  38. #include <linux/device.h>
  39. #include <linux/bio.h>
  40. #include <linux/suspend.h>
  41. #include <linux/platform_device.h>
  42. #include <linux/gfp.h>
  43. #include <linux/uaccess.h>
  44. #define XPRAM_NAME "xpram"
  45. #define XPRAM_DEVS 1 /* one partition */
  46. #define XPRAM_MAX_DEVS 32 /* maximal number of devices (partitions) */
  47. typedef struct {
  48. unsigned int size; /* size of xpram segment in pages */
  49. unsigned int offset; /* start page of xpram segment */
  50. } xpram_device_t;
  51. static xpram_device_t xpram_devices[XPRAM_MAX_DEVS];
  52. static unsigned int xpram_sizes[XPRAM_MAX_DEVS];
  53. static struct gendisk *xpram_disks[XPRAM_MAX_DEVS];
  54. static struct request_queue *xpram_queues[XPRAM_MAX_DEVS];
  55. static unsigned int xpram_pages;
  56. static int xpram_devs;
  57. /*
  58. * Parameter parsing functions.
  59. */
  60. static int devs = XPRAM_DEVS;
  61. static char *sizes[XPRAM_MAX_DEVS];
  62. module_param(devs, int, 0);
  63. module_param_array(sizes, charp, NULL, 0);
  64. MODULE_PARM_DESC(devs, "number of devices (\"partitions\"), " \
  65. "the default is " __MODULE_STRING(XPRAM_DEVS) "\n");
  66. MODULE_PARM_DESC(sizes, "list of device (partition) sizes " \
  67. "the defaults are 0s \n" \
  68. "All devices with size 0 equally partition the "
  69. "remaining space on the expanded strorage not "
  70. "claimed by explicit sizes\n");
  71. MODULE_LICENSE("GPL");
  72. /*
  73. * Copy expanded memory page (4kB) into main memory
  74. * Arguments
  75. * page_addr: address of target page
  76. * xpage_index: index of expandeded memory page
  77. * Return value
  78. * 0: if operation succeeds
  79. * -EIO: if pgin failed
  80. * -ENXIO: if xpram has vanished
  81. */
  82. static int xpram_page_in (unsigned long page_addr, unsigned int xpage_index)
  83. {
  84. int cc = 2; /* return unused cc 2 if pgin traps */
  85. asm volatile(
  86. " .insn rre,0xb22e0000,%1,%2\n" /* pgin %1,%2 */
  87. "0: ipm %0\n"
  88. " srl %0,28\n"
  89. "1:\n"
  90. EX_TABLE(0b,1b)
  91. : "+d" (cc) : "a" (__pa(page_addr)), "d" (xpage_index) : "cc");
  92. if (cc == 3)
  93. return -ENXIO;
  94. if (cc == 2)
  95. return -ENXIO;
  96. if (cc == 1)
  97. return -EIO;
  98. return 0;
  99. }
  100. /*
  101. * Copy a 4kB page of main memory to an expanded memory page
  102. * Arguments
  103. * page_addr: address of source page
  104. * xpage_index: index of expandeded memory page
  105. * Return value
  106. * 0: if operation succeeds
  107. * -EIO: if pgout failed
  108. * -ENXIO: if xpram has vanished
  109. */
  110. static long xpram_page_out (unsigned long page_addr, unsigned int xpage_index)
  111. {
  112. int cc = 2; /* return unused cc 2 if pgin traps */
  113. asm volatile(
  114. " .insn rre,0xb22f0000,%1,%2\n" /* pgout %1,%2 */
  115. "0: ipm %0\n"
  116. " srl %0,28\n"
  117. "1:\n"
  118. EX_TABLE(0b,1b)
  119. : "+d" (cc) : "a" (__pa(page_addr)), "d" (xpage_index) : "cc");
  120. if (cc == 3)
  121. return -ENXIO;
  122. if (cc == 2)
  123. return -ENXIO;
  124. if (cc == 1)
  125. return -EIO;
  126. return 0;
  127. }
  128. /*
  129. * Check if xpram is available.
  130. */
  131. static int xpram_present(void)
  132. {
  133. unsigned long mem_page;
  134. int rc;
  135. mem_page = (unsigned long) __get_free_page(GFP_KERNEL);
  136. if (!mem_page)
  137. return -ENOMEM;
  138. rc = xpram_page_in(mem_page, 0);
  139. free_page(mem_page);
  140. return rc ? -ENXIO : 0;
  141. }
  142. /*
  143. * Return index of the last available xpram page.
  144. */
  145. static unsigned long xpram_highest_page_index(void)
  146. {
  147. unsigned int page_index, add_bit;
  148. unsigned long mem_page;
  149. mem_page = (unsigned long) __get_free_page(GFP_KERNEL);
  150. if (!mem_page)
  151. return 0;
  152. page_index = 0;
  153. add_bit = 1ULL << (sizeof(unsigned int)*8 - 1);
  154. while (add_bit > 0) {
  155. if (xpram_page_in(mem_page, page_index | add_bit) == 0)
  156. page_index |= add_bit;
  157. add_bit >>= 1;
  158. }
  159. free_page (mem_page);
  160. return page_index;
  161. }
  162. /*
  163. * Block device make request function.
  164. */
  165. static blk_qc_t xpram_submit_bio(struct bio *bio)
  166. {
  167. xpram_device_t *xdev = bio->bi_disk->private_data;
  168. struct bio_vec bvec;
  169. struct bvec_iter iter;
  170. unsigned int index;
  171. unsigned long page_addr;
  172. unsigned long bytes;
  173. blk_queue_split(&bio);
  174. if ((bio->bi_iter.bi_sector & 7) != 0 ||
  175. (bio->bi_iter.bi_size & 4095) != 0)
  176. /* Request is not page-aligned. */
  177. goto fail;
  178. if ((bio->bi_iter.bi_size >> 12) > xdev->size)
  179. /* Request size is no page-aligned. */
  180. goto fail;
  181. if ((bio->bi_iter.bi_sector >> 3) > 0xffffffffU - xdev->offset)
  182. goto fail;
  183. index = (bio->bi_iter.bi_sector >> 3) + xdev->offset;
  184. bio_for_each_segment(bvec, bio, iter) {
  185. page_addr = (unsigned long)
  186. kmap(bvec.bv_page) + bvec.bv_offset;
  187. bytes = bvec.bv_len;
  188. if ((page_addr & 4095) != 0 || (bytes & 4095) != 0)
  189. /* More paranoia. */
  190. goto fail;
  191. while (bytes > 0) {
  192. if (bio_data_dir(bio) == READ) {
  193. if (xpram_page_in(page_addr, index) != 0)
  194. goto fail;
  195. } else {
  196. if (xpram_page_out(page_addr, index) != 0)
  197. goto fail;
  198. }
  199. page_addr += 4096;
  200. bytes -= 4096;
  201. index++;
  202. }
  203. }
  204. bio_endio(bio);
  205. return BLK_QC_T_NONE;
  206. fail:
  207. bio_io_error(bio);
  208. return BLK_QC_T_NONE;
  209. }
  210. static int xpram_getgeo(struct block_device *bdev, struct hd_geometry *geo)
  211. {
  212. unsigned long size;
  213. /*
  214. * get geometry: we have to fake one... trim the size to a
  215. * multiple of 64 (32k): tell we have 16 sectors, 4 heads,
  216. * whatever cylinders. Tell also that data starts at sector. 4.
  217. */
  218. size = (xpram_pages * 8) & ~0x3f;
  219. geo->cylinders = size >> 6;
  220. geo->heads = 4;
  221. geo->sectors = 16;
  222. geo->start = 4;
  223. return 0;
  224. }
  225. static const struct block_device_operations xpram_devops =
  226. {
  227. .owner = THIS_MODULE,
  228. .submit_bio = xpram_submit_bio,
  229. .getgeo = xpram_getgeo,
  230. };
  231. /*
  232. * Setup xpram_sizes array.
  233. */
  234. static int __init xpram_setup_sizes(unsigned long pages)
  235. {
  236. unsigned long mem_needed;
  237. unsigned long mem_auto;
  238. unsigned long long size;
  239. char *sizes_end;
  240. int mem_auto_no;
  241. int i;
  242. /* Check number of devices. */
  243. if (devs <= 0 || devs > XPRAM_MAX_DEVS) {
  244. pr_err("%d is not a valid number of XPRAM devices\n",devs);
  245. return -EINVAL;
  246. }
  247. xpram_devs = devs;
  248. /*
  249. * Copy sizes array to xpram_sizes and align partition
  250. * sizes to page boundary.
  251. */
  252. mem_needed = 0;
  253. mem_auto_no = 0;
  254. for (i = 0; i < xpram_devs; i++) {
  255. if (sizes[i]) {
  256. size = simple_strtoull(sizes[i], &sizes_end, 0);
  257. switch (*sizes_end) {
  258. case 'g':
  259. case 'G':
  260. size <<= 20;
  261. break;
  262. case 'm':
  263. case 'M':
  264. size <<= 10;
  265. }
  266. xpram_sizes[i] = (size + 3) & -4UL;
  267. }
  268. if (xpram_sizes[i])
  269. mem_needed += xpram_sizes[i];
  270. else
  271. mem_auto_no++;
  272. }
  273. pr_info(" number of devices (partitions): %d \n", xpram_devs);
  274. for (i = 0; i < xpram_devs; i++) {
  275. if (xpram_sizes[i])
  276. pr_info(" size of partition %d: %u kB\n",
  277. i, xpram_sizes[i]);
  278. else
  279. pr_info(" size of partition %d to be set "
  280. "automatically\n",i);
  281. }
  282. pr_info(" memory needed (for sized partitions): %lu kB\n",
  283. mem_needed);
  284. pr_info(" partitions to be sized automatically: %d\n",
  285. mem_auto_no);
  286. if (mem_needed > pages * 4) {
  287. pr_err("Not enough expanded memory available\n");
  288. return -EINVAL;
  289. }
  290. /*
  291. * partitioning:
  292. * xpram_sizes[i] != 0; partition i has size xpram_sizes[i] kB
  293. * else: ; all partitions with zero xpram_sizes[i]
  294. * partition equally the remaining space
  295. */
  296. if (mem_auto_no) {
  297. mem_auto = ((pages - mem_needed / 4) / mem_auto_no) * 4;
  298. pr_info(" automatically determined "
  299. "partition size: %lu kB\n", mem_auto);
  300. for (i = 0; i < xpram_devs; i++)
  301. if (xpram_sizes[i] == 0)
  302. xpram_sizes[i] = mem_auto;
  303. }
  304. return 0;
  305. }
  306. static int __init xpram_setup_blkdev(void)
  307. {
  308. unsigned long offset;
  309. int i, rc = -ENOMEM;
  310. for (i = 0; i < xpram_devs; i++) {
  311. xpram_disks[i] = alloc_disk(1);
  312. if (!xpram_disks[i])
  313. goto out;
  314. xpram_queues[i] = blk_alloc_queue(NUMA_NO_NODE);
  315. if (!xpram_queues[i]) {
  316. put_disk(xpram_disks[i]);
  317. goto out;
  318. }
  319. blk_queue_flag_set(QUEUE_FLAG_NONROT, xpram_queues[i]);
  320. blk_queue_flag_clear(QUEUE_FLAG_ADD_RANDOM, xpram_queues[i]);
  321. blk_queue_logical_block_size(xpram_queues[i], 4096);
  322. }
  323. /*
  324. * Register xpram major.
  325. */
  326. rc = register_blkdev(XPRAM_MAJOR, XPRAM_NAME);
  327. if (rc < 0)
  328. goto out;
  329. /*
  330. * Setup device structures.
  331. */
  332. offset = 0;
  333. for (i = 0; i < xpram_devs; i++) {
  334. struct gendisk *disk = xpram_disks[i];
  335. xpram_devices[i].size = xpram_sizes[i] / 4;
  336. xpram_devices[i].offset = offset;
  337. offset += xpram_devices[i].size;
  338. disk->major = XPRAM_MAJOR;
  339. disk->first_minor = i;
  340. disk->fops = &xpram_devops;
  341. disk->private_data = &xpram_devices[i];
  342. disk->queue = xpram_queues[i];
  343. sprintf(disk->disk_name, "slram%d", i);
  344. set_capacity(disk, xpram_sizes[i] << 1);
  345. add_disk(disk);
  346. }
  347. return 0;
  348. out:
  349. while (i--) {
  350. blk_cleanup_queue(xpram_queues[i]);
  351. put_disk(xpram_disks[i]);
  352. }
  353. return rc;
  354. }
  355. /*
  356. * Resume failed: Print error message and call panic.
  357. */
  358. static void xpram_resume_error(const char *message)
  359. {
  360. pr_err("Resuming the system failed: %s\n", message);
  361. panic("xpram resume error\n");
  362. }
  363. /*
  364. * Check if xpram setup changed between suspend and resume.
  365. */
  366. static int xpram_restore(struct device *dev)
  367. {
  368. if (!xpram_pages)
  369. return 0;
  370. if (xpram_present() != 0)
  371. xpram_resume_error("xpram disappeared");
  372. if (xpram_pages != xpram_highest_page_index() + 1)
  373. xpram_resume_error("Size of xpram changed");
  374. return 0;
  375. }
  376. static const struct dev_pm_ops xpram_pm_ops = {
  377. .restore = xpram_restore,
  378. };
  379. static struct platform_driver xpram_pdrv = {
  380. .driver = {
  381. .name = XPRAM_NAME,
  382. .pm = &xpram_pm_ops,
  383. },
  384. };
  385. static struct platform_device *xpram_pdev;
  386. /*
  387. * Finally, the init/exit functions.
  388. */
  389. static void __exit xpram_exit(void)
  390. {
  391. int i;
  392. for (i = 0; i < xpram_devs; i++) {
  393. del_gendisk(xpram_disks[i]);
  394. blk_cleanup_queue(xpram_queues[i]);
  395. put_disk(xpram_disks[i]);
  396. }
  397. unregister_blkdev(XPRAM_MAJOR, XPRAM_NAME);
  398. platform_device_unregister(xpram_pdev);
  399. platform_driver_unregister(&xpram_pdrv);
  400. }
  401. static int __init xpram_init(void)
  402. {
  403. int rc;
  404. /* Find out size of expanded memory. */
  405. if (xpram_present() != 0) {
  406. pr_err("No expanded memory available\n");
  407. return -ENODEV;
  408. }
  409. xpram_pages = xpram_highest_page_index() + 1;
  410. pr_info(" %u pages expanded memory found (%lu KB).\n",
  411. xpram_pages, (unsigned long) xpram_pages*4);
  412. rc = xpram_setup_sizes(xpram_pages);
  413. if (rc)
  414. return rc;
  415. rc = platform_driver_register(&xpram_pdrv);
  416. if (rc)
  417. return rc;
  418. xpram_pdev = platform_device_register_simple(XPRAM_NAME, -1, NULL, 0);
  419. if (IS_ERR(xpram_pdev)) {
  420. rc = PTR_ERR(xpram_pdev);
  421. goto fail_platform_driver_unregister;
  422. }
  423. rc = xpram_setup_blkdev();
  424. if (rc)
  425. goto fail_platform_device_unregister;
  426. return 0;
  427. fail_platform_device_unregister:
  428. platform_device_unregister(xpram_pdev);
  429. fail_platform_driver_unregister:
  430. platform_driver_unregister(&xpram_pdrv);
  431. return rc;
  432. }
  433. module_init(xpram_init);
  434. module_exit(xpram_exit);