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_format.h" 9 #include "xfs_log_format.h" 10 #include "xfs_trans_resv.h" 11 #include "xfs_mount.h" 12 #include "xfs_inode.h" 13 #include "xfs_quota.h" 14 #include "xfs_error.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 STATIC xfs_lsn_t 98 xfs_qm_dquot_logitem_committed( 99 struct xfs_log_item *lip, 100 xfs_lsn_t lsn) 101 { 102 /* 103 * We always re-log the entire dquot when it becomes dirty, 104 * so, the latest copy _is_ the only one that matters. 105 */ 106 return lsn; 107 } 108 109 /* 110 * This is called to wait for the given dquot to be unpinned. 111 * Most of these pin/unpin routines are plagiarized from inode code. 112 */ 113 void 114 xfs_qm_dqunpin_wait( 115 struct xfs_dquot *dqp) 116 { 117 ASSERT(XFS_DQ_IS_LOCKED(dqp)); 118 if (atomic_read(&dqp->q_pincount) == 0) 119 return; 120 121 /* 122 * Give the log a push so we don't wait here too long. 123 */ 124 xfs_log_force(dqp->q_mount, 0); 125 wait_event(dqp->q_pinwait, (atomic_read(&dqp->q_pincount) == 0)); 126 } 127 128 /* 129 * Callback used to mark a buffer with XFS_LI_FAILED when items in the buffer 130 * have been failed during writeback 131 * 132 * this informs the AIL that the dquot is already flush locked on the next push, 133 * and acquires a hold on the buffer to ensure that it isn't reclaimed before 134 * dirty data makes it to disk. 135 */ 136 STATIC void 137 xfs_dquot_item_error( 138 struct xfs_log_item *lip, 139 struct xfs_buf *bp) 140 { 141 ASSERT(!completion_done(&DQUOT_ITEM(lip)->qli_dquot->q_flush)); 142 xfs_set_li_failed(lip, bp); 143 } 144 145 STATIC uint 146 xfs_qm_dquot_logitem_push( 147 struct xfs_log_item *lip, 148 struct list_head *buffer_list) 149 __releases(&lip->li_ailp->ail_lock) 150 __acquires(&lip->li_ailp->ail_lock) 151 { 152 struct xfs_dquot *dqp = DQUOT_ITEM(lip)->qli_dquot; 153 struct xfs_buf *bp = lip->li_buf; 154 uint rval = XFS_ITEM_SUCCESS; 155 int error; 156 157 if (atomic_read(&dqp->q_pincount) > 0) 158 return XFS_ITEM_PINNED; 159 160 /* 161 * The buffer containing this item failed to be written back 162 * previously. Resubmit the buffer for IO 163 */ 164 if (test_bit(XFS_LI_FAILED, &lip->li_flags)) { 165 if (!xfs_buf_trylock(bp)) 166 return XFS_ITEM_LOCKED; 167 168 if (!xfs_buf_resubmit_failed_buffers(bp, buffer_list)) 169 rval = XFS_ITEM_FLUSHING; 170 171 xfs_buf_unlock(bp); 172 return rval; 173 } 174 175 if (!xfs_dqlock_nowait(dqp)) 176 return XFS_ITEM_LOCKED; 177 178 /* 179 * Re-check the pincount now that we stabilized the value by 180 * taking the quota lock. 181 */ 182 if (atomic_read(&dqp->q_pincount) > 0) { 183 rval = XFS_ITEM_PINNED; 184 goto out_unlock; 185 } 186 187 /* 188 * Someone else is already flushing the dquot. Nothing we can do 189 * here but wait for the flush to finish and remove the item from 190 * the AIL. 191 */ 192 if (!xfs_dqflock_nowait(dqp)) { 193 rval = XFS_ITEM_FLUSHING; 194 goto out_unlock; 195 } 196 197 spin_unlock(&lip->li_ailp->ail_lock); 198 199 error = xfs_qm_dqflush(dqp, &bp); 200 if (!error) { 201 if (!xfs_buf_delwri_queue(bp, buffer_list)) 202 rval = XFS_ITEM_FLUSHING; 203 xfs_buf_relse(bp); 204 } 205 206 spin_lock(&lip->li_ailp->ail_lock); 207 out_unlock: 208 xfs_dqunlock(dqp); 209 return rval; 210 } 211 212 /* 213 * Unlock the dquot associated with the log item. 214 * Clear the fields of the dquot and dquot log item that 215 * are specific to the current transaction. If the 216 * hold flags is set, do not unlock the dquot. 217 */ 218 STATIC void 219 xfs_qm_dquot_logitem_unlock( 220 struct xfs_log_item *lip) 221 { 222 struct xfs_dquot *dqp = DQUOT_ITEM(lip)->qli_dquot; 223 224 ASSERT(XFS_DQ_IS_LOCKED(dqp)); 225 226 /* 227 * Clear the transaction pointer in the dquot 228 */ 229 dqp->q_transp = NULL; 230 231 /* 232 * dquots are never 'held' from getting unlocked at the end of 233 * a transaction. Their locking and unlocking is hidden inside the 234 * transaction layer, within trans_commit. Hence, no LI_HOLD flag 235 * for the logitem. 236 */ 237 xfs_dqunlock(dqp); 238 } 239 240 /* 241 * this needs to stamp an lsn into the dquot, I think. 242 * rpc's that look at user dquot's would then have to 243 * push on the dependency recorded in the dquot 244 */ 245 STATIC void 246 xfs_qm_dquot_logitem_committing( 247 struct xfs_log_item *lip, 248 xfs_lsn_t lsn) 249 { 250 } 251 252 /* 253 * This is the ops vector for dquots 254 */ 255 static const struct xfs_item_ops xfs_dquot_item_ops = { 256 .iop_size = xfs_qm_dquot_logitem_size, 257 .iop_format = xfs_qm_dquot_logitem_format, 258 .iop_pin = xfs_qm_dquot_logitem_pin, 259 .iop_unpin = xfs_qm_dquot_logitem_unpin, 260 .iop_unlock = xfs_qm_dquot_logitem_unlock, 261 .iop_committed = xfs_qm_dquot_logitem_committed, 262 .iop_push = xfs_qm_dquot_logitem_push, 263 .iop_committing = xfs_qm_dquot_logitem_committing, 264 .iop_error = xfs_dquot_item_error 265 }; 266 267 /* 268 * Initialize the dquot log item for a newly allocated dquot. 269 * The dquot isn't locked at this point, but it isn't on any of the lists 270 * either, so we don't care. 271 */ 272 void 273 xfs_qm_dquot_logitem_init( 274 struct xfs_dquot *dqp) 275 { 276 struct xfs_dq_logitem *lp = &dqp->q_logitem; 277 278 xfs_log_item_init(dqp->q_mount, &lp->qli_item, XFS_LI_DQUOT, 279 &xfs_dquot_item_ops); 280 lp->qli_dquot = dqp; 281 } 282 283 /*------------------ QUOTAOFF LOG ITEMS -------------------*/ 284 285 static inline struct xfs_qoff_logitem *QOFF_ITEM(struct xfs_log_item *lip) 286 { 287 return container_of(lip, struct xfs_qoff_logitem, qql_item); 288 } 289 290 291 /* 292 * This returns the number of iovecs needed to log the given quotaoff item. 293 * We only need 1 iovec for an quotaoff item. It just logs the 294 * quotaoff_log_format structure. 295 */ 296 STATIC void 297 xfs_qm_qoff_logitem_size( 298 struct xfs_log_item *lip, 299 int *nvecs, 300 int *nbytes) 301 { 302 *nvecs += 1; 303 *nbytes += sizeof(struct xfs_qoff_logitem); 304 } 305 306 STATIC void 307 xfs_qm_qoff_logitem_format( 308 struct xfs_log_item *lip, 309 struct xfs_log_vec *lv) 310 { 311 struct xfs_qoff_logitem *qflip = QOFF_ITEM(lip); 312 struct xfs_log_iovec *vecp = NULL; 313 struct xfs_qoff_logformat *qlf; 314 315 qlf = xlog_prepare_iovec(lv, &vecp, XLOG_REG_TYPE_QUOTAOFF); 316 qlf->qf_type = XFS_LI_QUOTAOFF; 317 qlf->qf_size = 1; 318 qlf->qf_flags = qflip->qql_flags; 319 xlog_finish_iovec(lv, vecp, sizeof(struct xfs_qoff_logitem)); 320 } 321 322 /* 323 * Pinning has no meaning for an quotaoff item, so just return. 324 */ 325 STATIC void 326 xfs_qm_qoff_logitem_pin( 327 struct xfs_log_item *lip) 328 { 329 } 330 331 /* 332 * Since pinning has no meaning for an quotaoff item, unpinning does 333 * not either. 334 */ 335 STATIC void 336 xfs_qm_qoff_logitem_unpin( 337 struct xfs_log_item *lip, 338 int remove) 339 { 340 } 341 342 /* 343 * There isn't much you can do to push a quotaoff item. It is simply 344 * stuck waiting for the log to be flushed to disk. 345 */ 346 STATIC uint 347 xfs_qm_qoff_logitem_push( 348 struct xfs_log_item *lip, 349 struct list_head *buffer_list) 350 { 351 return XFS_ITEM_LOCKED; 352 } 353 354 /* 355 * Quotaoff items have no locking or pushing, so return failure 356 * so that the caller doesn't bother with us. 357 */ 358 STATIC void 359 xfs_qm_qoff_logitem_unlock( 360 struct xfs_log_item *lip) 361 { 362 } 363 364 /* 365 * The quotaoff-start-item is logged only once and cannot be moved in the log, 366 * so simply return the lsn at which it's been logged. 367 */ 368 STATIC xfs_lsn_t 369 xfs_qm_qoff_logitem_committed( 370 struct xfs_log_item *lip, 371 xfs_lsn_t lsn) 372 { 373 return lsn; 374 } 375 376 STATIC xfs_lsn_t 377 xfs_qm_qoffend_logitem_committed( 378 struct xfs_log_item *lip, 379 xfs_lsn_t lsn) 380 { 381 struct xfs_qoff_logitem *qfe = QOFF_ITEM(lip); 382 struct xfs_qoff_logitem *qfs = qfe->qql_start_lip; 383 struct xfs_ail *ailp = qfs->qql_item.li_ailp; 384 385 /* 386 * Delete the qoff-start logitem from the AIL. 387 * xfs_trans_ail_delete() drops the AIL lock. 388 */ 389 spin_lock(&ailp->ail_lock); 390 xfs_trans_ail_delete(ailp, &qfs->qql_item, SHUTDOWN_LOG_IO_ERROR); 391 392 kmem_free(qfs->qql_item.li_lv_shadow); 393 kmem_free(lip->li_lv_shadow); 394 kmem_free(qfs); 395 kmem_free(qfe); 396 return (xfs_lsn_t)-1; 397 } 398 399 /* 400 * XXX rcc - don't know quite what to do with this. I think we can 401 * just ignore it. The only time that isn't the case is if we allow 402 * the client to somehow see that quotas have been turned off in which 403 * we can't allow that to get back until the quotaoff hits the disk. 404 * So how would that happen? Also, do we need different routines for 405 * quotaoff start and quotaoff end? I suspect the answer is yes but 406 * to be sure, I need to look at the recovery code and see how quota off 407 * recovery is handled (do we roll forward or back or do something else). 408 * If we roll forwards or backwards, then we need two separate routines, 409 * one that does nothing and one that stamps in the lsn that matters 410 * (truly makes the quotaoff irrevocable). If we do something else, 411 * then maybe we don't need two. 412 */ 413 STATIC void 414 xfs_qm_qoff_logitem_committing( 415 struct xfs_log_item *lip, 416 xfs_lsn_t commit_lsn) 417 { 418 } 419 420 static const struct xfs_item_ops xfs_qm_qoffend_logitem_ops = { 421 .iop_size = xfs_qm_qoff_logitem_size, 422 .iop_format = xfs_qm_qoff_logitem_format, 423 .iop_pin = xfs_qm_qoff_logitem_pin, 424 .iop_unpin = xfs_qm_qoff_logitem_unpin, 425 .iop_unlock = xfs_qm_qoff_logitem_unlock, 426 .iop_committed = xfs_qm_qoffend_logitem_committed, 427 .iop_push = xfs_qm_qoff_logitem_push, 428 .iop_committing = xfs_qm_qoff_logitem_committing 429 }; 430 431 /* 432 * This is the ops vector shared by all quotaoff-start log items. 433 */ 434 static const struct xfs_item_ops xfs_qm_qoff_logitem_ops = { 435 .iop_size = xfs_qm_qoff_logitem_size, 436 .iop_format = xfs_qm_qoff_logitem_format, 437 .iop_pin = xfs_qm_qoff_logitem_pin, 438 .iop_unpin = xfs_qm_qoff_logitem_unpin, 439 .iop_unlock = xfs_qm_qoff_logitem_unlock, 440 .iop_committed = xfs_qm_qoff_logitem_committed, 441 .iop_push = xfs_qm_qoff_logitem_push, 442 .iop_committing = xfs_qm_qoff_logitem_committing 443 }; 444 445 /* 446 * Allocate and initialize an quotaoff item of the correct quota type(s). 447 */ 448 struct xfs_qoff_logitem * 449 xfs_qm_qoff_logitem_init( 450 struct xfs_mount *mp, 451 struct xfs_qoff_logitem *start, 452 uint flags) 453 { 454 struct xfs_qoff_logitem *qf; 455 456 qf = kmem_zalloc(sizeof(struct xfs_qoff_logitem), KM_SLEEP); 457 458 xfs_log_item_init(mp, &qf->qql_item, XFS_LI_QUOTAOFF, start ? 459 &xfs_qm_qoffend_logitem_ops : &xfs_qm_qoff_logitem_ops); 460 qf->qql_item.li_mountp = mp; 461 qf->qql_start_lip = start; 462 qf->qql_flags = flags; 463 return qf; 464 } 465