xfs_rw.c 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426
  1. /*
  2. * Copyright (c) 2000-2006 Silicon Graphics, Inc.
  3. * All Rights Reserved.
  4. *
  5. * This program is free software; you can redistribute it and/or
  6. * modify it under the terms of the GNU General Public License as
  7. * published by the Free Software Foundation.
  8. *
  9. * This program is distributed in the hope that it would be useful,
  10. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  12. * GNU General Public License for more details.
  13. *
  14. * You should have received a copy of the GNU General Public License
  15. * along with this program; if not, write the Free Software Foundation,
  16. * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  17. */
  18. #include "xfs.h"
  19. #include "xfs_fs.h"
  20. #include "xfs_types.h"
  21. #include "xfs_bit.h"
  22. #include "xfs_log.h"
  23. #include "xfs_inum.h"
  24. #include "xfs_trans.h"
  25. #include "xfs_sb.h"
  26. #include "xfs_ag.h"
  27. #include "xfs_dir2.h"
  28. #include "xfs_dmapi.h"
  29. #include "xfs_mount.h"
  30. #include "xfs_bmap_btree.h"
  31. #include "xfs_alloc_btree.h"
  32. #include "xfs_ialloc_btree.h"
  33. #include "xfs_dir2_sf.h"
  34. #include "xfs_attr_sf.h"
  35. #include "xfs_dinode.h"
  36. #include "xfs_inode.h"
  37. #include "xfs_inode_item.h"
  38. #include "xfs_itable.h"
  39. #include "xfs_btree.h"
  40. #include "xfs_alloc.h"
  41. #include "xfs_ialloc.h"
  42. #include "xfs_attr.h"
  43. #include "xfs_bmap.h"
  44. #include "xfs_acl.h"
  45. #include "xfs_error.h"
  46. #include "xfs_buf_item.h"
  47. #include "xfs_rw.h"
  48. /*
  49. * This is a subroutine for xfs_write() and other writers (xfs_ioctl)
  50. * which clears the setuid and setgid bits when a file is written.
  51. */
  52. int
  53. xfs_write_clear_setuid(
  54. xfs_inode_t *ip)
  55. {
  56. xfs_mount_t *mp;
  57. xfs_trans_t *tp;
  58. int error;
  59. mp = ip->i_mount;
  60. tp = xfs_trans_alloc(mp, XFS_TRANS_WRITEID);
  61. if ((error = xfs_trans_reserve(tp, 0,
  62. XFS_WRITEID_LOG_RES(mp),
  63. 0, 0, 0))) {
  64. xfs_trans_cancel(tp, 0);
  65. return error;
  66. }
  67. xfs_ilock(ip, XFS_ILOCK_EXCL);
  68. xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
  69. xfs_trans_ihold(tp, ip);
  70. ip->i_d.di_mode &= ~S_ISUID;
  71. /*
  72. * Note that we don't have to worry about mandatory
  73. * file locking being disabled here because we only
  74. * clear the S_ISGID bit if the Group execute bit is
  75. * on, but if it was on then mandatory locking wouldn't
  76. * have been enabled.
  77. */
  78. if (ip->i_d.di_mode & S_IXGRP) {
  79. ip->i_d.di_mode &= ~S_ISGID;
  80. }
  81. xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
  82. xfs_trans_set_sync(tp);
  83. error = xfs_trans_commit(tp, 0, NULL);
  84. xfs_iunlock(ip, XFS_ILOCK_EXCL);
  85. return 0;
  86. }
  87. /*
  88. * Handle logging requirements of various synchronous types of write.
  89. */
  90. int
  91. xfs_write_sync_logforce(
  92. xfs_mount_t *mp,
  93. xfs_inode_t *ip)
  94. {
  95. int error = 0;
  96. /*
  97. * If we're treating this as O_DSYNC and we have not updated the
  98. * size, force the log.
  99. */
  100. if (!(mp->m_flags & XFS_MOUNT_OSYNCISOSYNC) &&
  101. !(ip->i_update_size)) {
  102. xfs_inode_log_item_t *iip = ip->i_itemp;
  103. /*
  104. * If an allocation transaction occurred
  105. * without extending the size, then we have to force
  106. * the log up the proper point to ensure that the
  107. * allocation is permanent. We can't count on
  108. * the fact that buffered writes lock out direct I/O
  109. * writes - the direct I/O write could have extended
  110. * the size nontransactionally, then finished before
  111. * we started. xfs_write_file will think that the file
  112. * didn't grow but the update isn't safe unless the
  113. * size change is logged.
  114. *
  115. * Force the log if we've committed a transaction
  116. * against the inode or if someone else has and
  117. * the commit record hasn't gone to disk (e.g.
  118. * the inode is pinned). This guarantees that
  119. * all changes affecting the inode are permanent
  120. * when we return.
  121. */
  122. if (iip && iip->ili_last_lsn) {
  123. xfs_log_force(mp, iip->ili_last_lsn,
  124. XFS_LOG_FORCE | XFS_LOG_SYNC);
  125. } else if (xfs_ipincount(ip) > 0) {
  126. xfs_log_force(mp, (xfs_lsn_t)0,
  127. XFS_LOG_FORCE | XFS_LOG_SYNC);
  128. }
  129. } else {
  130. xfs_trans_t *tp;
  131. /*
  132. * O_SYNC or O_DSYNC _with_ a size update are handled
  133. * the same way.
  134. *
  135. * If the write was synchronous then we need to make
  136. * sure that the inode modification time is permanent.
  137. * We'll have updated the timestamp above, so here
  138. * we use a synchronous transaction to log the inode.
  139. * It's not fast, but it's necessary.
  140. *
  141. * If this a dsync write and the size got changed
  142. * non-transactionally, then we need to ensure that
  143. * the size change gets logged in a synchronous
  144. * transaction.
  145. */
  146. tp = xfs_trans_alloc(mp, XFS_TRANS_WRITE_SYNC);
  147. if ((error = xfs_trans_reserve(tp, 0,
  148. XFS_SWRITE_LOG_RES(mp),
  149. 0, 0, 0))) {
  150. /* Transaction reserve failed */
  151. xfs_trans_cancel(tp, 0);
  152. } else {
  153. /* Transaction reserve successful */
  154. xfs_ilock(ip, XFS_ILOCK_EXCL);
  155. xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
  156. xfs_trans_ihold(tp, ip);
  157. xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
  158. xfs_trans_set_sync(tp);
  159. error = xfs_trans_commit(tp, 0, NULL);
  160. xfs_iunlock(ip, XFS_ILOCK_EXCL);
  161. }
  162. }
  163. return error;
  164. }
  165. /*
  166. * Force a shutdown of the filesystem instantly while keeping
  167. * the filesystem consistent. We don't do an unmount here; just shutdown
  168. * the shop, make sure that absolutely nothing persistent happens to
  169. * this filesystem after this point.
  170. */
  171. void
  172. xfs_do_force_shutdown(
  173. bhv_desc_t *bdp,
  174. int flags,
  175. char *fname,
  176. int lnnum)
  177. {
  178. int logerror;
  179. xfs_mount_t *mp;
  180. mp = XFS_BHVTOM(bdp);
  181. logerror = flags & SHUTDOWN_LOG_IO_ERROR;
  182. if (!(flags & SHUTDOWN_FORCE_UMOUNT)) {
  183. cmn_err(CE_NOTE, "xfs_force_shutdown(%s,0x%x) called from "
  184. "line %d of file %s. Return address = 0x%p",
  185. mp->m_fsname, flags, lnnum, fname, __return_address);
  186. }
  187. /*
  188. * No need to duplicate efforts.
  189. */
  190. if (XFS_FORCED_SHUTDOWN(mp) && !logerror)
  191. return;
  192. /*
  193. * This flags XFS_MOUNT_FS_SHUTDOWN, makes sure that we don't
  194. * queue up anybody new on the log reservations, and wakes up
  195. * everybody who's sleeping on log reservations to tell them
  196. * the bad news.
  197. */
  198. if (xfs_log_force_umount(mp, logerror))
  199. return;
  200. if (flags & SHUTDOWN_CORRUPT_INCORE) {
  201. xfs_cmn_err(XFS_PTAG_SHUTDOWN_CORRUPT, CE_ALERT, mp,
  202. "Corruption of in-memory data detected. Shutting down filesystem: %s",
  203. mp->m_fsname);
  204. if (XFS_ERRLEVEL_HIGH <= xfs_error_level) {
  205. xfs_stack_trace();
  206. }
  207. } else if (!(flags & SHUTDOWN_FORCE_UMOUNT)) {
  208. if (logerror) {
  209. xfs_cmn_err(XFS_PTAG_SHUTDOWN_LOGERROR, CE_ALERT, mp,
  210. "Log I/O Error Detected. Shutting down filesystem: %s",
  211. mp->m_fsname);
  212. } else if (flags & SHUTDOWN_DEVICE_REQ) {
  213. xfs_cmn_err(XFS_PTAG_SHUTDOWN_IOERROR, CE_ALERT, mp,
  214. "All device paths lost. Shutting down filesystem: %s",
  215. mp->m_fsname);
  216. } else if (!(flags & SHUTDOWN_REMOTE_REQ)) {
  217. xfs_cmn_err(XFS_PTAG_SHUTDOWN_IOERROR, CE_ALERT, mp,
  218. "I/O Error Detected. Shutting down filesystem: %s",
  219. mp->m_fsname);
  220. }
  221. }
  222. if (!(flags & SHUTDOWN_FORCE_UMOUNT)) {
  223. cmn_err(CE_ALERT, "Please umount the filesystem, "
  224. "and rectify the problem(s)");
  225. }
  226. }
  227. /*
  228. * Called when we want to stop a buffer from getting written or read.
  229. * We attach the EIO error, muck with its flags, and call biodone
  230. * so that the proper iodone callbacks get called.
  231. */
  232. int
  233. xfs_bioerror(
  234. xfs_buf_t *bp)
  235. {
  236. #ifdef XFSERRORDEBUG
  237. ASSERT(XFS_BUF_ISREAD(bp) || bp->b_iodone);
  238. #endif
  239. /*
  240. * No need to wait until the buffer is unpinned.
  241. * We aren't flushing it.
  242. */
  243. xfs_buftrace("XFS IOERROR", bp);
  244. XFS_BUF_ERROR(bp, EIO);
  245. /*
  246. * We're calling biodone, so delete B_DONE flag. Either way
  247. * we have to call the iodone callback, and calling biodone
  248. * probably is the best way since it takes care of
  249. * GRIO as well.
  250. */
  251. XFS_BUF_UNREAD(bp);
  252. XFS_BUF_UNDELAYWRITE(bp);
  253. XFS_BUF_UNDONE(bp);
  254. XFS_BUF_STALE(bp);
  255. XFS_BUF_CLR_BDSTRAT_FUNC(bp);
  256. xfs_biodone(bp);
  257. return (EIO);
  258. }
  259. /*
  260. * Same as xfs_bioerror, except that we are releasing the buffer
  261. * here ourselves, and avoiding the biodone call.
  262. * This is meant for userdata errors; metadata bufs come with
  263. * iodone functions attached, so that we can track down errors.
  264. */
  265. int
  266. xfs_bioerror_relse(
  267. xfs_buf_t *bp)
  268. {
  269. int64_t fl;
  270. ASSERT(XFS_BUF_IODONE_FUNC(bp) != xfs_buf_iodone_callbacks);
  271. ASSERT(XFS_BUF_IODONE_FUNC(bp) != xlog_iodone);
  272. xfs_buftrace("XFS IOERRELSE", bp);
  273. fl = XFS_BUF_BFLAGS(bp);
  274. /*
  275. * No need to wait until the buffer is unpinned.
  276. * We aren't flushing it.
  277. *
  278. * chunkhold expects B_DONE to be set, whether
  279. * we actually finish the I/O or not. We don't want to
  280. * change that interface.
  281. */
  282. XFS_BUF_UNREAD(bp);
  283. XFS_BUF_UNDELAYWRITE(bp);
  284. XFS_BUF_DONE(bp);
  285. XFS_BUF_STALE(bp);
  286. XFS_BUF_CLR_IODONE_FUNC(bp);
  287. XFS_BUF_CLR_BDSTRAT_FUNC(bp);
  288. if (!(fl & XFS_B_ASYNC)) {
  289. /*
  290. * Mark b_error and B_ERROR _both_.
  291. * Lot's of chunkcache code assumes that.
  292. * There's no reason to mark error for
  293. * ASYNC buffers.
  294. */
  295. XFS_BUF_ERROR(bp, EIO);
  296. XFS_BUF_V_IODONESEMA(bp);
  297. } else {
  298. xfs_buf_relse(bp);
  299. }
  300. return (EIO);
  301. }
  302. /*
  303. * Prints out an ALERT message about I/O error.
  304. */
  305. void
  306. xfs_ioerror_alert(
  307. char *func,
  308. struct xfs_mount *mp,
  309. xfs_buf_t *bp,
  310. xfs_daddr_t blkno)
  311. {
  312. cmn_err(CE_ALERT,
  313. "I/O error in filesystem (\"%s\") meta-data dev %s block 0x%llx"
  314. " (\"%s\") error %d buf count %zd",
  315. (!mp || !mp->m_fsname) ? "(fs name not set)" : mp->m_fsname,
  316. XFS_BUFTARG_NAME(XFS_BUF_TARGET(bp)),
  317. (__uint64_t)blkno, func,
  318. XFS_BUF_GETERROR(bp), XFS_BUF_COUNT(bp));
  319. }
  320. /*
  321. * This isn't an absolute requirement, but it is
  322. * just a good idea to call xfs_read_buf instead of
  323. * directly doing a read_buf call. For one, we shouldn't
  324. * be doing this disk read if we are in SHUTDOWN state anyway,
  325. * so this stops that from happening. Secondly, this does all
  326. * the error checking stuff and the brelse if appropriate for
  327. * the caller, so the code can be a little leaner.
  328. */
  329. int
  330. xfs_read_buf(
  331. struct xfs_mount *mp,
  332. xfs_buftarg_t *target,
  333. xfs_daddr_t blkno,
  334. int len,
  335. uint flags,
  336. xfs_buf_t **bpp)
  337. {
  338. xfs_buf_t *bp;
  339. int error;
  340. if (flags)
  341. bp = xfs_buf_read_flags(target, blkno, len, flags);
  342. else
  343. bp = xfs_buf_read(target, blkno, len, flags);
  344. if (!bp)
  345. return XFS_ERROR(EIO);
  346. error = XFS_BUF_GETERROR(bp);
  347. if (bp && !error && !XFS_FORCED_SHUTDOWN(mp)) {
  348. *bpp = bp;
  349. } else {
  350. *bpp = NULL;
  351. if (error) {
  352. xfs_ioerror_alert("xfs_read_buf", mp, bp, XFS_BUF_ADDR(bp));
  353. } else {
  354. error = XFS_ERROR(EIO);
  355. }
  356. if (bp) {
  357. XFS_BUF_UNDONE(bp);
  358. XFS_BUF_UNDELAYWRITE(bp);
  359. XFS_BUF_STALE(bp);
  360. /*
  361. * brelse clears B_ERROR and b_error
  362. */
  363. xfs_buf_relse(bp);
  364. }
  365. }
  366. return (error);
  367. }
  368. /*
  369. * Wrapper around bwrite() so that we can trap
  370. * write errors, and act accordingly.
  371. */
  372. int
  373. xfs_bwrite(
  374. struct xfs_mount *mp,
  375. struct xfs_buf *bp)
  376. {
  377. int error;
  378. /*
  379. * XXXsup how does this work for quotas.
  380. */
  381. XFS_BUF_SET_BDSTRAT_FUNC(bp, xfs_bdstrat_cb);
  382. XFS_BUF_SET_FSPRIVATE3(bp, mp);
  383. XFS_BUF_WRITE(bp);
  384. if ((error = XFS_bwrite(bp))) {
  385. ASSERT(mp);
  386. /*
  387. * Cannot put a buftrace here since if the buffer is not
  388. * B_HOLD then we will brelse() the buffer before returning
  389. * from bwrite and we could be tracing a buffer that has
  390. * been reused.
  391. */
  392. xfs_force_shutdown(mp, SHUTDOWN_META_IO_ERROR);
  393. }
  394. return (error);
  395. }