xfs_dquot_item.c 18 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671
  1. /*
  2. * Copyright (c) 2000-2003 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_bit.h"
  21. #include "xfs_log.h"
  22. #include "xfs_inum.h"
  23. #include "xfs_trans.h"
  24. #include "xfs_sb.h"
  25. #include "xfs_ag.h"
  26. #include "xfs_dir2.h"
  27. #include "xfs_alloc.h"
  28. #include "xfs_dmapi.h"
  29. #include "xfs_quota.h"
  30. #include "xfs_mount.h"
  31. #include "xfs_bmap_btree.h"
  32. #include "xfs_alloc_btree.h"
  33. #include "xfs_ialloc_btree.h"
  34. #include "xfs_dir2_sf.h"
  35. #include "xfs_attr_sf.h"
  36. #include "xfs_dinode.h"
  37. #include "xfs_inode.h"
  38. #include "xfs_bmap.h"
  39. #include "xfs_btree.h"
  40. #include "xfs_ialloc.h"
  41. #include "xfs_rtalloc.h"
  42. #include "xfs_error.h"
  43. #include "xfs_itable.h"
  44. #include "xfs_rw.h"
  45. #include "xfs_acl.h"
  46. #include "xfs_attr.h"
  47. #include "xfs_buf_item.h"
  48. #include "xfs_trans_priv.h"
  49. #include "xfs_qm.h"
  50. /*
  51. * returns the number of iovecs needed to log the given dquot item.
  52. */
  53. /* ARGSUSED */
  54. STATIC uint
  55. xfs_qm_dquot_logitem_size(
  56. xfs_dq_logitem_t *logitem)
  57. {
  58. /*
  59. * we need only two iovecs, one for the format, one for the real thing
  60. */
  61. return (2);
  62. }
  63. /*
  64. * fills in the vector of log iovecs for the given dquot log item.
  65. */
  66. STATIC void
  67. xfs_qm_dquot_logitem_format(
  68. xfs_dq_logitem_t *logitem,
  69. xfs_log_iovec_t *logvec)
  70. {
  71. ASSERT(logitem);
  72. ASSERT(logitem->qli_dquot);
  73. logvec->i_addr = (xfs_caddr_t)&logitem->qli_format;
  74. logvec->i_len = sizeof(xfs_dq_logformat_t);
  75. XLOG_VEC_SET_TYPE(logvec, XLOG_REG_TYPE_QFORMAT);
  76. logvec++;
  77. logvec->i_addr = (xfs_caddr_t)&logitem->qli_dquot->q_core;
  78. logvec->i_len = sizeof(xfs_disk_dquot_t);
  79. XLOG_VEC_SET_TYPE(logvec, XLOG_REG_TYPE_DQUOT);
  80. ASSERT(2 == logitem->qli_item.li_desc->lid_size);
  81. logitem->qli_format.qlf_size = 2;
  82. }
  83. /*
  84. * Increment the pin count of the given dquot.
  85. * This value is protected by pinlock spinlock in the xQM structure.
  86. */
  87. STATIC void
  88. xfs_qm_dquot_logitem_pin(
  89. xfs_dq_logitem_t *logitem)
  90. {
  91. unsigned long s;
  92. xfs_dquot_t *dqp;
  93. dqp = logitem->qli_dquot;
  94. ASSERT(XFS_DQ_IS_LOCKED(dqp));
  95. s = XFS_DQ_PINLOCK(dqp);
  96. dqp->q_pincount++;
  97. XFS_DQ_PINUNLOCK(dqp, s);
  98. }
  99. /*
  100. * Decrement the pin count of the given dquot, and wake up
  101. * anyone in xfs_dqwait_unpin() if the count goes to 0. The
  102. * dquot must have been previously pinned with a call to xfs_dqpin().
  103. */
  104. /* ARGSUSED */
  105. STATIC void
  106. xfs_qm_dquot_logitem_unpin(
  107. xfs_dq_logitem_t *logitem,
  108. int stale)
  109. {
  110. unsigned long s;
  111. xfs_dquot_t *dqp;
  112. dqp = logitem->qli_dquot;
  113. ASSERT(dqp->q_pincount > 0);
  114. s = XFS_DQ_PINLOCK(dqp);
  115. dqp->q_pincount--;
  116. if (dqp->q_pincount == 0) {
  117. sv_broadcast(&dqp->q_pinwait);
  118. }
  119. XFS_DQ_PINUNLOCK(dqp, s);
  120. }
  121. /* ARGSUSED */
  122. STATIC void
  123. xfs_qm_dquot_logitem_unpin_remove(
  124. xfs_dq_logitem_t *logitem,
  125. xfs_trans_t *tp)
  126. {
  127. xfs_qm_dquot_logitem_unpin(logitem, 0);
  128. }
  129. /*
  130. * Given the logitem, this writes the corresponding dquot entry to disk
  131. * asynchronously. This is called with the dquot entry securely locked;
  132. * we simply get xfs_qm_dqflush() to do the work, and unlock the dquot
  133. * at the end.
  134. */
  135. STATIC void
  136. xfs_qm_dquot_logitem_push(
  137. xfs_dq_logitem_t *logitem)
  138. {
  139. xfs_dquot_t *dqp;
  140. dqp = logitem->qli_dquot;
  141. ASSERT(XFS_DQ_IS_LOCKED(dqp));
  142. ASSERT(XFS_DQ_IS_FLUSH_LOCKED(dqp));
  143. /*
  144. * Since we were able to lock the dquot's flush lock and
  145. * we found it on the AIL, the dquot must be dirty. This
  146. * is because the dquot is removed from the AIL while still
  147. * holding the flush lock in xfs_dqflush_done(). Thus, if
  148. * we found it in the AIL and were able to obtain the flush
  149. * lock without sleeping, then there must not have been
  150. * anyone in the process of flushing the dquot.
  151. */
  152. xfs_qm_dqflush(dqp, XFS_B_DELWRI);
  153. xfs_dqunlock(dqp);
  154. }
  155. /*ARGSUSED*/
  156. STATIC xfs_lsn_t
  157. xfs_qm_dquot_logitem_committed(
  158. xfs_dq_logitem_t *l,
  159. xfs_lsn_t lsn)
  160. {
  161. /*
  162. * We always re-log the entire dquot when it becomes dirty,
  163. * so, the latest copy _is_ the only one that matters.
  164. */
  165. return (lsn);
  166. }
  167. /*
  168. * This is called to wait for the given dquot to be unpinned.
  169. * Most of these pin/unpin routines are plagiarized from inode code.
  170. */
  171. void
  172. xfs_qm_dqunpin_wait(
  173. xfs_dquot_t *dqp)
  174. {
  175. SPLDECL(s);
  176. ASSERT(XFS_DQ_IS_LOCKED(dqp));
  177. if (dqp->q_pincount == 0) {
  178. return;
  179. }
  180. /*
  181. * Give the log a push so we don't wait here too long.
  182. */
  183. xfs_log_force(dqp->q_mount, (xfs_lsn_t)0, XFS_LOG_FORCE);
  184. s = XFS_DQ_PINLOCK(dqp);
  185. if (dqp->q_pincount == 0) {
  186. XFS_DQ_PINUNLOCK(dqp, s);
  187. return;
  188. }
  189. sv_wait(&(dqp->q_pinwait), PINOD,
  190. &(XFS_DQ_TO_QINF(dqp)->qi_pinlock), s);
  191. }
  192. /*
  193. * This is called when IOP_TRYLOCK returns XFS_ITEM_PUSHBUF to indicate that
  194. * the dquot is locked by us, but the flush lock isn't. So, here we are
  195. * going to see if the relevant dquot buffer is incore, waiting on DELWRI.
  196. * If so, we want to push it out to help us take this item off the AIL as soon
  197. * as possible.
  198. *
  199. * We must not be holding the AIL_LOCK at this point. Calling incore() to
  200. * search the buffer cache can be a time consuming thing, and AIL_LOCK is a
  201. * spinlock.
  202. */
  203. STATIC void
  204. xfs_qm_dquot_logitem_pushbuf(
  205. xfs_dq_logitem_t *qip)
  206. {
  207. xfs_dquot_t *dqp;
  208. xfs_mount_t *mp;
  209. xfs_buf_t *bp;
  210. uint dopush;
  211. dqp = qip->qli_dquot;
  212. ASSERT(XFS_DQ_IS_LOCKED(dqp));
  213. /*
  214. * The qli_pushbuf_flag keeps others from
  215. * trying to duplicate our effort.
  216. */
  217. ASSERT(qip->qli_pushbuf_flag != 0);
  218. ASSERT(qip->qli_push_owner == current_pid());
  219. /*
  220. * If flushlock isn't locked anymore, chances are that the
  221. * inode flush completed and the inode was taken off the AIL.
  222. * So, just get out.
  223. */
  224. if (!issemalocked(&(dqp->q_flock)) ||
  225. ((qip->qli_item.li_flags & XFS_LI_IN_AIL) == 0)) {
  226. qip->qli_pushbuf_flag = 0;
  227. xfs_dqunlock(dqp);
  228. return;
  229. }
  230. mp = dqp->q_mount;
  231. bp = xfs_incore(mp->m_ddev_targp, qip->qli_format.qlf_blkno,
  232. XFS_QI_DQCHUNKLEN(mp),
  233. XFS_INCORE_TRYLOCK);
  234. if (bp != NULL) {
  235. if (XFS_BUF_ISDELAYWRITE(bp)) {
  236. dopush = ((qip->qli_item.li_flags & XFS_LI_IN_AIL) &&
  237. issemalocked(&(dqp->q_flock)));
  238. qip->qli_pushbuf_flag = 0;
  239. xfs_dqunlock(dqp);
  240. if (XFS_BUF_ISPINNED(bp)) {
  241. xfs_log_force(mp, (xfs_lsn_t)0,
  242. XFS_LOG_FORCE);
  243. }
  244. if (dopush) {
  245. #ifdef XFSRACEDEBUG
  246. delay_for_intr();
  247. delay(300);
  248. #endif
  249. xfs_bawrite(mp, bp);
  250. } else {
  251. xfs_buf_relse(bp);
  252. }
  253. } else {
  254. qip->qli_pushbuf_flag = 0;
  255. xfs_dqunlock(dqp);
  256. xfs_buf_relse(bp);
  257. }
  258. return;
  259. }
  260. qip->qli_pushbuf_flag = 0;
  261. xfs_dqunlock(dqp);
  262. }
  263. /*
  264. * This is called to attempt to lock the dquot associated with this
  265. * dquot log item. Don't sleep on the dquot lock or the flush lock.
  266. * If the flush lock is already held, indicating that the dquot has
  267. * been or is in the process of being flushed, then see if we can
  268. * find the dquot's buffer in the buffer cache without sleeping. If
  269. * we can and it is marked delayed write, then we want to send it out.
  270. * We delay doing so until the push routine, though, to avoid sleeping
  271. * in any device strategy routines.
  272. */
  273. STATIC uint
  274. xfs_qm_dquot_logitem_trylock(
  275. xfs_dq_logitem_t *qip)
  276. {
  277. xfs_dquot_t *dqp;
  278. uint retval;
  279. dqp = qip->qli_dquot;
  280. if (dqp->q_pincount > 0)
  281. return (XFS_ITEM_PINNED);
  282. if (! xfs_qm_dqlock_nowait(dqp))
  283. return (XFS_ITEM_LOCKED);
  284. retval = XFS_ITEM_SUCCESS;
  285. if (! xfs_qm_dqflock_nowait(dqp)) {
  286. /*
  287. * The dquot is already being flushed. It may have been
  288. * flushed delayed write, however, and we don't want to
  289. * get stuck waiting for that to complete. So, we want to check
  290. * to see if we can lock the dquot's buffer without sleeping.
  291. * If we can and it is marked for delayed write, then we
  292. * hold it and send it out from the push routine. We don't
  293. * want to do that now since we might sleep in the device
  294. * strategy routine. We also don't want to grab the buffer lock
  295. * here because we'd like not to call into the buffer cache
  296. * while holding the AIL_LOCK.
  297. * Make sure to only return PUSHBUF if we set pushbuf_flag
  298. * ourselves. If someone else is doing it then we don't
  299. * want to go to the push routine and duplicate their efforts.
  300. */
  301. if (qip->qli_pushbuf_flag == 0) {
  302. qip->qli_pushbuf_flag = 1;
  303. ASSERT(qip->qli_format.qlf_blkno == dqp->q_blkno);
  304. #ifdef DEBUG
  305. qip->qli_push_owner = current_pid();
  306. #endif
  307. /*
  308. * The dquot is left locked.
  309. */
  310. retval = XFS_ITEM_PUSHBUF;
  311. } else {
  312. retval = XFS_ITEM_FLUSHING;
  313. xfs_dqunlock_nonotify(dqp);
  314. }
  315. }
  316. ASSERT(qip->qli_item.li_flags & XFS_LI_IN_AIL);
  317. return (retval);
  318. }
  319. /*
  320. * Unlock the dquot associated with the log item.
  321. * Clear the fields of the dquot and dquot log item that
  322. * are specific to the current transaction. If the
  323. * hold flags is set, do not unlock the dquot.
  324. */
  325. STATIC void
  326. xfs_qm_dquot_logitem_unlock(
  327. xfs_dq_logitem_t *ql)
  328. {
  329. xfs_dquot_t *dqp;
  330. ASSERT(ql != NULL);
  331. dqp = ql->qli_dquot;
  332. ASSERT(XFS_DQ_IS_LOCKED(dqp));
  333. /*
  334. * Clear the transaction pointer in the dquot
  335. */
  336. dqp->q_transp = NULL;
  337. /*
  338. * dquots are never 'held' from getting unlocked at the end of
  339. * a transaction. Their locking and unlocking is hidden inside the
  340. * transaction layer, within trans_commit. Hence, no LI_HOLD flag
  341. * for the logitem.
  342. */
  343. xfs_dqunlock(dqp);
  344. }
  345. /*
  346. * this needs to stamp an lsn into the dquot, I think.
  347. * rpc's that look at user dquot's would then have to
  348. * push on the dependency recorded in the dquot
  349. */
  350. /* ARGSUSED */
  351. STATIC void
  352. xfs_qm_dquot_logitem_committing(
  353. xfs_dq_logitem_t *l,
  354. xfs_lsn_t lsn)
  355. {
  356. return;
  357. }
  358. /*
  359. * This is the ops vector for dquots
  360. */
  361. static struct xfs_item_ops xfs_dquot_item_ops = {
  362. .iop_size = (uint(*)(xfs_log_item_t*))xfs_qm_dquot_logitem_size,
  363. .iop_format = (void(*)(xfs_log_item_t*, xfs_log_iovec_t*))
  364. xfs_qm_dquot_logitem_format,
  365. .iop_pin = (void(*)(xfs_log_item_t*))xfs_qm_dquot_logitem_pin,
  366. .iop_unpin = (void(*)(xfs_log_item_t*, int))
  367. xfs_qm_dquot_logitem_unpin,
  368. .iop_unpin_remove = (void(*)(xfs_log_item_t*, xfs_trans_t*))
  369. xfs_qm_dquot_logitem_unpin_remove,
  370. .iop_trylock = (uint(*)(xfs_log_item_t*))
  371. xfs_qm_dquot_logitem_trylock,
  372. .iop_unlock = (void(*)(xfs_log_item_t*))xfs_qm_dquot_logitem_unlock,
  373. .iop_committed = (xfs_lsn_t(*)(xfs_log_item_t*, xfs_lsn_t))
  374. xfs_qm_dquot_logitem_committed,
  375. .iop_push = (void(*)(xfs_log_item_t*))xfs_qm_dquot_logitem_push,
  376. .iop_pushbuf = (void(*)(xfs_log_item_t*))
  377. xfs_qm_dquot_logitem_pushbuf,
  378. .iop_committing = (void(*)(xfs_log_item_t*, xfs_lsn_t))
  379. xfs_qm_dquot_logitem_committing
  380. };
  381. /*
  382. * Initialize the dquot log item for a newly allocated dquot.
  383. * The dquot isn't locked at this point, but it isn't on any of the lists
  384. * either, so we don't care.
  385. */
  386. void
  387. xfs_qm_dquot_logitem_init(
  388. struct xfs_dquot *dqp)
  389. {
  390. xfs_dq_logitem_t *lp;
  391. lp = &dqp->q_logitem;
  392. lp->qli_item.li_type = XFS_LI_DQUOT;
  393. lp->qli_item.li_ops = &xfs_dquot_item_ops;
  394. lp->qli_item.li_mountp = dqp->q_mount;
  395. lp->qli_dquot = dqp;
  396. lp->qli_format.qlf_type = XFS_LI_DQUOT;
  397. lp->qli_format.qlf_id = be32_to_cpu(dqp->q_core.d_id);
  398. lp->qli_format.qlf_blkno = dqp->q_blkno;
  399. lp->qli_format.qlf_len = 1;
  400. /*
  401. * This is just the offset of this dquot within its buffer
  402. * (which is currently 1 FSB and probably won't change).
  403. * Hence 32 bits for this offset should be just fine.
  404. * Alternatively, we can store (bufoffset / sizeof(xfs_dqblk_t))
  405. * here, and recompute it at recovery time.
  406. */
  407. lp->qli_format.qlf_boffset = (__uint32_t)dqp->q_bufoffset;
  408. }
  409. /*------------------ QUOTAOFF LOG ITEMS -------------------*/
  410. /*
  411. * This returns the number of iovecs needed to log the given quotaoff item.
  412. * We only need 1 iovec for an quotaoff item. It just logs the
  413. * quotaoff_log_format structure.
  414. */
  415. /*ARGSUSED*/
  416. STATIC uint
  417. xfs_qm_qoff_logitem_size(xfs_qoff_logitem_t *qf)
  418. {
  419. return (1);
  420. }
  421. /*
  422. * This is called to fill in the vector of log iovecs for the
  423. * given quotaoff log item. We use only 1 iovec, and we point that
  424. * at the quotaoff_log_format structure embedded in the quotaoff item.
  425. * It is at this point that we assert that all of the extent
  426. * slots in the quotaoff item have been filled.
  427. */
  428. STATIC void
  429. xfs_qm_qoff_logitem_format(xfs_qoff_logitem_t *qf,
  430. xfs_log_iovec_t *log_vector)
  431. {
  432. ASSERT(qf->qql_format.qf_type == XFS_LI_QUOTAOFF);
  433. log_vector->i_addr = (xfs_caddr_t)&(qf->qql_format);
  434. log_vector->i_len = sizeof(xfs_qoff_logitem_t);
  435. XLOG_VEC_SET_TYPE(log_vector, XLOG_REG_TYPE_QUOTAOFF);
  436. qf->qql_format.qf_size = 1;
  437. }
  438. /*
  439. * Pinning has no meaning for an quotaoff item, so just return.
  440. */
  441. /*ARGSUSED*/
  442. STATIC void
  443. xfs_qm_qoff_logitem_pin(xfs_qoff_logitem_t *qf)
  444. {
  445. return;
  446. }
  447. /*
  448. * Since pinning has no meaning for an quotaoff item, unpinning does
  449. * not either.
  450. */
  451. /*ARGSUSED*/
  452. STATIC void
  453. xfs_qm_qoff_logitem_unpin(xfs_qoff_logitem_t *qf, int stale)
  454. {
  455. return;
  456. }
  457. /*ARGSUSED*/
  458. STATIC void
  459. xfs_qm_qoff_logitem_unpin_remove(xfs_qoff_logitem_t *qf, xfs_trans_t *tp)
  460. {
  461. return;
  462. }
  463. /*
  464. * Quotaoff items have no locking, so just return success.
  465. */
  466. /*ARGSUSED*/
  467. STATIC uint
  468. xfs_qm_qoff_logitem_trylock(xfs_qoff_logitem_t *qf)
  469. {
  470. return XFS_ITEM_LOCKED;
  471. }
  472. /*
  473. * Quotaoff items have no locking or pushing, so return failure
  474. * so that the caller doesn't bother with us.
  475. */
  476. /*ARGSUSED*/
  477. STATIC void
  478. xfs_qm_qoff_logitem_unlock(xfs_qoff_logitem_t *qf)
  479. {
  480. return;
  481. }
  482. /*
  483. * The quotaoff-start-item is logged only once and cannot be moved in the log,
  484. * so simply return the lsn at which it's been logged.
  485. */
  486. /*ARGSUSED*/
  487. STATIC xfs_lsn_t
  488. xfs_qm_qoff_logitem_committed(xfs_qoff_logitem_t *qf, xfs_lsn_t lsn)
  489. {
  490. return (lsn);
  491. }
  492. /*
  493. * There isn't much you can do to push on an quotaoff item. It is simply
  494. * stuck waiting for the log to be flushed to disk.
  495. */
  496. /*ARGSUSED*/
  497. STATIC void
  498. xfs_qm_qoff_logitem_push(xfs_qoff_logitem_t *qf)
  499. {
  500. return;
  501. }
  502. /*ARGSUSED*/
  503. STATIC xfs_lsn_t
  504. xfs_qm_qoffend_logitem_committed(
  505. xfs_qoff_logitem_t *qfe,
  506. xfs_lsn_t lsn)
  507. {
  508. xfs_qoff_logitem_t *qfs;
  509. SPLDECL(s);
  510. qfs = qfe->qql_start_lip;
  511. AIL_LOCK(qfs->qql_item.li_mountp,s);
  512. /*
  513. * Delete the qoff-start logitem from the AIL.
  514. * xfs_trans_delete_ail() drops the AIL lock.
  515. */
  516. xfs_trans_delete_ail(qfs->qql_item.li_mountp, (xfs_log_item_t *)qfs, s);
  517. kmem_free(qfs, sizeof(xfs_qoff_logitem_t));
  518. kmem_free(qfe, sizeof(xfs_qoff_logitem_t));
  519. return (xfs_lsn_t)-1;
  520. }
  521. /*
  522. * XXX rcc - don't know quite what to do with this. I think we can
  523. * just ignore it. The only time that isn't the case is if we allow
  524. * the client to somehow see that quotas have been turned off in which
  525. * we can't allow that to get back until the quotaoff hits the disk.
  526. * So how would that happen? Also, do we need different routines for
  527. * quotaoff start and quotaoff end? I suspect the answer is yes but
  528. * to be sure, I need to look at the recovery code and see how quota off
  529. * recovery is handled (do we roll forward or back or do something else).
  530. * If we roll forwards or backwards, then we need two separate routines,
  531. * one that does nothing and one that stamps in the lsn that matters
  532. * (truly makes the quotaoff irrevocable). If we do something else,
  533. * then maybe we don't need two.
  534. */
  535. /* ARGSUSED */
  536. STATIC void
  537. xfs_qm_qoff_logitem_committing(xfs_qoff_logitem_t *qip, xfs_lsn_t commit_lsn)
  538. {
  539. return;
  540. }
  541. /* ARGSUSED */
  542. STATIC void
  543. xfs_qm_qoffend_logitem_committing(xfs_qoff_logitem_t *qip, xfs_lsn_t commit_lsn)
  544. {
  545. return;
  546. }
  547. static struct xfs_item_ops xfs_qm_qoffend_logitem_ops = {
  548. .iop_size = (uint(*)(xfs_log_item_t*))xfs_qm_qoff_logitem_size,
  549. .iop_format = (void(*)(xfs_log_item_t*, xfs_log_iovec_t*))
  550. xfs_qm_qoff_logitem_format,
  551. .iop_pin = (void(*)(xfs_log_item_t*))xfs_qm_qoff_logitem_pin,
  552. .iop_unpin = (void(*)(xfs_log_item_t* ,int))
  553. xfs_qm_qoff_logitem_unpin,
  554. .iop_unpin_remove = (void(*)(xfs_log_item_t*,xfs_trans_t*))
  555. xfs_qm_qoff_logitem_unpin_remove,
  556. .iop_trylock = (uint(*)(xfs_log_item_t*))xfs_qm_qoff_logitem_trylock,
  557. .iop_unlock = (void(*)(xfs_log_item_t*))xfs_qm_qoff_logitem_unlock,
  558. .iop_committed = (xfs_lsn_t(*)(xfs_log_item_t*, xfs_lsn_t))
  559. xfs_qm_qoffend_logitem_committed,
  560. .iop_push = (void(*)(xfs_log_item_t*))xfs_qm_qoff_logitem_push,
  561. .iop_pushbuf = NULL,
  562. .iop_committing = (void(*)(xfs_log_item_t*, xfs_lsn_t))
  563. xfs_qm_qoffend_logitem_committing
  564. };
  565. /*
  566. * This is the ops vector shared by all quotaoff-start log items.
  567. */
  568. static struct xfs_item_ops xfs_qm_qoff_logitem_ops = {
  569. .iop_size = (uint(*)(xfs_log_item_t*))xfs_qm_qoff_logitem_size,
  570. .iop_format = (void(*)(xfs_log_item_t*, xfs_log_iovec_t*))
  571. xfs_qm_qoff_logitem_format,
  572. .iop_pin = (void(*)(xfs_log_item_t*))xfs_qm_qoff_logitem_pin,
  573. .iop_unpin = (void(*)(xfs_log_item_t*, int))
  574. xfs_qm_qoff_logitem_unpin,
  575. .iop_unpin_remove = (void(*)(xfs_log_item_t*,xfs_trans_t*))
  576. xfs_qm_qoff_logitem_unpin_remove,
  577. .iop_trylock = (uint(*)(xfs_log_item_t*))xfs_qm_qoff_logitem_trylock,
  578. .iop_unlock = (void(*)(xfs_log_item_t*))xfs_qm_qoff_logitem_unlock,
  579. .iop_committed = (xfs_lsn_t(*)(xfs_log_item_t*, xfs_lsn_t))
  580. xfs_qm_qoff_logitem_committed,
  581. .iop_push = (void(*)(xfs_log_item_t*))xfs_qm_qoff_logitem_push,
  582. .iop_pushbuf = NULL,
  583. .iop_committing = (void(*)(xfs_log_item_t*, xfs_lsn_t))
  584. xfs_qm_qoff_logitem_committing
  585. };
  586. /*
  587. * Allocate and initialize an quotaoff item of the correct quota type(s).
  588. */
  589. xfs_qoff_logitem_t *
  590. xfs_qm_qoff_logitem_init(
  591. struct xfs_mount *mp,
  592. xfs_qoff_logitem_t *start,
  593. uint flags)
  594. {
  595. xfs_qoff_logitem_t *qf;
  596. qf = (xfs_qoff_logitem_t*) kmem_zalloc(sizeof(xfs_qoff_logitem_t), KM_SLEEP);
  597. qf->qql_item.li_type = XFS_LI_QUOTAOFF;
  598. if (start)
  599. qf->qql_item.li_ops = &xfs_qm_qoffend_logitem_ops;
  600. else
  601. qf->qql_item.li_ops = &xfs_qm_qoff_logitem_ops;
  602. qf->qql_item.li_mountp = mp;
  603. qf->qql_format.qf_type = XFS_LI_QUOTAOFF;
  604. qf->qql_format.qf_flags = flags;
  605. qf->qql_start_lip = start;
  606. return (qf);
  607. }