1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (c) 2000-2003 Silicon Graphics, Inc. 4 * All Rights Reserved. 5 */ 6 #include "xfs.h" 7 #include "xfs_fs.h" 8 #include "xfs_shared.h" 9 #include "xfs_format.h" 10 #include "xfs_log_format.h" 11 #include "xfs_trans_resv.h" 12 #include "xfs_mount.h" 13 #include "xfs_inode.h" 14 #include "xfs_quota.h" 15 #include "xfs_trans.h" 16 #include "xfs_buf_item.h" 17 #include "xfs_trans_priv.h" 18 #include "xfs_qm.h" 19 #include "xfs_log.h" 20 #include "xfs_error.h" 21 22 static inline struct xfs_dq_logitem *DQUOT_ITEM(struct xfs_log_item *lip) 23 { 24 return container_of(lip, struct xfs_dq_logitem, qli_item); 25 } 26 27 /* 28 * returns the number of iovecs needed to log the given dquot item. 29 */ 30 STATIC void 31 xfs_qm_dquot_logitem_size( 32 struct xfs_log_item *lip, 33 int *nvecs, 34 int *nbytes) 35 { 36 *nvecs += 2; 37 *nbytes += sizeof(struct xfs_dq_logformat) + 38 sizeof(struct xfs_disk_dquot); 39 } 40 41 /* 42 * fills in the vector of log iovecs for the given dquot log item. 43 */ 44 STATIC void 45 xfs_qm_dquot_logitem_format( 46 struct xfs_log_item *lip, 47 struct xfs_log_vec *lv) 48 { 49 struct xfs_disk_dquot ddq; 50 struct xfs_dq_logitem *qlip = DQUOT_ITEM(lip); 51 struct xfs_log_iovec *vecp = NULL; 52 struct xfs_dq_logformat *qlf; 53 54 qlf = xlog_prepare_iovec(lv, &vecp, XLOG_REG_TYPE_QFORMAT); 55 qlf->qlf_type = XFS_LI_DQUOT; 56 qlf->qlf_size = 2; 57 qlf->qlf_id = qlip->qli_dquot->q_id; 58 qlf->qlf_blkno = qlip->qli_dquot->q_blkno; 59 qlf->qlf_len = 1; 60 qlf->qlf_boffset = qlip->qli_dquot->q_bufoffset; 61 xlog_finish_iovec(lv, vecp, sizeof(struct xfs_dq_logformat)); 62 63 xfs_dquot_to_disk(&ddq, qlip->qli_dquot); 64 65 xlog_copy_iovec(lv, &vecp, XLOG_REG_TYPE_DQUOT, &ddq, 66 sizeof(struct xfs_disk_dquot)); 67 } 68 69 /* 70 * Increment the pin count of the given dquot. 71 */ 72 STATIC void 73 xfs_qm_dquot_logitem_pin( 74 struct xfs_log_item *lip) 75 { 76 struct xfs_dquot *dqp = DQUOT_ITEM(lip)->qli_dquot; 77 78 ASSERT(XFS_DQ_IS_LOCKED(dqp)); 79 atomic_inc(&dqp->q_pincount); 80 } 81 82 /* 83 * Decrement the pin count of the given dquot, and wake up 84 * anyone in xfs_dqwait_unpin() if the count goes to 0. The 85 * dquot must have been previously pinned with a call to 86 * xfs_qm_dquot_logitem_pin(). 87 */ 88 STATIC void 89 xfs_qm_dquot_logitem_unpin( 90 struct xfs_log_item *lip, 91 int remove) 92 { 93 struct xfs_dquot *dqp = DQUOT_ITEM(lip)->qli_dquot; 94 95 ASSERT(atomic_read(&dqp->q_pincount) > 0); 96 if (atomic_dec_and_test(&dqp->q_pincount)) 97 wake_up(&dqp->q_pinwait); 98 } 99 100 /* 101 * This is called to wait for the given dquot to be unpinned. 102 * Most of these pin/unpin routines are plagiarized from inode code. 103 */ 104 void 105 xfs_qm_dqunpin_wait( 106 struct xfs_dquot *dqp) 107 { 108 ASSERT(XFS_DQ_IS_LOCKED(dqp)); 109 if (atomic_read(&dqp->q_pincount) == 0) 110 return; 111 112 /* 113 * Give the log a push so we don't wait here too long. 114 */ 115 xfs_log_force(dqp->q_mount, 0); 116 wait_event(dqp->q_pinwait, (atomic_read(&dqp->q_pincount) == 0)); 117 } 118 119 STATIC uint 120 xfs_qm_dquot_logitem_push( 121 struct xfs_log_item *lip, 122 struct list_head *buffer_list) 123 __releases(&lip->li_ailp->ail_lock) 124 __acquires(&lip->li_ailp->ail_lock) 125 { 126 struct xfs_dq_logitem *qlip = DQUOT_ITEM(lip); 127 struct xfs_dquot *dqp = qlip->qli_dquot; 128 struct xfs_buf *bp; 129 uint rval = XFS_ITEM_SUCCESS; 130 int error; 131 132 if (atomic_read(&dqp->q_pincount) > 0) 133 return XFS_ITEM_PINNED; 134 135 if (!xfs_dqlock_nowait(dqp)) 136 return XFS_ITEM_LOCKED; 137 138 /* 139 * Re-check the pincount now that we stabilized the value by 140 * taking the quota lock. 141 */ 142 if (atomic_read(&dqp->q_pincount) > 0) { 143 rval = XFS_ITEM_PINNED; 144 goto out_unlock; 145 } 146 147 /* 148 * Someone else is already flushing the dquot. Nothing we can do 149 * here but wait for the flush to finish and remove the item from 150 * the AIL. 151 */ 152 if (!xfs_dqflock_nowait(dqp)) { 153 rval = XFS_ITEM_FLUSHING; 154 goto out_unlock; 155 } 156 157 spin_unlock(&lip->li_ailp->ail_lock); 158 159 error = xfs_dquot_use_attached_buf(dqp, &bp); 160 if (error == -EAGAIN) { 161 xfs_dqfunlock(dqp); 162 rval = XFS_ITEM_LOCKED; 163 goto out_relock_ail; 164 } 165 166 /* 167 * dqflush completes dqflock on error, and the delwri ioend does it on 168 * success. 169 */ 170 error = xfs_qm_dqflush(dqp, bp); 171 if (!error) { 172 if (!xfs_buf_delwri_queue(bp, buffer_list)) 173 rval = XFS_ITEM_FLUSHING; 174 } 175 xfs_buf_relse(bp); 176 177 out_relock_ail: 178 spin_lock(&lip->li_ailp->ail_lock); 179 out_unlock: 180 xfs_dqunlock(dqp); 181 return rval; 182 } 183 184 STATIC void 185 xfs_qm_dquot_logitem_release( 186 struct xfs_log_item *lip) 187 { 188 struct xfs_dquot *dqp = DQUOT_ITEM(lip)->qli_dquot; 189 190 ASSERT(XFS_DQ_IS_LOCKED(dqp)); 191 192 /* 193 * dquots are never 'held' from getting unlocked at the end of 194 * a transaction. Their locking and unlocking is hidden inside the 195 * transaction layer, within trans_commit. Hence, no LI_HOLD flag 196 * for the logitem. 197 */ 198 xfs_dqunlock(dqp); 199 } 200 201 STATIC void 202 xfs_qm_dquot_logitem_committing( 203 struct xfs_log_item *lip, 204 xfs_csn_t seq) 205 { 206 return xfs_qm_dquot_logitem_release(lip); 207 } 208 209 #ifdef DEBUG_EXPENSIVE 210 static void 211 xfs_qm_dquot_logitem_precommit_check( 212 struct xfs_dquot *dqp) 213 { 214 struct xfs_mount *mp = dqp->q_mount; 215 struct xfs_disk_dquot ddq = { }; 216 xfs_failaddr_t fa; 217 218 xfs_dquot_to_disk(&ddq, dqp); 219 fa = xfs_dquot_verify(mp, &ddq, dqp->q_id); 220 if (fa) { 221 XFS_CORRUPTION_ERROR("Bad dquot during logging", 222 XFS_ERRLEVEL_LOW, mp, &ddq, sizeof(ddq)); 223 xfs_alert(mp, 224 "Metadata corruption detected at %pS, dquot 0x%x", 225 fa, dqp->q_id); 226 xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE); 227 ASSERT(fa == NULL); 228 } 229 } 230 #else 231 # define xfs_qm_dquot_logitem_precommit_check(...) ((void)0) 232 #endif 233 234 static int 235 xfs_qm_dquot_logitem_precommit( 236 struct xfs_trans *tp, 237 struct xfs_log_item *lip) 238 { 239 struct xfs_dq_logitem *qlip = DQUOT_ITEM(lip); 240 struct xfs_dquot *dqp = qlip->qli_dquot; 241 242 xfs_qm_dquot_logitem_precommit_check(dqp); 243 244 return xfs_dquot_attach_buf(tp, dqp); 245 } 246 247 static const struct xfs_item_ops xfs_dquot_item_ops = { 248 .iop_size = xfs_qm_dquot_logitem_size, 249 .iop_precommit = xfs_qm_dquot_logitem_precommit, 250 .iop_format = xfs_qm_dquot_logitem_format, 251 .iop_pin = xfs_qm_dquot_logitem_pin, 252 .iop_unpin = xfs_qm_dquot_logitem_unpin, 253 .iop_release = xfs_qm_dquot_logitem_release, 254 .iop_committing = xfs_qm_dquot_logitem_committing, 255 .iop_push = xfs_qm_dquot_logitem_push, 256 }; 257 258 /* 259 * Initialize the dquot log item for a newly allocated dquot. 260 * The dquot isn't locked at this point, but it isn't on any of the lists 261 * either, so we don't care. 262 */ 263 void 264 xfs_qm_dquot_logitem_init( 265 struct xfs_dquot *dqp) 266 { 267 struct xfs_dq_logitem *lp = &dqp->q_logitem; 268 269 xfs_log_item_init(dqp->q_mount, &lp->qli_item, XFS_LI_DQUOT, 270 &xfs_dquot_item_ops); 271 spin_lock_init(&lp->qli_lock); 272 lp->qli_dquot = dqp; 273 lp->qli_dirty = false; 274 } 275