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 21 static inline struct xfs_dq_logitem *DQUOT_ITEM(struct xfs_log_item *lip) 22 { 23 return container_of(lip, struct xfs_dq_logitem, qli_item); 24 } 25 26 /* 27 * returns the number of iovecs needed to log the given dquot item. 28 */ 29 STATIC void 30 xfs_qm_dquot_logitem_size( 31 struct xfs_log_item *lip, 32 int *nvecs, 33 int *nbytes) 34 { 35 *nvecs += 2; 36 *nbytes += sizeof(struct xfs_dq_logformat) + 37 sizeof(struct xfs_disk_dquot); 38 } 39 40 /* 41 * fills in the vector of log iovecs for the given dquot log item. 42 */ 43 STATIC void 44 xfs_qm_dquot_logitem_format( 45 struct xfs_log_item *lip, 46 struct xfs_log_vec *lv) 47 { 48 struct xfs_dq_logitem *qlip = DQUOT_ITEM(lip); 49 struct xfs_log_iovec *vecp = NULL; 50 struct xfs_dq_logformat *qlf; 51 52 qlf = xlog_prepare_iovec(lv, &vecp, XLOG_REG_TYPE_QFORMAT); 53 qlf->qlf_type = XFS_LI_DQUOT; 54 qlf->qlf_size = 2; 55 qlf->qlf_id = be32_to_cpu(qlip->qli_dquot->q_core.d_id); 56 qlf->qlf_blkno = qlip->qli_dquot->q_blkno; 57 qlf->qlf_len = 1; 58 qlf->qlf_boffset = qlip->qli_dquot->q_bufoffset; 59 xlog_finish_iovec(lv, vecp, sizeof(struct xfs_dq_logformat)); 60 61 xlog_copy_iovec(lv, &vecp, XLOG_REG_TYPE_DQUOT, 62 &qlip->qli_dquot->q_core, 63 sizeof(struct xfs_disk_dquot)); 64 } 65 66 /* 67 * Increment the pin count of the given dquot. 68 */ 69 STATIC void 70 xfs_qm_dquot_logitem_pin( 71 struct xfs_log_item *lip) 72 { 73 struct xfs_dquot *dqp = DQUOT_ITEM(lip)->qli_dquot; 74 75 ASSERT(XFS_DQ_IS_LOCKED(dqp)); 76 atomic_inc(&dqp->q_pincount); 77 } 78 79 /* 80 * Decrement the pin count of the given dquot, and wake up 81 * anyone in xfs_dqwait_unpin() if the count goes to 0. The 82 * dquot must have been previously pinned with a call to 83 * xfs_qm_dquot_logitem_pin(). 84 */ 85 STATIC void 86 xfs_qm_dquot_logitem_unpin( 87 struct xfs_log_item *lip, 88 int remove) 89 { 90 struct xfs_dquot *dqp = DQUOT_ITEM(lip)->qli_dquot; 91 92 ASSERT(atomic_read(&dqp->q_pincount) > 0); 93 if (atomic_dec_and_test(&dqp->q_pincount)) 94 wake_up(&dqp->q_pinwait); 95 } 96 97 /* 98 * This is called to wait for the given dquot to be unpinned. 99 * Most of these pin/unpin routines are plagiarized from inode code. 100 */ 101 void 102 xfs_qm_dqunpin_wait( 103 struct xfs_dquot *dqp) 104 { 105 ASSERT(XFS_DQ_IS_LOCKED(dqp)); 106 if (atomic_read(&dqp->q_pincount) == 0) 107 return; 108 109 /* 110 * Give the log a push so we don't wait here too long. 111 */ 112 xfs_log_force(dqp->q_mount, 0); 113 wait_event(dqp->q_pinwait, (atomic_read(&dqp->q_pincount) == 0)); 114 } 115 116 /* 117 * Callback used to mark a buffer with XFS_LI_FAILED when items in the buffer 118 * have been failed during writeback 119 * 120 * this informs the AIL that the dquot is already flush locked on the next push, 121 * and acquires a hold on the buffer to ensure that it isn't reclaimed before 122 * dirty data makes it to disk. 123 */ 124 STATIC void 125 xfs_dquot_item_error( 126 struct xfs_log_item *lip, 127 struct xfs_buf *bp) 128 { 129 ASSERT(!completion_done(&DQUOT_ITEM(lip)->qli_dquot->q_flush)); 130 xfs_set_li_failed(lip, bp); 131 } 132 133 STATIC uint 134 xfs_qm_dquot_logitem_push( 135 struct xfs_log_item *lip, 136 struct list_head *buffer_list) 137 __releases(&lip->li_ailp->ail_lock) 138 __acquires(&lip->li_ailp->ail_lock) 139 { 140 struct xfs_dquot *dqp = DQUOT_ITEM(lip)->qli_dquot; 141 struct xfs_buf *bp = lip->li_buf; 142 uint rval = XFS_ITEM_SUCCESS; 143 int error; 144 145 if (atomic_read(&dqp->q_pincount) > 0) 146 return XFS_ITEM_PINNED; 147 148 if (!xfs_dqlock_nowait(dqp)) 149 return XFS_ITEM_LOCKED; 150 151 /* 152 * Re-check the pincount now that we stabilized the value by 153 * taking the quota lock. 154 */ 155 if (atomic_read(&dqp->q_pincount) > 0) { 156 rval = XFS_ITEM_PINNED; 157 goto out_unlock; 158 } 159 160 /* 161 * Someone else is already flushing the dquot. Nothing we can do 162 * here but wait for the flush to finish and remove the item from 163 * the AIL. 164 */ 165 if (!xfs_dqflock_nowait(dqp)) { 166 rval = XFS_ITEM_FLUSHING; 167 goto out_unlock; 168 } 169 170 spin_unlock(&lip->li_ailp->ail_lock); 171 172 error = xfs_qm_dqflush(dqp, &bp); 173 if (!error) { 174 if (!xfs_buf_delwri_queue(bp, buffer_list)) 175 rval = XFS_ITEM_FLUSHING; 176 xfs_buf_relse(bp); 177 } else if (error == -EAGAIN) 178 rval = XFS_ITEM_LOCKED; 179 180 spin_lock(&lip->li_ailp->ail_lock); 181 out_unlock: 182 xfs_dqunlock(dqp); 183 return rval; 184 } 185 186 STATIC void 187 xfs_qm_dquot_logitem_release( 188 struct xfs_log_item *lip) 189 { 190 struct xfs_dquot *dqp = DQUOT_ITEM(lip)->qli_dquot; 191 192 ASSERT(XFS_DQ_IS_LOCKED(dqp)); 193 194 /* 195 * dquots are never 'held' from getting unlocked at the end of 196 * a transaction. Their locking and unlocking is hidden inside the 197 * transaction layer, within trans_commit. Hence, no LI_HOLD flag 198 * for the logitem. 199 */ 200 xfs_dqunlock(dqp); 201 } 202 203 STATIC void 204 xfs_qm_dquot_logitem_committing( 205 struct xfs_log_item *lip, 206 xfs_lsn_t commit_lsn) 207 { 208 return xfs_qm_dquot_logitem_release(lip); 209 } 210 211 static const struct xfs_item_ops xfs_dquot_item_ops = { 212 .iop_size = xfs_qm_dquot_logitem_size, 213 .iop_format = xfs_qm_dquot_logitem_format, 214 .iop_pin = xfs_qm_dquot_logitem_pin, 215 .iop_unpin = xfs_qm_dquot_logitem_unpin, 216 .iop_release = xfs_qm_dquot_logitem_release, 217 .iop_committing = xfs_qm_dquot_logitem_committing, 218 .iop_push = xfs_qm_dquot_logitem_push, 219 .iop_error = xfs_dquot_item_error 220 }; 221 222 /* 223 * Initialize the dquot log item for a newly allocated dquot. 224 * The dquot isn't locked at this point, but it isn't on any of the lists 225 * either, so we don't care. 226 */ 227 void 228 xfs_qm_dquot_logitem_init( 229 struct xfs_dquot *dqp) 230 { 231 struct xfs_dq_logitem *lp = &dqp->q_logitem; 232 233 xfs_log_item_init(dqp->q_mount, &lp->qli_item, XFS_LI_DQUOT, 234 &xfs_dquot_item_ops); 235 lp->qli_dquot = dqp; 236 } 237 238 /*------------------ QUOTAOFF LOG ITEMS -------------------*/ 239 240 static inline struct xfs_qoff_logitem *QOFF_ITEM(struct xfs_log_item *lip) 241 { 242 return container_of(lip, struct xfs_qoff_logitem, qql_item); 243 } 244 245 246 /* 247 * This returns the number of iovecs needed to log the given quotaoff item. 248 * We only need 1 iovec for an quotaoff item. It just logs the 249 * quotaoff_log_format structure. 250 */ 251 STATIC void 252 xfs_qm_qoff_logitem_size( 253 struct xfs_log_item *lip, 254 int *nvecs, 255 int *nbytes) 256 { 257 *nvecs += 1; 258 *nbytes += sizeof(struct xfs_qoff_logitem); 259 } 260 261 STATIC void 262 xfs_qm_qoff_logitem_format( 263 struct xfs_log_item *lip, 264 struct xfs_log_vec *lv) 265 { 266 struct xfs_qoff_logitem *qflip = QOFF_ITEM(lip); 267 struct xfs_log_iovec *vecp = NULL; 268 struct xfs_qoff_logformat *qlf; 269 270 qlf = xlog_prepare_iovec(lv, &vecp, XLOG_REG_TYPE_QUOTAOFF); 271 qlf->qf_type = XFS_LI_QUOTAOFF; 272 qlf->qf_size = 1; 273 qlf->qf_flags = qflip->qql_flags; 274 xlog_finish_iovec(lv, vecp, sizeof(struct xfs_qoff_logitem)); 275 } 276 277 /* 278 * There isn't much you can do to push a quotaoff item. It is simply 279 * stuck waiting for the log to be flushed to disk. 280 */ 281 STATIC uint 282 xfs_qm_qoff_logitem_push( 283 struct xfs_log_item *lip, 284 struct list_head *buffer_list) 285 { 286 return XFS_ITEM_LOCKED; 287 } 288 289 STATIC xfs_lsn_t 290 xfs_qm_qoffend_logitem_committed( 291 struct xfs_log_item *lip, 292 xfs_lsn_t lsn) 293 { 294 struct xfs_qoff_logitem *qfe = QOFF_ITEM(lip); 295 struct xfs_qoff_logitem *qfs = qfe->qql_start_lip; 296 297 xfs_qm_qoff_logitem_relse(qfs); 298 299 kmem_free(lip->li_lv_shadow); 300 kmem_free(qfe); 301 return (xfs_lsn_t)-1; 302 } 303 304 STATIC void 305 xfs_qm_qoff_logitem_release( 306 struct xfs_log_item *lip) 307 { 308 struct xfs_qoff_logitem *qoff = QOFF_ITEM(lip); 309 310 if (test_bit(XFS_LI_ABORTED, &lip->li_flags)) { 311 if (qoff->qql_start_lip) 312 xfs_qm_qoff_logitem_relse(qoff->qql_start_lip); 313 xfs_qm_qoff_logitem_relse(qoff); 314 } 315 } 316 317 static const struct xfs_item_ops xfs_qm_qoffend_logitem_ops = { 318 .iop_size = xfs_qm_qoff_logitem_size, 319 .iop_format = xfs_qm_qoff_logitem_format, 320 .iop_committed = xfs_qm_qoffend_logitem_committed, 321 .iop_push = xfs_qm_qoff_logitem_push, 322 .iop_release = xfs_qm_qoff_logitem_release, 323 }; 324 325 static const struct xfs_item_ops xfs_qm_qoff_logitem_ops = { 326 .iop_size = xfs_qm_qoff_logitem_size, 327 .iop_format = xfs_qm_qoff_logitem_format, 328 .iop_push = xfs_qm_qoff_logitem_push, 329 .iop_release = xfs_qm_qoff_logitem_release, 330 }; 331 332 /* 333 * Delete the quotaoff intent from the AIL and free it. On success, 334 * this should only be called for the start item. It can be used for 335 * either on shutdown or abort. 336 */ 337 void 338 xfs_qm_qoff_logitem_relse( 339 struct xfs_qoff_logitem *qoff) 340 { 341 struct xfs_log_item *lip = &qoff->qql_item; 342 343 ASSERT(test_bit(XFS_LI_IN_AIL, &lip->li_flags) || 344 test_bit(XFS_LI_ABORTED, &lip->li_flags) || 345 XFS_FORCED_SHUTDOWN(lip->li_mountp)); 346 xfs_trans_ail_delete(lip, 0); 347 kmem_free(lip->li_lv_shadow); 348 kmem_free(qoff); 349 } 350 351 /* 352 * Allocate and initialize an quotaoff item of the correct quota type(s). 353 */ 354 struct xfs_qoff_logitem * 355 xfs_qm_qoff_logitem_init( 356 struct xfs_mount *mp, 357 struct xfs_qoff_logitem *start, 358 uint flags) 359 { 360 struct xfs_qoff_logitem *qf; 361 362 qf = kmem_zalloc(sizeof(struct xfs_qoff_logitem), 0); 363 364 xfs_log_item_init(mp, &qf->qql_item, XFS_LI_QUOTAOFF, start ? 365 &xfs_qm_qoffend_logitem_ops : &xfs_qm_qoff_logitem_ops); 366 qf->qql_item.li_mountp = mp; 367 qf->qql_start_lip = start; 368 qf->qql_flags = flags; 369 return qf; 370 } 371