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_format.h" 21 #include "xfs_log_format.h" 22 #include "xfs_trans_resv.h" 23 #include "xfs_sb.h" 24 #include "xfs_ag.h" 25 #include "xfs_mount.h" 26 #include "xfs_inode.h" 27 #include "xfs_quota.h" 28 #include "xfs_error.h" 29 #include "xfs_trans.h" 30 #include "xfs_buf_item.h" 31 #include "xfs_trans_priv.h" 32 #include "xfs_qm.h" 33 #include "xfs_log.h" 34 35 static inline struct xfs_dq_logitem *DQUOT_ITEM(struct xfs_log_item *lip) 36 { 37 return container_of(lip, struct xfs_dq_logitem, qli_item); 38 } 39 40 /* 41 * returns the number of iovecs needed to log the given dquot item. 42 */ 43 STATIC void 44 xfs_qm_dquot_logitem_size( 45 struct xfs_log_item *lip, 46 int *nvecs, 47 int *nbytes) 48 { 49 *nvecs += 2; 50 *nbytes += sizeof(struct xfs_dq_logformat) + 51 sizeof(struct xfs_disk_dquot); 52 } 53 54 /* 55 * fills in the vector of log iovecs for the given dquot log item. 56 */ 57 STATIC void 58 xfs_qm_dquot_logitem_format( 59 struct xfs_log_item *lip, 60 struct xfs_log_iovec *logvec) 61 { 62 struct xfs_dq_logitem *qlip = DQUOT_ITEM(lip); 63 64 logvec->i_addr = &qlip->qli_format; 65 logvec->i_len = sizeof(xfs_dq_logformat_t); 66 logvec->i_type = XLOG_REG_TYPE_QFORMAT; 67 logvec++; 68 logvec->i_addr = &qlip->qli_dquot->q_core; 69 logvec->i_len = sizeof(xfs_disk_dquot_t); 70 logvec->i_type = XLOG_REG_TYPE_DQUOT; 71 72 qlip->qli_format.qlf_size = 2; 73 74 } 75 76 /* 77 * Increment the pin count of the given dquot. 78 */ 79 STATIC void 80 xfs_qm_dquot_logitem_pin( 81 struct xfs_log_item *lip) 82 { 83 struct xfs_dquot *dqp = DQUOT_ITEM(lip)->qli_dquot; 84 85 ASSERT(XFS_DQ_IS_LOCKED(dqp)); 86 atomic_inc(&dqp->q_pincount); 87 } 88 89 /* 90 * Decrement the pin count of the given dquot, and wake up 91 * anyone in xfs_dqwait_unpin() if the count goes to 0. The 92 * dquot must have been previously pinned with a call to 93 * xfs_qm_dquot_logitem_pin(). 94 */ 95 STATIC void 96 xfs_qm_dquot_logitem_unpin( 97 struct xfs_log_item *lip, 98 int remove) 99 { 100 struct xfs_dquot *dqp = DQUOT_ITEM(lip)->qli_dquot; 101 102 ASSERT(atomic_read(&dqp->q_pincount) > 0); 103 if (atomic_dec_and_test(&dqp->q_pincount)) 104 wake_up(&dqp->q_pinwait); 105 } 106 107 STATIC xfs_lsn_t 108 xfs_qm_dquot_logitem_committed( 109 struct xfs_log_item *lip, 110 xfs_lsn_t lsn) 111 { 112 /* 113 * We always re-log the entire dquot when it becomes dirty, 114 * so, the latest copy _is_ the only one that matters. 115 */ 116 return lsn; 117 } 118 119 /* 120 * This is called to wait for the given dquot to be unpinned. 121 * Most of these pin/unpin routines are plagiarized from inode code. 122 */ 123 void 124 xfs_qm_dqunpin_wait( 125 struct xfs_dquot *dqp) 126 { 127 ASSERT(XFS_DQ_IS_LOCKED(dqp)); 128 if (atomic_read(&dqp->q_pincount) == 0) 129 return; 130 131 /* 132 * Give the log a push so we don't wait here too long. 133 */ 134 xfs_log_force(dqp->q_mount, 0); 135 wait_event(dqp->q_pinwait, (atomic_read(&dqp->q_pincount) == 0)); 136 } 137 138 STATIC uint 139 xfs_qm_dquot_logitem_push( 140 struct xfs_log_item *lip, 141 struct list_head *buffer_list) __releases(&lip->li_ailp->xa_lock) 142 __acquires(&lip->li_ailp->xa_lock) 143 { 144 struct xfs_dquot *dqp = DQUOT_ITEM(lip)->qli_dquot; 145 struct xfs_buf *bp = NULL; 146 uint rval = XFS_ITEM_SUCCESS; 147 int error; 148 149 if (atomic_read(&dqp->q_pincount) > 0) 150 return XFS_ITEM_PINNED; 151 152 if (!xfs_dqlock_nowait(dqp)) 153 return XFS_ITEM_LOCKED; 154 155 /* 156 * Re-check the pincount now that we stabilized the value by 157 * taking the quota lock. 158 */ 159 if (atomic_read(&dqp->q_pincount) > 0) { 160 rval = XFS_ITEM_PINNED; 161 goto out_unlock; 162 } 163 164 /* 165 * Someone else is already flushing the dquot. Nothing we can do 166 * here but wait for the flush to finish and remove the item from 167 * the AIL. 168 */ 169 if (!xfs_dqflock_nowait(dqp)) { 170 rval = XFS_ITEM_FLUSHING; 171 goto out_unlock; 172 } 173 174 spin_unlock(&lip->li_ailp->xa_lock); 175 176 error = xfs_qm_dqflush(dqp, &bp); 177 if (error) { 178 xfs_warn(dqp->q_mount, "%s: push error %d on dqp %p", 179 __func__, error, dqp); 180 } else { 181 if (!xfs_buf_delwri_queue(bp, buffer_list)) 182 rval = XFS_ITEM_FLUSHING; 183 xfs_buf_relse(bp); 184 } 185 186 spin_lock(&lip->li_ailp->xa_lock); 187 out_unlock: 188 xfs_dqunlock(dqp); 189 return rval; 190 } 191 192 /* 193 * Unlock the dquot associated with the log item. 194 * Clear the fields of the dquot and dquot log item that 195 * are specific to the current transaction. If the 196 * hold flags is set, do not unlock the dquot. 197 */ 198 STATIC void 199 xfs_qm_dquot_logitem_unlock( 200 struct xfs_log_item *lip) 201 { 202 struct xfs_dquot *dqp = DQUOT_ITEM(lip)->qli_dquot; 203 204 ASSERT(XFS_DQ_IS_LOCKED(dqp)); 205 206 /* 207 * Clear the transaction pointer in the dquot 208 */ 209 dqp->q_transp = NULL; 210 211 /* 212 * dquots are never 'held' from getting unlocked at the end of 213 * a transaction. Their locking and unlocking is hidden inside the 214 * transaction layer, within trans_commit. Hence, no LI_HOLD flag 215 * for the logitem. 216 */ 217 xfs_dqunlock(dqp); 218 } 219 220 /* 221 * this needs to stamp an lsn into the dquot, I think. 222 * rpc's that look at user dquot's would then have to 223 * push on the dependency recorded in the dquot 224 */ 225 STATIC void 226 xfs_qm_dquot_logitem_committing( 227 struct xfs_log_item *lip, 228 xfs_lsn_t lsn) 229 { 230 } 231 232 /* 233 * This is the ops vector for dquots 234 */ 235 static const struct xfs_item_ops xfs_dquot_item_ops = { 236 .iop_size = xfs_qm_dquot_logitem_size, 237 .iop_format = xfs_qm_dquot_logitem_format, 238 .iop_pin = xfs_qm_dquot_logitem_pin, 239 .iop_unpin = xfs_qm_dquot_logitem_unpin, 240 .iop_unlock = xfs_qm_dquot_logitem_unlock, 241 .iop_committed = xfs_qm_dquot_logitem_committed, 242 .iop_push = xfs_qm_dquot_logitem_push, 243 .iop_committing = xfs_qm_dquot_logitem_committing 244 }; 245 246 /* 247 * Initialize the dquot log item for a newly allocated dquot. 248 * The dquot isn't locked at this point, but it isn't on any of the lists 249 * either, so we don't care. 250 */ 251 void 252 xfs_qm_dquot_logitem_init( 253 struct xfs_dquot *dqp) 254 { 255 struct xfs_dq_logitem *lp = &dqp->q_logitem; 256 257 xfs_log_item_init(dqp->q_mount, &lp->qli_item, XFS_LI_DQUOT, 258 &xfs_dquot_item_ops); 259 lp->qli_dquot = dqp; 260 lp->qli_format.qlf_type = XFS_LI_DQUOT; 261 lp->qli_format.qlf_id = be32_to_cpu(dqp->q_core.d_id); 262 lp->qli_format.qlf_blkno = dqp->q_blkno; 263 lp->qli_format.qlf_len = 1; 264 /* 265 * This is just the offset of this dquot within its buffer 266 * (which is currently 1 FSB and probably won't change). 267 * Hence 32 bits for this offset should be just fine. 268 * Alternatively, we can store (bufoffset / sizeof(xfs_dqblk_t)) 269 * here, and recompute it at recovery time. 270 */ 271 lp->qli_format.qlf_boffset = (__uint32_t)dqp->q_bufoffset; 272 } 273 274 /*------------------ QUOTAOFF LOG ITEMS -------------------*/ 275 276 static inline struct xfs_qoff_logitem *QOFF_ITEM(struct xfs_log_item *lip) 277 { 278 return container_of(lip, struct xfs_qoff_logitem, qql_item); 279 } 280 281 282 /* 283 * This returns the number of iovecs needed to log the given quotaoff item. 284 * We only need 1 iovec for an quotaoff item. It just logs the 285 * quotaoff_log_format structure. 286 */ 287 STATIC void 288 xfs_qm_qoff_logitem_size( 289 struct xfs_log_item *lip, 290 int *nvecs, 291 int *nbytes) 292 { 293 *nvecs += 1; 294 *nbytes += sizeof(struct xfs_qoff_logitem); 295 } 296 297 /* 298 * This is called to fill in the vector of log iovecs for the 299 * given quotaoff log item. We use only 1 iovec, and we point that 300 * at the quotaoff_log_format structure embedded in the quotaoff item. 301 * It is at this point that we assert that all of the extent 302 * slots in the quotaoff item have been filled. 303 */ 304 STATIC void 305 xfs_qm_qoff_logitem_format( 306 struct xfs_log_item *lip, 307 struct xfs_log_iovec *log_vector) 308 { 309 struct xfs_qoff_logitem *qflip = QOFF_ITEM(lip); 310 311 ASSERT(qflip->qql_format.qf_type == XFS_LI_QUOTAOFF); 312 313 log_vector->i_addr = &qflip->qql_format; 314 log_vector->i_len = sizeof(xfs_qoff_logitem_t); 315 log_vector->i_type = XLOG_REG_TYPE_QUOTAOFF; 316 qflip->qql_format.qf_size = 1; 317 } 318 319 /* 320 * Pinning has no meaning for an quotaoff item, so just return. 321 */ 322 STATIC void 323 xfs_qm_qoff_logitem_pin( 324 struct xfs_log_item *lip) 325 { 326 } 327 328 /* 329 * Since pinning has no meaning for an quotaoff item, unpinning does 330 * not either. 331 */ 332 STATIC void 333 xfs_qm_qoff_logitem_unpin( 334 struct xfs_log_item *lip, 335 int remove) 336 { 337 } 338 339 /* 340 * There isn't much you can do to push a quotaoff item. It is simply 341 * stuck waiting for the log to be flushed to disk. 342 */ 343 STATIC uint 344 xfs_qm_qoff_logitem_push( 345 struct xfs_log_item *lip, 346 struct list_head *buffer_list) 347 { 348 return XFS_ITEM_LOCKED; 349 } 350 351 /* 352 * Quotaoff items have no locking or pushing, so return failure 353 * so that the caller doesn't bother with us. 354 */ 355 STATIC void 356 xfs_qm_qoff_logitem_unlock( 357 struct xfs_log_item *lip) 358 { 359 } 360 361 /* 362 * The quotaoff-start-item is logged only once and cannot be moved in the log, 363 * so simply return the lsn at which it's been logged. 364 */ 365 STATIC xfs_lsn_t 366 xfs_qm_qoff_logitem_committed( 367 struct xfs_log_item *lip, 368 xfs_lsn_t lsn) 369 { 370 return lsn; 371 } 372 373 STATIC xfs_lsn_t 374 xfs_qm_qoffend_logitem_committed( 375 struct xfs_log_item *lip, 376 xfs_lsn_t lsn) 377 { 378 struct xfs_qoff_logitem *qfe = QOFF_ITEM(lip); 379 struct xfs_qoff_logitem *qfs = qfe->qql_start_lip; 380 struct xfs_ail *ailp = qfs->qql_item.li_ailp; 381 382 /* 383 * Delete the qoff-start logitem from the AIL. 384 * xfs_trans_ail_delete() drops the AIL lock. 385 */ 386 spin_lock(&ailp->xa_lock); 387 xfs_trans_ail_delete(ailp, &qfs->qql_item, SHUTDOWN_LOG_IO_ERROR); 388 389 kmem_free(qfs); 390 kmem_free(qfe); 391 return (xfs_lsn_t)-1; 392 } 393 394 /* 395 * XXX rcc - don't know quite what to do with this. I think we can 396 * just ignore it. The only time that isn't the case is if we allow 397 * the client to somehow see that quotas have been turned off in which 398 * we can't allow that to get back until the quotaoff hits the disk. 399 * So how would that happen? Also, do we need different routines for 400 * quotaoff start and quotaoff end? I suspect the answer is yes but 401 * to be sure, I need to look at the recovery code and see how quota off 402 * recovery is handled (do we roll forward or back or do something else). 403 * If we roll forwards or backwards, then we need two separate routines, 404 * one that does nothing and one that stamps in the lsn that matters 405 * (truly makes the quotaoff irrevocable). If we do something else, 406 * then maybe we don't need two. 407 */ 408 STATIC void 409 xfs_qm_qoff_logitem_committing( 410 struct xfs_log_item *lip, 411 xfs_lsn_t commit_lsn) 412 { 413 } 414 415 static const struct xfs_item_ops xfs_qm_qoffend_logitem_ops = { 416 .iop_size = xfs_qm_qoff_logitem_size, 417 .iop_format = xfs_qm_qoff_logitem_format, 418 .iop_pin = xfs_qm_qoff_logitem_pin, 419 .iop_unpin = xfs_qm_qoff_logitem_unpin, 420 .iop_unlock = xfs_qm_qoff_logitem_unlock, 421 .iop_committed = xfs_qm_qoffend_logitem_committed, 422 .iop_push = xfs_qm_qoff_logitem_push, 423 .iop_committing = xfs_qm_qoff_logitem_committing 424 }; 425 426 /* 427 * This is the ops vector shared by all quotaoff-start log items. 428 */ 429 static const struct xfs_item_ops xfs_qm_qoff_logitem_ops = { 430 .iop_size = xfs_qm_qoff_logitem_size, 431 .iop_format = xfs_qm_qoff_logitem_format, 432 .iop_pin = xfs_qm_qoff_logitem_pin, 433 .iop_unpin = xfs_qm_qoff_logitem_unpin, 434 .iop_unlock = xfs_qm_qoff_logitem_unlock, 435 .iop_committed = xfs_qm_qoff_logitem_committed, 436 .iop_push = xfs_qm_qoff_logitem_push, 437 .iop_committing = xfs_qm_qoff_logitem_committing 438 }; 439 440 /* 441 * Allocate and initialize an quotaoff item of the correct quota type(s). 442 */ 443 struct xfs_qoff_logitem * 444 xfs_qm_qoff_logitem_init( 445 struct xfs_mount *mp, 446 struct xfs_qoff_logitem *start, 447 uint flags) 448 { 449 struct xfs_qoff_logitem *qf; 450 451 qf = kmem_zalloc(sizeof(struct xfs_qoff_logitem), KM_SLEEP); 452 453 xfs_log_item_init(mp, &qf->qql_item, XFS_LI_QUOTAOFF, start ? 454 &xfs_qm_qoffend_logitem_ops : &xfs_qm_qoff_logitem_ops); 455 qf->qql_item.li_mountp = mp; 456 qf->qql_format.qf_type = XFS_LI_QUOTAOFF; 457 qf->qql_format.qf_flags = flags; 458 qf->qql_start_lip = start; 459 return qf; 460 } 461