inode.c 28 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * (C) 2001 Clemson University and The University of Chicago
  4. * Copyright 2018 Omnibond Systems, L.L.C.
  5. *
  6. * See COPYING in top-level directory.
  7. */
  8. /*
  9. * Linux VFS inode operations.
  10. */
  11. #include <linux/bvec.h>
  12. #include "protocol.h"
  13. #include "orangefs-kernel.h"
  14. #include "orangefs-bufmap.h"
  15. static int orangefs_writepage_locked(struct page *page,
  16. struct writeback_control *wbc)
  17. {
  18. struct inode *inode = page->mapping->host;
  19. struct orangefs_write_range *wr = NULL;
  20. struct iov_iter iter;
  21. struct bio_vec bv;
  22. size_t len, wlen;
  23. ssize_t ret;
  24. loff_t off;
  25. set_page_writeback(page);
  26. len = i_size_read(inode);
  27. if (PagePrivate(page)) {
  28. wr = (struct orangefs_write_range *)page_private(page);
  29. WARN_ON(wr->pos >= len);
  30. off = wr->pos;
  31. if (off + wr->len > len)
  32. wlen = len - off;
  33. else
  34. wlen = wr->len;
  35. } else {
  36. WARN_ON(1);
  37. off = page_offset(page);
  38. if (off + PAGE_SIZE > len)
  39. wlen = len - off;
  40. else
  41. wlen = PAGE_SIZE;
  42. }
  43. /* Should've been handled in orangefs_invalidatepage. */
  44. WARN_ON(off == len || off + wlen > len);
  45. bv.bv_page = page;
  46. bv.bv_len = wlen;
  47. bv.bv_offset = off % PAGE_SIZE;
  48. WARN_ON(wlen == 0);
  49. iov_iter_bvec(&iter, WRITE, &bv, 1, wlen);
  50. ret = wait_for_direct_io(ORANGEFS_IO_WRITE, inode, &off, &iter, wlen,
  51. len, wr, NULL, NULL);
  52. if (ret < 0) {
  53. SetPageError(page);
  54. mapping_set_error(page->mapping, ret);
  55. } else {
  56. ret = 0;
  57. }
  58. kfree(detach_page_private(page));
  59. return ret;
  60. }
  61. static int orangefs_writepage(struct page *page, struct writeback_control *wbc)
  62. {
  63. int ret;
  64. ret = orangefs_writepage_locked(page, wbc);
  65. unlock_page(page);
  66. end_page_writeback(page);
  67. return ret;
  68. }
  69. struct orangefs_writepages {
  70. loff_t off;
  71. size_t len;
  72. kuid_t uid;
  73. kgid_t gid;
  74. int maxpages;
  75. int npages;
  76. struct page **pages;
  77. struct bio_vec *bv;
  78. };
  79. static int orangefs_writepages_work(struct orangefs_writepages *ow,
  80. struct writeback_control *wbc)
  81. {
  82. struct inode *inode = ow->pages[0]->mapping->host;
  83. struct orangefs_write_range *wrp, wr;
  84. struct iov_iter iter;
  85. ssize_t ret;
  86. size_t len;
  87. loff_t off;
  88. int i;
  89. len = i_size_read(inode);
  90. for (i = 0; i < ow->npages; i++) {
  91. set_page_writeback(ow->pages[i]);
  92. ow->bv[i].bv_page = ow->pages[i];
  93. ow->bv[i].bv_len = min(page_offset(ow->pages[i]) + PAGE_SIZE,
  94. ow->off + ow->len) -
  95. max(ow->off, page_offset(ow->pages[i]));
  96. if (i == 0)
  97. ow->bv[i].bv_offset = ow->off -
  98. page_offset(ow->pages[i]);
  99. else
  100. ow->bv[i].bv_offset = 0;
  101. }
  102. iov_iter_bvec(&iter, WRITE, ow->bv, ow->npages, ow->len);
  103. WARN_ON(ow->off >= len);
  104. if (ow->off + ow->len > len)
  105. ow->len = len - ow->off;
  106. off = ow->off;
  107. wr.uid = ow->uid;
  108. wr.gid = ow->gid;
  109. ret = wait_for_direct_io(ORANGEFS_IO_WRITE, inode, &off, &iter, ow->len,
  110. 0, &wr, NULL, NULL);
  111. if (ret < 0) {
  112. for (i = 0; i < ow->npages; i++) {
  113. SetPageError(ow->pages[i]);
  114. mapping_set_error(ow->pages[i]->mapping, ret);
  115. if (PagePrivate(ow->pages[i])) {
  116. wrp = (struct orangefs_write_range *)
  117. page_private(ow->pages[i]);
  118. ClearPagePrivate(ow->pages[i]);
  119. put_page(ow->pages[i]);
  120. kfree(wrp);
  121. }
  122. end_page_writeback(ow->pages[i]);
  123. unlock_page(ow->pages[i]);
  124. }
  125. } else {
  126. ret = 0;
  127. for (i = 0; i < ow->npages; i++) {
  128. if (PagePrivate(ow->pages[i])) {
  129. wrp = (struct orangefs_write_range *)
  130. page_private(ow->pages[i]);
  131. ClearPagePrivate(ow->pages[i]);
  132. put_page(ow->pages[i]);
  133. kfree(wrp);
  134. }
  135. end_page_writeback(ow->pages[i]);
  136. unlock_page(ow->pages[i]);
  137. }
  138. }
  139. return ret;
  140. }
  141. static int orangefs_writepages_callback(struct page *page,
  142. struct writeback_control *wbc, void *data)
  143. {
  144. struct orangefs_writepages *ow = data;
  145. struct orangefs_write_range *wr;
  146. int ret;
  147. if (!PagePrivate(page)) {
  148. unlock_page(page);
  149. /* It's not private so there's nothing to write, right? */
  150. printk("writepages_callback not private!\n");
  151. BUG();
  152. return 0;
  153. }
  154. wr = (struct orangefs_write_range *)page_private(page);
  155. ret = -1;
  156. if (ow->npages == 0) {
  157. ow->off = wr->pos;
  158. ow->len = wr->len;
  159. ow->uid = wr->uid;
  160. ow->gid = wr->gid;
  161. ow->pages[ow->npages++] = page;
  162. ret = 0;
  163. goto done;
  164. }
  165. if (!uid_eq(ow->uid, wr->uid) || !gid_eq(ow->gid, wr->gid)) {
  166. orangefs_writepages_work(ow, wbc);
  167. ow->npages = 0;
  168. ret = -1;
  169. goto done;
  170. }
  171. if (ow->off + ow->len == wr->pos) {
  172. ow->len += wr->len;
  173. ow->pages[ow->npages++] = page;
  174. ret = 0;
  175. goto done;
  176. }
  177. done:
  178. if (ret == -1) {
  179. if (ow->npages) {
  180. orangefs_writepages_work(ow, wbc);
  181. ow->npages = 0;
  182. }
  183. ret = orangefs_writepage_locked(page, wbc);
  184. mapping_set_error(page->mapping, ret);
  185. unlock_page(page);
  186. end_page_writeback(page);
  187. } else {
  188. if (ow->npages == ow->maxpages) {
  189. orangefs_writepages_work(ow, wbc);
  190. ow->npages = 0;
  191. }
  192. }
  193. return ret;
  194. }
  195. static int orangefs_writepages(struct address_space *mapping,
  196. struct writeback_control *wbc)
  197. {
  198. struct orangefs_writepages *ow;
  199. struct blk_plug plug;
  200. int ret;
  201. ow = kzalloc(sizeof(struct orangefs_writepages), GFP_KERNEL);
  202. if (!ow)
  203. return -ENOMEM;
  204. ow->maxpages = orangefs_bufmap_size_query()/PAGE_SIZE;
  205. ow->pages = kcalloc(ow->maxpages, sizeof(struct page *), GFP_KERNEL);
  206. if (!ow->pages) {
  207. kfree(ow);
  208. return -ENOMEM;
  209. }
  210. ow->bv = kcalloc(ow->maxpages, sizeof(struct bio_vec), GFP_KERNEL);
  211. if (!ow->bv) {
  212. kfree(ow->pages);
  213. kfree(ow);
  214. return -ENOMEM;
  215. }
  216. blk_start_plug(&plug);
  217. ret = write_cache_pages(mapping, wbc, orangefs_writepages_callback, ow);
  218. if (ow->npages)
  219. ret = orangefs_writepages_work(ow, wbc);
  220. blk_finish_plug(&plug);
  221. kfree(ow->pages);
  222. kfree(ow->bv);
  223. kfree(ow);
  224. return ret;
  225. }
  226. static int orangefs_launder_page(struct page *);
  227. static int orangefs_readpage(struct file *file, struct page *page)
  228. {
  229. struct inode *inode = page->mapping->host;
  230. struct iov_iter iter;
  231. struct bio_vec bv;
  232. ssize_t ret;
  233. loff_t off; /* offset into this page */
  234. pgoff_t index; /* which page */
  235. struct page *next_page;
  236. char *kaddr;
  237. loff_t read_size;
  238. int buffer_index = -1; /* orangefs shared memory slot */
  239. int slot_index; /* index into slot */
  240. int remaining;
  241. /*
  242. * Get up to this many bytes from Orangefs at a time and try
  243. * to fill them into the page cache at once. Tests with dd made
  244. * this seem like a reasonable static number, if there was
  245. * interest perhaps this number could be made setable through
  246. * sysfs...
  247. */
  248. read_size = 524288;
  249. if (PageDirty(page))
  250. orangefs_launder_page(page);
  251. off = page_offset(page);
  252. index = off >> PAGE_SHIFT;
  253. bv.bv_page = page;
  254. bv.bv_len = PAGE_SIZE;
  255. bv.bv_offset = 0;
  256. iov_iter_bvec(&iter, READ, &bv, 1, PAGE_SIZE);
  257. ret = wait_for_direct_io(ORANGEFS_IO_READ, inode, &off, &iter,
  258. read_size, inode->i_size, NULL, &buffer_index, file);
  259. remaining = ret;
  260. /* this will only zero remaining unread portions of the page data */
  261. iov_iter_zero(~0U, &iter);
  262. /* takes care of potential aliasing */
  263. flush_dcache_page(page);
  264. if (ret < 0) {
  265. SetPageError(page);
  266. unlock_page(page);
  267. goto out;
  268. } else {
  269. SetPageUptodate(page);
  270. if (PageError(page))
  271. ClearPageError(page);
  272. ret = 0;
  273. }
  274. /* unlock the page after the ->readpage() routine completes */
  275. unlock_page(page);
  276. if (remaining > PAGE_SIZE) {
  277. slot_index = 0;
  278. while ((remaining - PAGE_SIZE) >= PAGE_SIZE) {
  279. remaining -= PAGE_SIZE;
  280. /*
  281. * It is an optimization to try and fill more than one
  282. * page... by now we've already gotten the single
  283. * page we were after, if stuff doesn't seem to
  284. * be going our way at this point just return
  285. * and hope for the best.
  286. *
  287. * If we look for pages and they're already there is
  288. * one reason to give up, and if they're not there
  289. * and we can't create them is another reason.
  290. */
  291. index++;
  292. slot_index++;
  293. next_page = find_get_page(inode->i_mapping, index);
  294. if (next_page) {
  295. gossip_debug(GOSSIP_FILE_DEBUG,
  296. "%s: found next page, quitting\n",
  297. __func__);
  298. put_page(next_page);
  299. goto out;
  300. }
  301. next_page = find_or_create_page(inode->i_mapping,
  302. index,
  303. GFP_KERNEL);
  304. /*
  305. * I've never hit this, leave it as a printk for
  306. * now so it will be obvious.
  307. */
  308. if (!next_page) {
  309. printk("%s: can't create next page, quitting\n",
  310. __func__);
  311. goto out;
  312. }
  313. kaddr = kmap_atomic(next_page);
  314. orangefs_bufmap_page_fill(kaddr,
  315. buffer_index,
  316. slot_index);
  317. kunmap_atomic(kaddr);
  318. SetPageUptodate(next_page);
  319. unlock_page(next_page);
  320. put_page(next_page);
  321. }
  322. }
  323. out:
  324. if (buffer_index != -1)
  325. orangefs_bufmap_put(buffer_index);
  326. return ret;
  327. }
  328. static int orangefs_write_begin(struct file *file,
  329. struct address_space *mapping,
  330. loff_t pos, unsigned len, unsigned flags, struct page **pagep,
  331. void **fsdata)
  332. {
  333. struct orangefs_write_range *wr;
  334. struct page *page;
  335. pgoff_t index;
  336. int ret;
  337. index = pos >> PAGE_SHIFT;
  338. page = grab_cache_page_write_begin(mapping, index, flags);
  339. if (!page)
  340. return -ENOMEM;
  341. *pagep = page;
  342. if (PageDirty(page) && !PagePrivate(page)) {
  343. /*
  344. * Should be impossible. If it happens, launder the page
  345. * since we don't know what's dirty. This will WARN in
  346. * orangefs_writepage_locked.
  347. */
  348. ret = orangefs_launder_page(page);
  349. if (ret)
  350. return ret;
  351. }
  352. if (PagePrivate(page)) {
  353. struct orangefs_write_range *wr;
  354. wr = (struct orangefs_write_range *)page_private(page);
  355. if (wr->pos + wr->len == pos &&
  356. uid_eq(wr->uid, current_fsuid()) &&
  357. gid_eq(wr->gid, current_fsgid())) {
  358. wr->len += len;
  359. goto okay;
  360. } else {
  361. ret = orangefs_launder_page(page);
  362. if (ret)
  363. return ret;
  364. }
  365. }
  366. wr = kmalloc(sizeof *wr, GFP_KERNEL);
  367. if (!wr)
  368. return -ENOMEM;
  369. wr->pos = pos;
  370. wr->len = len;
  371. wr->uid = current_fsuid();
  372. wr->gid = current_fsgid();
  373. attach_page_private(page, wr);
  374. okay:
  375. return 0;
  376. }
  377. static int orangefs_write_end(struct file *file, struct address_space *mapping,
  378. loff_t pos, unsigned len, unsigned copied, struct page *page, void *fsdata)
  379. {
  380. struct inode *inode = page->mapping->host;
  381. loff_t last_pos = pos + copied;
  382. /*
  383. * No need to use i_size_read() here, the i_size
  384. * cannot change under us because we hold the i_mutex.
  385. */
  386. if (last_pos > inode->i_size)
  387. i_size_write(inode, last_pos);
  388. /* zero the stale part of the page if we did a short copy */
  389. if (!PageUptodate(page)) {
  390. unsigned from = pos & (PAGE_SIZE - 1);
  391. if (copied < len) {
  392. zero_user(page, from + copied, len - copied);
  393. }
  394. /* Set fully written pages uptodate. */
  395. if (pos == page_offset(page) &&
  396. (len == PAGE_SIZE || pos + len == inode->i_size)) {
  397. zero_user_segment(page, from + copied, PAGE_SIZE);
  398. SetPageUptodate(page);
  399. }
  400. }
  401. set_page_dirty(page);
  402. unlock_page(page);
  403. put_page(page);
  404. mark_inode_dirty_sync(file_inode(file));
  405. return copied;
  406. }
  407. static void orangefs_invalidatepage(struct page *page,
  408. unsigned int offset,
  409. unsigned int length)
  410. {
  411. struct orangefs_write_range *wr;
  412. wr = (struct orangefs_write_range *)page_private(page);
  413. if (offset == 0 && length == PAGE_SIZE) {
  414. kfree(detach_page_private(page));
  415. return;
  416. /* write range entirely within invalidate range (or equal) */
  417. } else if (page_offset(page) + offset <= wr->pos &&
  418. wr->pos + wr->len <= page_offset(page) + offset + length) {
  419. kfree(detach_page_private(page));
  420. /* XXX is this right? only caller in fs */
  421. cancel_dirty_page(page);
  422. return;
  423. /* invalidate range chops off end of write range */
  424. } else if (wr->pos < page_offset(page) + offset &&
  425. wr->pos + wr->len <= page_offset(page) + offset + length &&
  426. page_offset(page) + offset < wr->pos + wr->len) {
  427. size_t x;
  428. x = wr->pos + wr->len - (page_offset(page) + offset);
  429. WARN_ON(x > wr->len);
  430. wr->len -= x;
  431. wr->uid = current_fsuid();
  432. wr->gid = current_fsgid();
  433. /* invalidate range chops off beginning of write range */
  434. } else if (page_offset(page) + offset <= wr->pos &&
  435. page_offset(page) + offset + length < wr->pos + wr->len &&
  436. wr->pos < page_offset(page) + offset + length) {
  437. size_t x;
  438. x = page_offset(page) + offset + length - wr->pos;
  439. WARN_ON(x > wr->len);
  440. wr->pos += x;
  441. wr->len -= x;
  442. wr->uid = current_fsuid();
  443. wr->gid = current_fsgid();
  444. /* invalidate range entirely within write range (punch hole) */
  445. } else if (wr->pos < page_offset(page) + offset &&
  446. page_offset(page) + offset + length < wr->pos + wr->len) {
  447. /* XXX what do we do here... should not WARN_ON */
  448. WARN_ON(1);
  449. /* punch hole */
  450. /*
  451. * should we just ignore this and write it out anyway?
  452. * it hardly makes sense
  453. */
  454. return;
  455. /* non-overlapping ranges */
  456. } else {
  457. /* WARN if they do overlap */
  458. if (!((page_offset(page) + offset + length <= wr->pos) ^
  459. (wr->pos + wr->len <= page_offset(page) + offset))) {
  460. WARN_ON(1);
  461. printk("invalidate range offset %llu length %u\n",
  462. page_offset(page) + offset, length);
  463. printk("write range offset %llu length %zu\n",
  464. wr->pos, wr->len);
  465. }
  466. return;
  467. }
  468. /*
  469. * Above there are returns where wr is freed or where we WARN.
  470. * Thus the following runs if wr was modified above.
  471. */
  472. orangefs_launder_page(page);
  473. }
  474. static int orangefs_releasepage(struct page *page, gfp_t foo)
  475. {
  476. return !PagePrivate(page);
  477. }
  478. static void orangefs_freepage(struct page *page)
  479. {
  480. kfree(detach_page_private(page));
  481. }
  482. static int orangefs_launder_page(struct page *page)
  483. {
  484. int r = 0;
  485. struct writeback_control wbc = {
  486. .sync_mode = WB_SYNC_ALL,
  487. .nr_to_write = 0,
  488. };
  489. wait_on_page_writeback(page);
  490. if (clear_page_dirty_for_io(page)) {
  491. r = orangefs_writepage_locked(page, &wbc);
  492. end_page_writeback(page);
  493. }
  494. return r;
  495. }
  496. static ssize_t orangefs_direct_IO(struct kiocb *iocb,
  497. struct iov_iter *iter)
  498. {
  499. /*
  500. * Comment from original do_readv_writev:
  501. * Common entry point for read/write/readv/writev
  502. * This function will dispatch it to either the direct I/O
  503. * or buffered I/O path depending on the mount options and/or
  504. * augmented/extended metadata attached to the file.
  505. * Note: File extended attributes override any mount options.
  506. */
  507. struct file *file = iocb->ki_filp;
  508. loff_t pos = iocb->ki_pos;
  509. enum ORANGEFS_io_type type = iov_iter_rw(iter) == WRITE ?
  510. ORANGEFS_IO_WRITE : ORANGEFS_IO_READ;
  511. loff_t *offset = &pos;
  512. struct inode *inode = file->f_mapping->host;
  513. struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode);
  514. struct orangefs_khandle *handle = &orangefs_inode->refn.khandle;
  515. size_t count = iov_iter_count(iter);
  516. ssize_t total_count = 0;
  517. ssize_t ret = -EINVAL;
  518. int i = 0;
  519. gossip_debug(GOSSIP_FILE_DEBUG,
  520. "%s-BEGIN(%pU): count(%d) after estimate_max_iovecs.\n",
  521. __func__,
  522. handle,
  523. (int)count);
  524. if (type == ORANGEFS_IO_WRITE) {
  525. gossip_debug(GOSSIP_FILE_DEBUG,
  526. "%s(%pU): proceeding with offset : %llu, "
  527. "size %d\n",
  528. __func__,
  529. handle,
  530. llu(*offset),
  531. (int)count);
  532. }
  533. if (count == 0) {
  534. ret = 0;
  535. goto out;
  536. }
  537. while (iov_iter_count(iter)) {
  538. size_t each_count = iov_iter_count(iter);
  539. size_t amt_complete;
  540. i++;
  541. /* how much to transfer in this loop iteration */
  542. if (each_count > orangefs_bufmap_size_query())
  543. each_count = orangefs_bufmap_size_query();
  544. gossip_debug(GOSSIP_FILE_DEBUG,
  545. "%s(%pU): size of each_count(%d)\n",
  546. __func__,
  547. handle,
  548. (int)each_count);
  549. gossip_debug(GOSSIP_FILE_DEBUG,
  550. "%s(%pU): BEFORE wait_for_io: offset is %d\n",
  551. __func__,
  552. handle,
  553. (int)*offset);
  554. ret = wait_for_direct_io(type, inode, offset, iter,
  555. each_count, 0, NULL, NULL, file);
  556. gossip_debug(GOSSIP_FILE_DEBUG,
  557. "%s(%pU): return from wait_for_io:%d\n",
  558. __func__,
  559. handle,
  560. (int)ret);
  561. if (ret < 0)
  562. goto out;
  563. *offset += ret;
  564. total_count += ret;
  565. amt_complete = ret;
  566. gossip_debug(GOSSIP_FILE_DEBUG,
  567. "%s(%pU): AFTER wait_for_io: offset is %d\n",
  568. __func__,
  569. handle,
  570. (int)*offset);
  571. /*
  572. * if we got a short I/O operations,
  573. * fall out and return what we got so far
  574. */
  575. if (amt_complete < each_count)
  576. break;
  577. } /*end while */
  578. out:
  579. if (total_count > 0)
  580. ret = total_count;
  581. if (ret > 0) {
  582. if (type == ORANGEFS_IO_READ) {
  583. file_accessed(file);
  584. } else {
  585. file_update_time(file);
  586. if (*offset > i_size_read(inode))
  587. i_size_write(inode, *offset);
  588. }
  589. }
  590. gossip_debug(GOSSIP_FILE_DEBUG,
  591. "%s(%pU): Value(%d) returned.\n",
  592. __func__,
  593. handle,
  594. (int)ret);
  595. return ret;
  596. }
  597. /** ORANGEFS2 implementation of address space operations */
  598. static const struct address_space_operations orangefs_address_operations = {
  599. .writepage = orangefs_writepage,
  600. .readpage = orangefs_readpage,
  601. .writepages = orangefs_writepages,
  602. .set_page_dirty = __set_page_dirty_nobuffers,
  603. .write_begin = orangefs_write_begin,
  604. .write_end = orangefs_write_end,
  605. .invalidatepage = orangefs_invalidatepage,
  606. .releasepage = orangefs_releasepage,
  607. .freepage = orangefs_freepage,
  608. .launder_page = orangefs_launder_page,
  609. .direct_IO = orangefs_direct_IO,
  610. };
  611. vm_fault_t orangefs_page_mkwrite(struct vm_fault *vmf)
  612. {
  613. struct page *page = vmf->page;
  614. struct inode *inode = file_inode(vmf->vma->vm_file);
  615. struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode);
  616. unsigned long *bitlock = &orangefs_inode->bitlock;
  617. vm_fault_t ret;
  618. struct orangefs_write_range *wr;
  619. sb_start_pagefault(inode->i_sb);
  620. if (wait_on_bit(bitlock, 1, TASK_KILLABLE)) {
  621. ret = VM_FAULT_RETRY;
  622. goto out;
  623. }
  624. lock_page(page);
  625. if (PageDirty(page) && !PagePrivate(page)) {
  626. /*
  627. * Should be impossible. If it happens, launder the page
  628. * since we don't know what's dirty. This will WARN in
  629. * orangefs_writepage_locked.
  630. */
  631. if (orangefs_launder_page(page)) {
  632. ret = VM_FAULT_LOCKED|VM_FAULT_RETRY;
  633. goto out;
  634. }
  635. }
  636. if (PagePrivate(page)) {
  637. wr = (struct orangefs_write_range *)page_private(page);
  638. if (uid_eq(wr->uid, current_fsuid()) &&
  639. gid_eq(wr->gid, current_fsgid())) {
  640. wr->pos = page_offset(page);
  641. wr->len = PAGE_SIZE;
  642. goto okay;
  643. } else {
  644. if (orangefs_launder_page(page)) {
  645. ret = VM_FAULT_LOCKED|VM_FAULT_RETRY;
  646. goto out;
  647. }
  648. }
  649. }
  650. wr = kmalloc(sizeof *wr, GFP_KERNEL);
  651. if (!wr) {
  652. ret = VM_FAULT_LOCKED|VM_FAULT_RETRY;
  653. goto out;
  654. }
  655. wr->pos = page_offset(page);
  656. wr->len = PAGE_SIZE;
  657. wr->uid = current_fsuid();
  658. wr->gid = current_fsgid();
  659. attach_page_private(page, wr);
  660. okay:
  661. file_update_time(vmf->vma->vm_file);
  662. if (page->mapping != inode->i_mapping) {
  663. unlock_page(page);
  664. ret = VM_FAULT_LOCKED|VM_FAULT_NOPAGE;
  665. goto out;
  666. }
  667. /*
  668. * We mark the page dirty already here so that when freeze is in
  669. * progress, we are guaranteed that writeback during freezing will
  670. * see the dirty page and writeprotect it again.
  671. */
  672. set_page_dirty(page);
  673. wait_for_stable_page(page);
  674. ret = VM_FAULT_LOCKED;
  675. out:
  676. sb_end_pagefault(inode->i_sb);
  677. return ret;
  678. }
  679. static int orangefs_setattr_size(struct inode *inode, struct iattr *iattr)
  680. {
  681. struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode);
  682. struct orangefs_kernel_op_s *new_op;
  683. loff_t orig_size;
  684. int ret = -EINVAL;
  685. gossip_debug(GOSSIP_INODE_DEBUG,
  686. "%s: %pU: Handle is %pU | fs_id %d | size is %llu\n",
  687. __func__,
  688. get_khandle_from_ino(inode),
  689. &orangefs_inode->refn.khandle,
  690. orangefs_inode->refn.fs_id,
  691. iattr->ia_size);
  692. /* Ensure that we have a up to date size, so we know if it changed. */
  693. ret = orangefs_inode_getattr(inode, ORANGEFS_GETATTR_SIZE);
  694. if (ret == -ESTALE)
  695. ret = -EIO;
  696. if (ret) {
  697. gossip_err("%s: orangefs_inode_getattr failed, ret:%d:.\n",
  698. __func__, ret);
  699. return ret;
  700. }
  701. orig_size = i_size_read(inode);
  702. /* This is truncate_setsize in a different order. */
  703. truncate_pagecache(inode, iattr->ia_size);
  704. i_size_write(inode, iattr->ia_size);
  705. if (iattr->ia_size > orig_size)
  706. pagecache_isize_extended(inode, orig_size, iattr->ia_size);
  707. new_op = op_alloc(ORANGEFS_VFS_OP_TRUNCATE);
  708. if (!new_op)
  709. return -ENOMEM;
  710. new_op->upcall.req.truncate.refn = orangefs_inode->refn;
  711. new_op->upcall.req.truncate.size = (__s64) iattr->ia_size;
  712. ret = service_operation(new_op,
  713. __func__,
  714. get_interruptible_flag(inode));
  715. /*
  716. * the truncate has no downcall members to retrieve, but
  717. * the status value tells us if it went through ok or not
  718. */
  719. gossip_debug(GOSSIP_INODE_DEBUG, "%s: ret:%d:\n", __func__, ret);
  720. op_release(new_op);
  721. if (ret != 0)
  722. return ret;
  723. if (orig_size != i_size_read(inode))
  724. iattr->ia_valid |= ATTR_CTIME | ATTR_MTIME;
  725. return ret;
  726. }
  727. int __orangefs_setattr(struct inode *inode, struct iattr *iattr)
  728. {
  729. int ret;
  730. if (iattr->ia_valid & ATTR_MODE) {
  731. if (iattr->ia_mode & (S_ISVTX)) {
  732. if (is_root_handle(inode)) {
  733. /*
  734. * allow sticky bit to be set on root (since
  735. * it shows up that way by default anyhow),
  736. * but don't show it to the server
  737. */
  738. iattr->ia_mode -= S_ISVTX;
  739. } else {
  740. gossip_debug(GOSSIP_UTILS_DEBUG,
  741. "User attempted to set sticky bit on non-root directory; returning EINVAL.\n");
  742. ret = -EINVAL;
  743. goto out;
  744. }
  745. }
  746. if (iattr->ia_mode & (S_ISUID)) {
  747. gossip_debug(GOSSIP_UTILS_DEBUG,
  748. "Attempting to set setuid bit (not supported); returning EINVAL.\n");
  749. ret = -EINVAL;
  750. goto out;
  751. }
  752. }
  753. if (iattr->ia_valid & ATTR_SIZE) {
  754. ret = orangefs_setattr_size(inode, iattr);
  755. if (ret)
  756. goto out;
  757. }
  758. again:
  759. spin_lock(&inode->i_lock);
  760. if (ORANGEFS_I(inode)->attr_valid) {
  761. if (uid_eq(ORANGEFS_I(inode)->attr_uid, current_fsuid()) &&
  762. gid_eq(ORANGEFS_I(inode)->attr_gid, current_fsgid())) {
  763. ORANGEFS_I(inode)->attr_valid = iattr->ia_valid;
  764. } else {
  765. spin_unlock(&inode->i_lock);
  766. write_inode_now(inode, 1);
  767. goto again;
  768. }
  769. } else {
  770. ORANGEFS_I(inode)->attr_valid = iattr->ia_valid;
  771. ORANGEFS_I(inode)->attr_uid = current_fsuid();
  772. ORANGEFS_I(inode)->attr_gid = current_fsgid();
  773. }
  774. setattr_copy(inode, iattr);
  775. spin_unlock(&inode->i_lock);
  776. mark_inode_dirty(inode);
  777. if (iattr->ia_valid & ATTR_MODE)
  778. /* change mod on a file that has ACLs */
  779. ret = posix_acl_chmod(inode, inode->i_mode);
  780. ret = 0;
  781. out:
  782. return ret;
  783. }
  784. /*
  785. * Change attributes of an object referenced by dentry.
  786. */
  787. int orangefs_setattr(struct dentry *dentry, struct iattr *iattr)
  788. {
  789. int ret;
  790. gossip_debug(GOSSIP_INODE_DEBUG, "__orangefs_setattr: called on %pd\n",
  791. dentry);
  792. ret = setattr_prepare(dentry, iattr);
  793. if (ret)
  794. goto out;
  795. ret = __orangefs_setattr(d_inode(dentry), iattr);
  796. sync_inode_metadata(d_inode(dentry), 1);
  797. out:
  798. gossip_debug(GOSSIP_INODE_DEBUG, "orangefs_setattr: returning %d\n",
  799. ret);
  800. return ret;
  801. }
  802. /*
  803. * Obtain attributes of an object given a dentry
  804. */
  805. int orangefs_getattr(const struct path *path, struct kstat *stat,
  806. u32 request_mask, unsigned int flags)
  807. {
  808. int ret;
  809. struct inode *inode = path->dentry->d_inode;
  810. gossip_debug(GOSSIP_INODE_DEBUG,
  811. "orangefs_getattr: called on %pd mask %u\n",
  812. path->dentry, request_mask);
  813. ret = orangefs_inode_getattr(inode,
  814. request_mask & STATX_SIZE ? ORANGEFS_GETATTR_SIZE : 0);
  815. if (ret == 0) {
  816. generic_fillattr(inode, stat);
  817. /* override block size reported to stat */
  818. if (!(request_mask & STATX_SIZE))
  819. stat->result_mask &= ~STATX_SIZE;
  820. stat->attributes_mask = STATX_ATTR_IMMUTABLE |
  821. STATX_ATTR_APPEND;
  822. if (inode->i_flags & S_IMMUTABLE)
  823. stat->attributes |= STATX_ATTR_IMMUTABLE;
  824. if (inode->i_flags & S_APPEND)
  825. stat->attributes |= STATX_ATTR_APPEND;
  826. }
  827. return ret;
  828. }
  829. int orangefs_permission(struct inode *inode, int mask)
  830. {
  831. int ret;
  832. if (mask & MAY_NOT_BLOCK)
  833. return -ECHILD;
  834. gossip_debug(GOSSIP_INODE_DEBUG, "%s: refreshing\n", __func__);
  835. /* Make sure the permission (and other common attrs) are up to date. */
  836. ret = orangefs_inode_getattr(inode, 0);
  837. if (ret < 0)
  838. return ret;
  839. return generic_permission(inode, mask);
  840. }
  841. int orangefs_update_time(struct inode *inode, struct timespec64 *time, int flags)
  842. {
  843. struct iattr iattr;
  844. gossip_debug(GOSSIP_INODE_DEBUG, "orangefs_update_time: %pU\n",
  845. get_khandle_from_ino(inode));
  846. generic_update_time(inode, time, flags);
  847. memset(&iattr, 0, sizeof iattr);
  848. if (flags & S_ATIME)
  849. iattr.ia_valid |= ATTR_ATIME;
  850. if (flags & S_CTIME)
  851. iattr.ia_valid |= ATTR_CTIME;
  852. if (flags & S_MTIME)
  853. iattr.ia_valid |= ATTR_MTIME;
  854. return __orangefs_setattr(inode, &iattr);
  855. }
  856. /* ORANGEFS2 implementation of VFS inode operations for files */
  857. static const struct inode_operations orangefs_file_inode_operations = {
  858. .get_acl = orangefs_get_acl,
  859. .set_acl = orangefs_set_acl,
  860. .setattr = orangefs_setattr,
  861. .getattr = orangefs_getattr,
  862. .listxattr = orangefs_listxattr,
  863. .permission = orangefs_permission,
  864. .update_time = orangefs_update_time,
  865. };
  866. static int orangefs_init_iops(struct inode *inode)
  867. {
  868. inode->i_mapping->a_ops = &orangefs_address_operations;
  869. switch (inode->i_mode & S_IFMT) {
  870. case S_IFREG:
  871. inode->i_op = &orangefs_file_inode_operations;
  872. inode->i_fop = &orangefs_file_operations;
  873. break;
  874. case S_IFLNK:
  875. inode->i_op = &orangefs_symlink_inode_operations;
  876. break;
  877. case S_IFDIR:
  878. inode->i_op = &orangefs_dir_inode_operations;
  879. inode->i_fop = &orangefs_dir_operations;
  880. break;
  881. default:
  882. gossip_debug(GOSSIP_INODE_DEBUG,
  883. "%s: unsupported mode\n",
  884. __func__);
  885. return -EINVAL;
  886. }
  887. return 0;
  888. }
  889. /*
  890. * Given an ORANGEFS object identifier (fsid, handle), convert it into
  891. * a ino_t type that will be used as a hash-index from where the handle will
  892. * be searched for in the VFS hash table of inodes.
  893. */
  894. static inline ino_t orangefs_handle_hash(struct orangefs_object_kref *ref)
  895. {
  896. if (!ref)
  897. return 0;
  898. return orangefs_khandle_to_ino(&(ref->khandle));
  899. }
  900. /*
  901. * Called to set up an inode from iget5_locked.
  902. */
  903. static int orangefs_set_inode(struct inode *inode, void *data)
  904. {
  905. struct orangefs_object_kref *ref = (struct orangefs_object_kref *) data;
  906. ORANGEFS_I(inode)->refn.fs_id = ref->fs_id;
  907. ORANGEFS_I(inode)->refn.khandle = ref->khandle;
  908. ORANGEFS_I(inode)->attr_valid = 0;
  909. hash_init(ORANGEFS_I(inode)->xattr_cache);
  910. ORANGEFS_I(inode)->mapping_time = jiffies - 1;
  911. ORANGEFS_I(inode)->bitlock = 0;
  912. return 0;
  913. }
  914. /*
  915. * Called to determine if handles match.
  916. */
  917. static int orangefs_test_inode(struct inode *inode, void *data)
  918. {
  919. struct orangefs_object_kref *ref = (struct orangefs_object_kref *) data;
  920. struct orangefs_inode_s *orangefs_inode = NULL;
  921. orangefs_inode = ORANGEFS_I(inode);
  922. /* test handles and fs_ids... */
  923. return (!ORANGEFS_khandle_cmp(&(orangefs_inode->refn.khandle),
  924. &(ref->khandle)) &&
  925. orangefs_inode->refn.fs_id == ref->fs_id);
  926. }
  927. /*
  928. * Front-end to lookup the inode-cache maintained by the VFS using the ORANGEFS
  929. * file handle.
  930. *
  931. * @sb: the file system super block instance.
  932. * @ref: The ORANGEFS object for which we are trying to locate an inode.
  933. */
  934. struct inode *orangefs_iget(struct super_block *sb,
  935. struct orangefs_object_kref *ref)
  936. {
  937. struct inode *inode = NULL;
  938. unsigned long hash;
  939. int error;
  940. hash = orangefs_handle_hash(ref);
  941. inode = iget5_locked(sb,
  942. hash,
  943. orangefs_test_inode,
  944. orangefs_set_inode,
  945. ref);
  946. if (!inode)
  947. return ERR_PTR(-ENOMEM);
  948. if (!(inode->i_state & I_NEW))
  949. return inode;
  950. error = orangefs_inode_getattr(inode, ORANGEFS_GETATTR_NEW);
  951. if (error) {
  952. iget_failed(inode);
  953. return ERR_PTR(error);
  954. }
  955. inode->i_ino = hash; /* needed for stat etc */
  956. orangefs_init_iops(inode);
  957. unlock_new_inode(inode);
  958. gossip_debug(GOSSIP_INODE_DEBUG,
  959. "iget handle %pU, fsid %d hash %ld i_ino %lu\n",
  960. &ref->khandle,
  961. ref->fs_id,
  962. hash,
  963. inode->i_ino);
  964. return inode;
  965. }
  966. /*
  967. * Allocate an inode for a newly created file and insert it into the inode hash.
  968. */
  969. struct inode *orangefs_new_inode(struct super_block *sb, struct inode *dir,
  970. int mode, dev_t dev, struct orangefs_object_kref *ref)
  971. {
  972. unsigned long hash = orangefs_handle_hash(ref);
  973. struct inode *inode;
  974. int error;
  975. gossip_debug(GOSSIP_INODE_DEBUG,
  976. "%s:(sb is %p | MAJOR(dev)=%u | MINOR(dev)=%u mode=%o)\n",
  977. __func__,
  978. sb,
  979. MAJOR(dev),
  980. MINOR(dev),
  981. mode);
  982. inode = new_inode(sb);
  983. if (!inode)
  984. return ERR_PTR(-ENOMEM);
  985. orangefs_set_inode(inode, ref);
  986. inode->i_ino = hash; /* needed for stat etc */
  987. error = orangefs_inode_getattr(inode, ORANGEFS_GETATTR_NEW);
  988. if (error)
  989. goto out_iput;
  990. orangefs_init_iops(inode);
  991. inode->i_rdev = dev;
  992. error = insert_inode_locked4(inode, hash, orangefs_test_inode, ref);
  993. if (error < 0)
  994. goto out_iput;
  995. gossip_debug(GOSSIP_INODE_DEBUG,
  996. "Initializing ACL's for inode %pU\n",
  997. get_khandle_from_ino(inode));
  998. orangefs_init_acl(inode, dir);
  999. return inode;
  1000. out_iput:
  1001. iput(inode);
  1002. return ERR_PTR(error);
  1003. }