1/* 2 * Implementation of operations over global quota file 3 */ 4#include <linux/spinlock.h> 5#include <linux/fs.h> 6#include <linux/slab.h> 7#include <linux/quota.h> 8#include <linux/quotaops.h> 9#include <linux/dqblk_qtree.h> 10#include <linux/jiffies.h> 11#include <linux/writeback.h> 12#include <linux/workqueue.h> 13 14#define MLOG_MASK_PREFIX ML_QUOTA 15#include <cluster/masklog.h> 16 17#include "ocfs2_fs.h" 18#include "ocfs2.h" 19#include "alloc.h" 20#include "blockcheck.h" 21#include "inode.h" 22#include "journal.h" 23#include "file.h" 24#include "sysfile.h" 25#include "dlmglue.h" 26#include "uptodate.h" 27#include "super.h" 28#include "buffer_head_io.h" 29#include "quota.h" 30 31/* 32 * Locking of quotas with OCFS2 is rather complex. Here are rules that 33 * should be obeyed by all the functions: 34 * - any write of quota structure (either to local or global file) is protected 35 * by dqio_mutex or dquot->dq_lock. 36 * - any modification of global quota file holds inode cluster lock, i_mutex, 37 * and ip_alloc_sem of the global quota file (achieved by 38 * ocfs2_lock_global_qf). It also has to hold qinfo_lock. 39 * - an allocation of new blocks for local quota file is protected by 40 * its ip_alloc_sem 41 * 42 * A rough sketch of locking dependencies (lf = local file, gf = global file): 43 * Normal filesystem operation: 44 * start_trans -> dqio_mutex -> write to lf 45 * Syncing of local and global file: 46 * ocfs2_lock_global_qf -> start_trans -> dqio_mutex -> qinfo_lock -> 47 * write to gf 48 * -> write to lf 49 * Acquire dquot for the first time: 50 * dq_lock -> ocfs2_lock_global_qf -> qinfo_lock -> read from gf 51 * -> alloc space for gf 52 * -> start_trans -> qinfo_lock -> write to gf 53 * -> ip_alloc_sem of lf -> alloc space for lf 54 * -> write to lf 55 * Release last reference to dquot: 56 * dq_lock -> ocfs2_lock_global_qf -> start_trans -> qinfo_lock -> write to gf 57 * -> write to lf 58 * Note that all the above operations also hold the inode cluster lock of lf. 59 * Recovery: 60 * inode cluster lock of recovered lf 61 * -> read bitmaps -> ip_alloc_sem of lf 62 * -> ocfs2_lock_global_qf -> start_trans -> dqio_mutex -> qinfo_lock -> 63 * write to gf 64 */ 65 66static struct workqueue_struct *ocfs2_quota_wq = NULL; 67 68static void qsync_work_fn(struct work_struct *work); 69 70static void ocfs2_global_disk2memdqb(struct dquot *dquot, void *dp) 71{ 72 struct ocfs2_global_disk_dqblk *d = dp; 73 struct mem_dqblk *m = &dquot->dq_dqb; 74 75 /* Update from disk only entries not set by the admin */ 76 if (!test_bit(DQ_LASTSET_B + QIF_ILIMITS_B, &dquot->dq_flags)) { 77 m->dqb_ihardlimit = le64_to_cpu(d->dqb_ihardlimit); 78 m->dqb_isoftlimit = le64_to_cpu(d->dqb_isoftlimit); 79 } 80 if (!test_bit(DQ_LASTSET_B + QIF_INODES_B, &dquot->dq_flags)) 81 m->dqb_curinodes = le64_to_cpu(d->dqb_curinodes); 82 if (!test_bit(DQ_LASTSET_B + QIF_BLIMITS_B, &dquot->dq_flags)) { 83 m->dqb_bhardlimit = le64_to_cpu(d->dqb_bhardlimit); 84 m->dqb_bsoftlimit = le64_to_cpu(d->dqb_bsoftlimit); 85 } 86 if (!test_bit(DQ_LASTSET_B + QIF_SPACE_B, &dquot->dq_flags)) 87 m->dqb_curspace = le64_to_cpu(d->dqb_curspace); 88 if (!test_bit(DQ_LASTSET_B + QIF_BTIME_B, &dquot->dq_flags)) 89 m->dqb_btime = le64_to_cpu(d->dqb_btime); 90 if (!test_bit(DQ_LASTSET_B + QIF_ITIME_B, &dquot->dq_flags)) 91 m->dqb_itime = le64_to_cpu(d->dqb_itime); 92 OCFS2_DQUOT(dquot)->dq_use_count = le32_to_cpu(d->dqb_use_count); 93} 94 95static void ocfs2_global_mem2diskdqb(void *dp, struct dquot *dquot) 96{ 97 struct ocfs2_global_disk_dqblk *d = dp; 98 struct mem_dqblk *m = &dquot->dq_dqb; 99 100 d->dqb_id = cpu_to_le32(dquot->dq_id); 101 d->dqb_use_count = cpu_to_le32(OCFS2_DQUOT(dquot)->dq_use_count); 102 d->dqb_ihardlimit = cpu_to_le64(m->dqb_ihardlimit); 103 d->dqb_isoftlimit = cpu_to_le64(m->dqb_isoftlimit); 104 d->dqb_curinodes = cpu_to_le64(m->dqb_curinodes); 105 d->dqb_bhardlimit = cpu_to_le64(m->dqb_bhardlimit); 106 d->dqb_bsoftlimit = cpu_to_le64(m->dqb_bsoftlimit); 107 d->dqb_curspace = cpu_to_le64(m->dqb_curspace); 108 d->dqb_btime = cpu_to_le64(m->dqb_btime); 109 d->dqb_itime = cpu_to_le64(m->dqb_itime); 110 d->dqb_pad1 = d->dqb_pad2 = 0; 111} 112 113static int ocfs2_global_is_id(void *dp, struct dquot *dquot) 114{ 115 struct ocfs2_global_disk_dqblk *d = dp; 116 struct ocfs2_mem_dqinfo *oinfo = 117 sb_dqinfo(dquot->dq_sb, dquot->dq_type)->dqi_priv; 118 119 if (qtree_entry_unused(&oinfo->dqi_gi, dp)) 120 return 0; 121 return le32_to_cpu(d->dqb_id) == dquot->dq_id; 122} 123 124struct qtree_fmt_operations ocfs2_global_ops = { 125 .mem2disk_dqblk = ocfs2_global_mem2diskdqb, 126 .disk2mem_dqblk = ocfs2_global_disk2memdqb, 127 .is_id = ocfs2_global_is_id, 128}; 129 130int ocfs2_validate_quota_block(struct super_block *sb, struct buffer_head *bh) 131{ 132 struct ocfs2_disk_dqtrailer *dqt = 133 ocfs2_block_dqtrailer(sb->s_blocksize, bh->b_data); 134 135 mlog(0, "Validating quota block %llu\n", 136 (unsigned long long)bh->b_blocknr); 137 138 BUG_ON(!buffer_uptodate(bh)); 139 140 /* 141 * If the ecc fails, we return the error but otherwise 142 * leave the filesystem running. We know any error is 143 * local to this block. 144 */ 145 return ocfs2_validate_meta_ecc(sb, bh->b_data, &dqt->dq_check); 146} 147 148int ocfs2_read_quota_phys_block(struct inode *inode, u64 p_block, 149 struct buffer_head **bhp) 150{ 151 int rc; 152 153 *bhp = NULL; 154 rc = ocfs2_read_blocks(INODE_CACHE(inode), p_block, 1, bhp, 0, 155 ocfs2_validate_quota_block); 156 if (rc) 157 mlog_errno(rc); 158 return rc; 159} 160 161/* Read data from global quotafile - avoid pagecache and such because we cannot 162 * afford acquiring the locks... We use quota cluster lock to serialize 163 * operations. Caller is responsible for acquiring it. */ 164ssize_t ocfs2_quota_read(struct super_block *sb, int type, char *data, 165 size_t len, loff_t off) 166{ 167 struct ocfs2_mem_dqinfo *oinfo = sb_dqinfo(sb, type)->dqi_priv; 168 struct inode *gqinode = oinfo->dqi_gqinode; 169 loff_t i_size = i_size_read(gqinode); 170 int offset = off & (sb->s_blocksize - 1); 171 sector_t blk = off >> sb->s_blocksize_bits; 172 int err = 0; 173 struct buffer_head *bh; 174 size_t toread, tocopy; 175 u64 pblock = 0, pcount = 0; 176 177 if (off > i_size) 178 return 0; 179 if (off + len > i_size) 180 len = i_size - off; 181 toread = len; 182 while (toread > 0) { 183 tocopy = min_t(size_t, (sb->s_blocksize - offset), toread); 184 if (!pcount) { 185 err = ocfs2_extent_map_get_blocks(gqinode, blk, &pblock, 186 &pcount, NULL); 187 if (err) { 188 mlog_errno(err); 189 return err; 190 } 191 } else { 192 pcount--; 193 pblock++; 194 } 195 bh = NULL; 196 err = ocfs2_read_quota_phys_block(gqinode, pblock, &bh); 197 if (err) { 198 mlog_errno(err); 199 return err; 200 } 201 memcpy(data, bh->b_data + offset, tocopy); 202 brelse(bh); 203 offset = 0; 204 toread -= tocopy; 205 data += tocopy; 206 blk++; 207 } 208 return len; 209} 210 211/* Write to quotafile (we know the transaction is already started and has 212 * enough credits) */ 213ssize_t ocfs2_quota_write(struct super_block *sb, int type, 214 const char *data, size_t len, loff_t off) 215{ 216 struct mem_dqinfo *info = sb_dqinfo(sb, type); 217 struct ocfs2_mem_dqinfo *oinfo = info->dqi_priv; 218 struct inode *gqinode = oinfo->dqi_gqinode; 219 int offset = off & (sb->s_blocksize - 1); 220 sector_t blk = off >> sb->s_blocksize_bits; 221 int err = 0, new = 0, ja_type; 222 struct buffer_head *bh = NULL; 223 handle_t *handle = journal_current_handle(); 224 u64 pblock, pcount; 225 226 if (!handle) { 227 mlog(ML_ERROR, "Quota write (off=%llu, len=%llu) cancelled " 228 "because transaction was not started.\n", 229 (unsigned long long)off, (unsigned long long)len); 230 return -EIO; 231 } 232 if (len > sb->s_blocksize - OCFS2_QBLK_RESERVED_SPACE - offset) { 233 WARN_ON(1); 234 len = sb->s_blocksize - OCFS2_QBLK_RESERVED_SPACE - offset; 235 } 236 237 if (gqinode->i_size < off + len) { 238 loff_t rounded_end = 239 ocfs2_align_bytes_to_blocks(sb, off + len); 240 241 /* Space is already allocated in ocfs2_acquire_dquot() */ 242 err = ocfs2_simple_size_update(gqinode, 243 oinfo->dqi_gqi_bh, 244 rounded_end); 245 if (err < 0) 246 goto out; 247 new = 1; 248 } 249 err = ocfs2_extent_map_get_blocks(gqinode, blk, &pblock, &pcount, NULL); 250 if (err) { 251 mlog_errno(err); 252 goto out; 253 } 254 /* Not rewriting whole block? */ 255 if ((offset || len < sb->s_blocksize - OCFS2_QBLK_RESERVED_SPACE) && 256 !new) { 257 err = ocfs2_read_quota_phys_block(gqinode, pblock, &bh); 258 ja_type = OCFS2_JOURNAL_ACCESS_WRITE; 259 } else { 260 bh = sb_getblk(sb, pblock); 261 if (!bh) 262 err = -ENOMEM; 263 ja_type = OCFS2_JOURNAL_ACCESS_CREATE; 264 } 265 if (err) { 266 mlog_errno(err); 267 goto out; 268 } 269 lock_buffer(bh); 270 if (new) 271 memset(bh->b_data, 0, sb->s_blocksize); 272 memcpy(bh->b_data + offset, data, len); 273 flush_dcache_page(bh->b_page); 274 set_buffer_uptodate(bh); 275 unlock_buffer(bh); 276 ocfs2_set_buffer_uptodate(INODE_CACHE(gqinode), bh); 277 err = ocfs2_journal_access_dq(handle, INODE_CACHE(gqinode), bh, 278 ja_type); 279 if (err < 0) { 280 brelse(bh); 281 goto out; 282 } 283 ocfs2_journal_dirty(handle, bh); 284 brelse(bh); 285out: 286 if (err) { 287 mlog_errno(err); 288 return err; 289 } 290 gqinode->i_version++; 291 ocfs2_mark_inode_dirty(handle, gqinode, oinfo->dqi_gqi_bh); 292 return len; 293} 294 295int ocfs2_lock_global_qf(struct ocfs2_mem_dqinfo *oinfo, int ex) 296{ 297 int status; 298 struct buffer_head *bh = NULL; 299 300 status = ocfs2_inode_lock(oinfo->dqi_gqinode, &bh, ex); 301 if (status < 0) 302 return status; 303 spin_lock(&dq_data_lock); 304 if (!oinfo->dqi_gqi_count++) 305 oinfo->dqi_gqi_bh = bh; 306 else 307 WARN_ON(bh != oinfo->dqi_gqi_bh); 308 spin_unlock(&dq_data_lock); 309 if (ex) { 310 mutex_lock(&oinfo->dqi_gqinode->i_mutex); 311 down_write(&OCFS2_I(oinfo->dqi_gqinode)->ip_alloc_sem); 312 } else { 313 down_read(&OCFS2_I(oinfo->dqi_gqinode)->ip_alloc_sem); 314 } 315 return 0; 316} 317 318void ocfs2_unlock_global_qf(struct ocfs2_mem_dqinfo *oinfo, int ex) 319{ 320 if (ex) { 321 up_write(&OCFS2_I(oinfo->dqi_gqinode)->ip_alloc_sem); 322 mutex_unlock(&oinfo->dqi_gqinode->i_mutex); 323 } else { 324 up_read(&OCFS2_I(oinfo->dqi_gqinode)->ip_alloc_sem); 325 } 326 ocfs2_inode_unlock(oinfo->dqi_gqinode, ex); 327 brelse(oinfo->dqi_gqi_bh); 328 spin_lock(&dq_data_lock); 329 if (!--oinfo->dqi_gqi_count) 330 oinfo->dqi_gqi_bh = NULL; 331 spin_unlock(&dq_data_lock); 332} 333 334/* Read information header from global quota file */ 335int ocfs2_global_read_info(struct super_block *sb, int type) 336{ 337 struct inode *gqinode = NULL; 338 unsigned int ino[MAXQUOTAS] = { USER_QUOTA_SYSTEM_INODE, 339 GROUP_QUOTA_SYSTEM_INODE }; 340 struct ocfs2_global_disk_dqinfo dinfo; 341 struct mem_dqinfo *info = sb_dqinfo(sb, type); 342 struct ocfs2_mem_dqinfo *oinfo = info->dqi_priv; 343 u64 pcount; 344 int status; 345 346 mlog_entry_void(); 347 348 /* Read global header */ 349 gqinode = ocfs2_get_system_file_inode(OCFS2_SB(sb), ino[type], 350 OCFS2_INVALID_SLOT); 351 if (!gqinode) { 352 mlog(ML_ERROR, "failed to get global quota inode (type=%d)\n", 353 type); 354 status = -EINVAL; 355 goto out_err; 356 } 357 oinfo->dqi_gi.dqi_sb = sb; 358 oinfo->dqi_gi.dqi_type = type; 359 ocfs2_qinfo_lock_res_init(&oinfo->dqi_gqlock, oinfo); 360 oinfo->dqi_gi.dqi_entry_size = sizeof(struct ocfs2_global_disk_dqblk); 361 oinfo->dqi_gi.dqi_ops = &ocfs2_global_ops; 362 oinfo->dqi_gqi_bh = NULL; 363 oinfo->dqi_gqi_count = 0; 364 oinfo->dqi_gqinode = gqinode; 365 status = ocfs2_lock_global_qf(oinfo, 0); 366 if (status < 0) { 367 mlog_errno(status); 368 goto out_err; 369 } 370 371 status = ocfs2_extent_map_get_blocks(gqinode, 0, &oinfo->dqi_giblk, 372 &pcount, NULL); 373 if (status < 0) 374 goto out_unlock; 375 376 status = ocfs2_qinfo_lock(oinfo, 0); 377 if (status < 0) 378 goto out_unlock; 379 status = sb->s_op->quota_read(sb, type, (char *)&dinfo, 380 sizeof(struct ocfs2_global_disk_dqinfo), 381 OCFS2_GLOBAL_INFO_OFF); 382 ocfs2_qinfo_unlock(oinfo, 0); 383 ocfs2_unlock_global_qf(oinfo, 0); 384 if (status != sizeof(struct ocfs2_global_disk_dqinfo)) { 385 mlog(ML_ERROR, "Cannot read global quota info (%d).\n", 386 status); 387 if (status >= 0) 388 status = -EIO; 389 mlog_errno(status); 390 goto out_err; 391 } 392 info->dqi_bgrace = le32_to_cpu(dinfo.dqi_bgrace); 393 info->dqi_igrace = le32_to_cpu(dinfo.dqi_igrace); 394 oinfo->dqi_syncms = le32_to_cpu(dinfo.dqi_syncms); 395 oinfo->dqi_gi.dqi_blocks = le32_to_cpu(dinfo.dqi_blocks); 396 oinfo->dqi_gi.dqi_free_blk = le32_to_cpu(dinfo.dqi_free_blk); 397 oinfo->dqi_gi.dqi_free_entry = le32_to_cpu(dinfo.dqi_free_entry); 398 oinfo->dqi_gi.dqi_blocksize_bits = sb->s_blocksize_bits; 399 oinfo->dqi_gi.dqi_usable_bs = sb->s_blocksize - 400 OCFS2_QBLK_RESERVED_SPACE; 401 oinfo->dqi_gi.dqi_qtree_depth = qtree_depth(&oinfo->dqi_gi); 402 INIT_DELAYED_WORK(&oinfo->dqi_sync_work, qsync_work_fn); 403 queue_delayed_work(ocfs2_quota_wq, &oinfo->dqi_sync_work, 404 msecs_to_jiffies(oinfo->dqi_syncms)); 405 406out_err: 407 mlog_exit(status); 408 return status; 409out_unlock: 410 ocfs2_unlock_global_qf(oinfo, 0); 411 mlog_errno(status); 412 goto out_err; 413} 414 415/* Write information to global quota file. Expects exlusive lock on quota 416 * file inode and quota info */ 417static int __ocfs2_global_write_info(struct super_block *sb, int type) 418{ 419 struct mem_dqinfo *info = sb_dqinfo(sb, type); 420 struct ocfs2_mem_dqinfo *oinfo = info->dqi_priv; 421 struct ocfs2_global_disk_dqinfo dinfo; 422 ssize_t size; 423 424 spin_lock(&dq_data_lock); 425 info->dqi_flags &= ~DQF_INFO_DIRTY; 426 dinfo.dqi_bgrace = cpu_to_le32(info->dqi_bgrace); 427 dinfo.dqi_igrace = cpu_to_le32(info->dqi_igrace); 428 spin_unlock(&dq_data_lock); 429 dinfo.dqi_syncms = cpu_to_le32(oinfo->dqi_syncms); 430 dinfo.dqi_blocks = cpu_to_le32(oinfo->dqi_gi.dqi_blocks); 431 dinfo.dqi_free_blk = cpu_to_le32(oinfo->dqi_gi.dqi_free_blk); 432 dinfo.dqi_free_entry = cpu_to_le32(oinfo->dqi_gi.dqi_free_entry); 433 size = sb->s_op->quota_write(sb, type, (char *)&dinfo, 434 sizeof(struct ocfs2_global_disk_dqinfo), 435 OCFS2_GLOBAL_INFO_OFF); 436 if (size != sizeof(struct ocfs2_global_disk_dqinfo)) { 437 mlog(ML_ERROR, "Cannot write global quota info structure\n"); 438 if (size >= 0) 439 size = -EIO; 440 return size; 441 } 442 return 0; 443} 444 445int ocfs2_global_write_info(struct super_block *sb, int type) 446{ 447 int err; 448 struct ocfs2_mem_dqinfo *info = sb_dqinfo(sb, type)->dqi_priv; 449 450 err = ocfs2_qinfo_lock(info, 1); 451 if (err < 0) 452 return err; 453 err = __ocfs2_global_write_info(sb, type); 454 ocfs2_qinfo_unlock(info, 1); 455 return err; 456} 457 458static int ocfs2_global_qinit_alloc(struct super_block *sb, int type) 459{ 460 struct ocfs2_mem_dqinfo *oinfo = sb_dqinfo(sb, type)->dqi_priv; 461 462 /* 463 * We may need to allocate tree blocks and a leaf block but not the 464 * root block 465 */ 466 return oinfo->dqi_gi.dqi_qtree_depth; 467} 468 469static int ocfs2_calc_global_qinit_credits(struct super_block *sb, int type) 470{ 471 /* We modify all the allocated blocks, tree root, info block and 472 * the inode */ 473 return (ocfs2_global_qinit_alloc(sb, type) + 2) * 474 OCFS2_QUOTA_BLOCK_UPDATE_CREDITS + 1; 475} 476 477/* Sync local information about quota modifications with global quota file. 478 * Caller must have started the transaction and obtained exclusive lock for 479 * global quota file inode */ 480int __ocfs2_sync_dquot(struct dquot *dquot, int freeing) 481{ 482 int err, err2; 483 struct super_block *sb = dquot->dq_sb; 484 int type = dquot->dq_type; 485 struct ocfs2_mem_dqinfo *info = sb_dqinfo(sb, type)->dqi_priv; 486 struct ocfs2_global_disk_dqblk dqblk; 487 s64 spacechange, inodechange; 488 time_t olditime, oldbtime; 489 490 err = sb->s_op->quota_read(sb, type, (char *)&dqblk, 491 sizeof(struct ocfs2_global_disk_dqblk), 492 dquot->dq_off); 493 if (err != sizeof(struct ocfs2_global_disk_dqblk)) { 494 if (err >= 0) { 495 mlog(ML_ERROR, "Short read from global quota file " 496 "(%u read)\n", err); 497 err = -EIO; 498 } 499 goto out; 500 } 501 502 /* Update space and inode usage. Get also other information from 503 * global quota file so that we don't overwrite any changes there. 504 * We are */ 505 spin_lock(&dq_data_lock); 506 spacechange = dquot->dq_dqb.dqb_curspace - 507 OCFS2_DQUOT(dquot)->dq_origspace; 508 inodechange = dquot->dq_dqb.dqb_curinodes - 509 OCFS2_DQUOT(dquot)->dq_originodes; 510 olditime = dquot->dq_dqb.dqb_itime; 511 oldbtime = dquot->dq_dqb.dqb_btime; 512 ocfs2_global_disk2memdqb(dquot, &dqblk); 513 mlog(0, "Syncing global dquot %u space %lld+%lld, inodes %lld+%lld\n", 514 dquot->dq_id, dquot->dq_dqb.dqb_curspace, (long long)spacechange, 515 dquot->dq_dqb.dqb_curinodes, (long long)inodechange); 516 if (!test_bit(DQ_LASTSET_B + QIF_SPACE_B, &dquot->dq_flags)) 517 dquot->dq_dqb.dqb_curspace += spacechange; 518 if (!test_bit(DQ_LASTSET_B + QIF_INODES_B, &dquot->dq_flags)) 519 dquot->dq_dqb.dqb_curinodes += inodechange; 520 /* Set properly space grace time... */ 521 if (dquot->dq_dqb.dqb_bsoftlimit && 522 dquot->dq_dqb.dqb_curspace > dquot->dq_dqb.dqb_bsoftlimit) { 523 if (!test_bit(DQ_LASTSET_B + QIF_BTIME_B, &dquot->dq_flags) && 524 oldbtime > 0) { 525 if (dquot->dq_dqb.dqb_btime > 0) 526 dquot->dq_dqb.dqb_btime = 527 min(dquot->dq_dqb.dqb_btime, oldbtime); 528 else 529 dquot->dq_dqb.dqb_btime = oldbtime; 530 } 531 } else { 532 dquot->dq_dqb.dqb_btime = 0; 533 clear_bit(DQ_BLKS_B, &dquot->dq_flags); 534 } 535 /* Set properly inode grace time... */ 536 if (dquot->dq_dqb.dqb_isoftlimit && 537 dquot->dq_dqb.dqb_curinodes > dquot->dq_dqb.dqb_isoftlimit) { 538 if (!test_bit(DQ_LASTSET_B + QIF_ITIME_B, &dquot->dq_flags) && 539 olditime > 0) { 540 if (dquot->dq_dqb.dqb_itime > 0) 541 dquot->dq_dqb.dqb_itime = 542 min(dquot->dq_dqb.dqb_itime, olditime); 543 else 544 dquot->dq_dqb.dqb_itime = olditime; 545 } 546 } else { 547 dquot->dq_dqb.dqb_itime = 0; 548 clear_bit(DQ_INODES_B, &dquot->dq_flags); 549 } 550 /* All information is properly updated, clear the flags */ 551 __clear_bit(DQ_LASTSET_B + QIF_SPACE_B, &dquot->dq_flags); 552 __clear_bit(DQ_LASTSET_B + QIF_INODES_B, &dquot->dq_flags); 553 __clear_bit(DQ_LASTSET_B + QIF_BLIMITS_B, &dquot->dq_flags); 554 __clear_bit(DQ_LASTSET_B + QIF_ILIMITS_B, &dquot->dq_flags); 555 __clear_bit(DQ_LASTSET_B + QIF_BTIME_B, &dquot->dq_flags); 556 __clear_bit(DQ_LASTSET_B + QIF_ITIME_B, &dquot->dq_flags); 557 OCFS2_DQUOT(dquot)->dq_origspace = dquot->dq_dqb.dqb_curspace; 558 OCFS2_DQUOT(dquot)->dq_originodes = dquot->dq_dqb.dqb_curinodes; 559 spin_unlock(&dq_data_lock); 560 err = ocfs2_qinfo_lock(info, freeing); 561 if (err < 0) { 562 mlog(ML_ERROR, "Failed to lock quota info, loosing quota write" 563 " (type=%d, id=%u)\n", dquot->dq_type, 564 (unsigned)dquot->dq_id); 565 goto out; 566 } 567 if (freeing) 568 OCFS2_DQUOT(dquot)->dq_use_count--; 569 err = qtree_write_dquot(&info->dqi_gi, dquot); 570 if (err < 0) 571 goto out_qlock; 572 if (freeing && !OCFS2_DQUOT(dquot)->dq_use_count) { 573 err = qtree_release_dquot(&info->dqi_gi, dquot); 574 if (info_dirty(sb_dqinfo(sb, type))) { 575 err2 = __ocfs2_global_write_info(sb, type); 576 if (!err) 577 err = err2; 578 } 579 } 580out_qlock: 581 ocfs2_qinfo_unlock(info, freeing); 582out: 583 if (err < 0) 584 mlog_errno(err); 585 return err; 586} 587 588/* 589 * Functions for periodic syncing of dquots with global file 590 */ 591static int ocfs2_sync_dquot_helper(struct dquot *dquot, unsigned long type) 592{ 593 handle_t *handle; 594 struct super_block *sb = dquot->dq_sb; 595 struct ocfs2_mem_dqinfo *oinfo = sb_dqinfo(sb, type)->dqi_priv; 596 struct ocfs2_super *osb = OCFS2_SB(sb); 597 int status = 0; 598 599 mlog_entry("id=%u qtype=%u type=%lu device=%s\n", dquot->dq_id, 600 dquot->dq_type, type, sb->s_id); 601 if (type != dquot->dq_type) 602 goto out; 603 status = ocfs2_lock_global_qf(oinfo, 1); 604 if (status < 0) 605 goto out; 606 607 handle = ocfs2_start_trans(osb, OCFS2_QSYNC_CREDITS); 608 if (IS_ERR(handle)) { 609 status = PTR_ERR(handle); 610 mlog_errno(status); 611 goto out_ilock; 612 } 613 mutex_lock(&sb_dqopt(sb)->dqio_mutex); 614 status = ocfs2_sync_dquot(dquot); 615 if (status < 0) 616 mlog_errno(status); 617 /* We have to write local structure as well... */ 618 status = ocfs2_local_write_dquot(dquot); 619 if (status < 0) 620 mlog_errno(status); 621 mutex_unlock(&sb_dqopt(sb)->dqio_mutex); 622 ocfs2_commit_trans(osb, handle); 623out_ilock: 624 ocfs2_unlock_global_qf(oinfo, 1); 625out: 626 mlog_exit(status); 627 return status; 628} 629 630static void qsync_work_fn(struct work_struct *work) 631{ 632 struct ocfs2_mem_dqinfo *oinfo = container_of(work, 633 struct ocfs2_mem_dqinfo, 634 dqi_sync_work.work); 635 struct super_block *sb = oinfo->dqi_gqinode->i_sb; 636 637 dquot_scan_active(sb, ocfs2_sync_dquot_helper, oinfo->dqi_type); 638 queue_delayed_work(ocfs2_quota_wq, &oinfo->dqi_sync_work, 639 msecs_to_jiffies(oinfo->dqi_syncms)); 640} 641 642/* 643 * Wrappers for generic quota functions 644 */ 645 646static int ocfs2_write_dquot(struct dquot *dquot) 647{ 648 handle_t *handle; 649 struct ocfs2_super *osb = OCFS2_SB(dquot->dq_sb); 650 int status = 0; 651 652 mlog_entry("id=%u, type=%d", dquot->dq_id, dquot->dq_type); 653 654 handle = ocfs2_start_trans(osb, OCFS2_QWRITE_CREDITS); 655 if (IS_ERR(handle)) { 656 status = PTR_ERR(handle); 657 mlog_errno(status); 658 goto out; 659 } 660 mutex_lock(&sb_dqopt(dquot->dq_sb)->dqio_mutex); 661 status = ocfs2_local_write_dquot(dquot); 662 mutex_unlock(&sb_dqopt(dquot->dq_sb)->dqio_mutex); 663 ocfs2_commit_trans(osb, handle); 664out: 665 mlog_exit(status); 666 return status; 667} 668 669static int ocfs2_calc_qdel_credits(struct super_block *sb, int type) 670{ 671 struct ocfs2_mem_dqinfo *oinfo = sb_dqinfo(sb, type)->dqi_priv; 672 /* 673 * We modify tree, leaf block, global info, local chunk header, 674 * global and local inode; OCFS2_QINFO_WRITE_CREDITS already 675 * accounts for inode update 676 */ 677 return (oinfo->dqi_gi.dqi_qtree_depth + 2) * 678 OCFS2_QUOTA_BLOCK_UPDATE_CREDITS + 679 OCFS2_QINFO_WRITE_CREDITS + 680 OCFS2_INODE_UPDATE_CREDITS; 681} 682 683static int ocfs2_release_dquot(struct dquot *dquot) 684{ 685 handle_t *handle; 686 struct ocfs2_mem_dqinfo *oinfo = 687 sb_dqinfo(dquot->dq_sb, dquot->dq_type)->dqi_priv; 688 struct ocfs2_super *osb = OCFS2_SB(dquot->dq_sb); 689 int status = 0; 690 691 mlog_entry("id=%u, type=%d", dquot->dq_id, dquot->dq_type); 692 693 mutex_lock(&dquot->dq_lock); 694 /* Check whether we are not racing with some other dqget() */ 695 if (atomic_read(&dquot->dq_count) > 1) 696 goto out; 697 status = ocfs2_lock_global_qf(oinfo, 1); 698 if (status < 0) 699 goto out; 700 handle = ocfs2_start_trans(osb, 701 ocfs2_calc_qdel_credits(dquot->dq_sb, dquot->dq_type)); 702 if (IS_ERR(handle)) { 703 status = PTR_ERR(handle); 704 mlog_errno(status); 705 goto out_ilock; 706 } 707 708 status = ocfs2_global_release_dquot(dquot); 709 if (status < 0) { 710 mlog_errno(status); 711 goto out_trans; 712 } 713 status = ocfs2_local_release_dquot(handle, dquot); 714 /* 715 * If we fail here, we cannot do much as global structure is 716 * already released. So just complain... 717 */ 718 if (status < 0) 719 mlog_errno(status); 720 clear_bit(DQ_ACTIVE_B, &dquot->dq_flags); 721out_trans: 722 ocfs2_commit_trans(osb, handle); 723out_ilock: 724 ocfs2_unlock_global_qf(oinfo, 1); 725out: 726 mutex_unlock(&dquot->dq_lock); 727 mlog_exit(status); 728 return status; 729} 730 731/* 732 * Read global dquot structure from disk or create it if it does 733 * not exist. Also update use count of the global structure and 734 * create structure in node-local quota file. 735 */ 736static int ocfs2_acquire_dquot(struct dquot *dquot) 737{ 738 int status = 0, err; 739 int ex = 0; 740 struct super_block *sb = dquot->dq_sb; 741 struct ocfs2_super *osb = OCFS2_SB(sb); 742 int type = dquot->dq_type; 743 struct ocfs2_mem_dqinfo *info = sb_dqinfo(sb, type)->dqi_priv; 744 struct inode *gqinode = info->dqi_gqinode; 745 int need_alloc = ocfs2_global_qinit_alloc(sb, type); 746 handle_t *handle; 747 748 mlog_entry("id=%u, type=%d", dquot->dq_id, type); 749 mutex_lock(&dquot->dq_lock); 750 /* 751 * We need an exclusive lock, because we're going to update use count 752 * and instantiate possibly new dquot structure 753 */ 754 status = ocfs2_lock_global_qf(info, 1); 755 if (status < 0) 756 goto out; 757 if (!test_bit(DQ_READ_B, &dquot->dq_flags)) { 758 status = ocfs2_qinfo_lock(info, 0); 759 if (status < 0) 760 goto out_dq; 761 status = qtree_read_dquot(&info->dqi_gi, dquot); 762 ocfs2_qinfo_unlock(info, 0); 763 if (status < 0) 764 goto out_dq; 765 } 766 set_bit(DQ_READ_B, &dquot->dq_flags); 767 768 OCFS2_DQUOT(dquot)->dq_use_count++; 769 OCFS2_DQUOT(dquot)->dq_origspace = dquot->dq_dqb.dqb_curspace; 770 OCFS2_DQUOT(dquot)->dq_originodes = dquot->dq_dqb.dqb_curinodes; 771 if (!dquot->dq_off) { /* No real quota entry? */ 772 ex = 1; 773 /* 774 * Add blocks to quota file before we start a transaction since 775 * locking allocators ranks above a transaction start 776 */ 777 WARN_ON(journal_current_handle()); 778 status = ocfs2_extend_no_holes(gqinode, NULL, 779 gqinode->i_size + (need_alloc << sb->s_blocksize_bits), 780 gqinode->i_size); 781 if (status < 0) 782 goto out_dq; 783 } 784 785 handle = ocfs2_start_trans(osb, 786 ocfs2_calc_global_qinit_credits(sb, type)); 787 if (IS_ERR(handle)) { 788 status = PTR_ERR(handle); 789 goto out_dq; 790 } 791 status = ocfs2_qinfo_lock(info, ex); 792 if (status < 0) 793 goto out_trans; 794 status = qtree_write_dquot(&info->dqi_gi, dquot); 795 if (ex && info_dirty(sb_dqinfo(sb, type))) { 796 err = __ocfs2_global_write_info(sb, type); 797 if (!status) 798 status = err; 799 } 800 ocfs2_qinfo_unlock(info, ex); 801out_trans: 802 ocfs2_commit_trans(osb, handle); 803out_dq: 804 ocfs2_unlock_global_qf(info, 1); 805 if (status < 0) 806 goto out; 807 808 status = ocfs2_create_local_dquot(dquot); 809 if (status < 0) 810 goto out; 811 set_bit(DQ_ACTIVE_B, &dquot->dq_flags); 812out: 813 mutex_unlock(&dquot->dq_lock); 814 mlog_exit(status); 815 return status; 816} 817 818static int ocfs2_mark_dquot_dirty(struct dquot *dquot) 819{ 820 unsigned long mask = (1 << (DQ_LASTSET_B + QIF_ILIMITS_B)) | 821 (1 << (DQ_LASTSET_B + QIF_BLIMITS_B)) | 822 (1 << (DQ_LASTSET_B + QIF_INODES_B)) | 823 (1 << (DQ_LASTSET_B + QIF_SPACE_B)) | 824 (1 << (DQ_LASTSET_B + QIF_BTIME_B)) | 825 (1 << (DQ_LASTSET_B + QIF_ITIME_B)); 826 int sync = 0; 827 int status; 828 struct super_block *sb = dquot->dq_sb; 829 int type = dquot->dq_type; 830 struct ocfs2_mem_dqinfo *oinfo = sb_dqinfo(sb, type)->dqi_priv; 831 handle_t *handle; 832 struct ocfs2_super *osb = OCFS2_SB(sb); 833 834 mlog_entry("id=%u, type=%d", dquot->dq_id, type); 835 836 /* In case user set some limits, sync dquot immediately to global 837 * quota file so that information propagates quicker */ 838 spin_lock(&dq_data_lock); 839 if (dquot->dq_flags & mask) 840 sync = 1; 841 spin_unlock(&dq_data_lock); 842 /* This is a slight hack but we can't afford getting global quota 843 * lock if we already have a transaction started. */ 844 if (!sync || journal_current_handle()) { 845 status = ocfs2_write_dquot(dquot); 846 goto out; 847 } 848 status = ocfs2_lock_global_qf(oinfo, 1); 849 if (status < 0) 850 goto out; 851 handle = ocfs2_start_trans(osb, OCFS2_QSYNC_CREDITS); 852 if (IS_ERR(handle)) { 853 status = PTR_ERR(handle); 854 mlog_errno(status); 855 goto out_ilock; 856 } 857 mutex_lock(&sb_dqopt(sb)->dqio_mutex); 858 status = ocfs2_sync_dquot(dquot); 859 if (status < 0) { 860 mlog_errno(status); 861 goto out_dlock; 862 } 863 /* Now write updated local dquot structure */ 864 status = ocfs2_local_write_dquot(dquot); 865out_dlock: 866 mutex_unlock(&sb_dqopt(sb)->dqio_mutex); 867 ocfs2_commit_trans(osb, handle); 868out_ilock: 869 ocfs2_unlock_global_qf(oinfo, 1); 870out: 871 mlog_exit(status); 872 return status; 873} 874 875/* This should happen only after set_dqinfo(). */ 876static int ocfs2_write_info(struct super_block *sb, int type) 877{ 878 handle_t *handle; 879 int status = 0; 880 struct ocfs2_mem_dqinfo *oinfo = sb_dqinfo(sb, type)->dqi_priv; 881 882 mlog_entry_void(); 883 884 status = ocfs2_lock_global_qf(oinfo, 1); 885 if (status < 0) 886 goto out; 887 handle = ocfs2_start_trans(OCFS2_SB(sb), OCFS2_QINFO_WRITE_CREDITS); 888 if (IS_ERR(handle)) { 889 status = PTR_ERR(handle); 890 mlog_errno(status); 891 goto out_ilock; 892 } 893 status = dquot_commit_info(sb, type); 894 ocfs2_commit_trans(OCFS2_SB(sb), handle); 895out_ilock: 896 ocfs2_unlock_global_qf(oinfo, 1); 897out: 898 mlog_exit(status); 899 return status; 900} 901 902static struct dquot *ocfs2_alloc_dquot(struct super_block *sb, int type) 903{ 904 struct ocfs2_dquot *dquot = 905 kmem_cache_zalloc(ocfs2_dquot_cachep, GFP_NOFS); 906 907 if (!dquot) 908 return NULL; 909 return &dquot->dq_dquot; 910} 911 912static void ocfs2_destroy_dquot(struct dquot *dquot) 913{ 914 kmem_cache_free(ocfs2_dquot_cachep, dquot); 915} 916 917const struct dquot_operations ocfs2_quota_operations = { 918 /* We never make dquot dirty so .write_dquot is never called */ 919 .acquire_dquot = ocfs2_acquire_dquot, 920 .release_dquot = ocfs2_release_dquot, 921 .mark_dirty = ocfs2_mark_dquot_dirty, 922 .write_info = ocfs2_write_info, 923 .alloc_dquot = ocfs2_alloc_dquot, 924 .destroy_dquot = ocfs2_destroy_dquot, 925}; 926 927int ocfs2_quota_setup(void) 928{ 929 ocfs2_quota_wq = create_workqueue("o2quot"); 930 if (!ocfs2_quota_wq) 931 return -ENOMEM; 932 return 0; 933} 934 935void ocfs2_quota_shutdown(void) 936{ 937 if (ocfs2_quota_wq) { 938 flush_workqueue(ocfs2_quota_wq); 939 destroy_workqueue(ocfs2_quota_wq); 940 ocfs2_quota_wq = NULL; 941 } 942} 943