1 /* 2 * vfsv0 quota IO operations on file 3 */ 4 5 #include <linux/errno.h> 6 #include <linux/fs.h> 7 #include <linux/mount.h> 8 #include <linux/dqblk_v2.h> 9 #include <linux/kernel.h> 10 #include <linux/init.h> 11 #include <linux/module.h> 12 #include <linux/slab.h> 13 #include <linux/quotaops.h> 14 15 #include <asm/byteorder.h> 16 17 #include "quota_tree.h" 18 19 MODULE_AUTHOR("Jan Kara"); 20 MODULE_DESCRIPTION("Quota trie support"); 21 MODULE_LICENSE("GPL"); 22 23 #define __QUOTA_QT_PARANOIA 24 25 static int get_index(struct qtree_mem_dqinfo *info, qid_t id, int depth) 26 { 27 unsigned int epb = info->dqi_usable_bs >> 2; 28 29 depth = info->dqi_qtree_depth - depth - 1; 30 while (depth--) 31 id /= epb; 32 return id % epb; 33 } 34 35 /* Number of entries in one blocks */ 36 static int qtree_dqstr_in_blk(struct qtree_mem_dqinfo *info) 37 { 38 return (info->dqi_usable_bs - sizeof(struct qt_disk_dqdbheader)) 39 / info->dqi_entry_size; 40 } 41 42 static char *getdqbuf(size_t size) 43 { 44 char *buf = kmalloc(size, GFP_NOFS); 45 if (!buf) 46 printk(KERN_WARNING 47 "VFS: Not enough memory for quota buffers.\n"); 48 return buf; 49 } 50 51 static ssize_t read_blk(struct qtree_mem_dqinfo *info, uint blk, char *buf) 52 { 53 struct super_block *sb = info->dqi_sb; 54 55 memset(buf, 0, info->dqi_usable_bs); 56 return sb->s_op->quota_read(sb, info->dqi_type, buf, 57 info->dqi_usable_bs, blk << info->dqi_blocksize_bits); 58 } 59 60 static ssize_t write_blk(struct qtree_mem_dqinfo *info, uint blk, char *buf) 61 { 62 struct super_block *sb = info->dqi_sb; 63 ssize_t ret; 64 65 ret = sb->s_op->quota_write(sb, info->dqi_type, buf, 66 info->dqi_usable_bs, blk << info->dqi_blocksize_bits); 67 if (ret != info->dqi_usable_bs) { 68 quota_error(sb, "dquota write failed"); 69 if (ret >= 0) 70 ret = -EIO; 71 } 72 return ret; 73 } 74 75 /* Remove empty block from list and return it */ 76 static int get_free_dqblk(struct qtree_mem_dqinfo *info) 77 { 78 char *buf = getdqbuf(info->dqi_usable_bs); 79 struct qt_disk_dqdbheader *dh = (struct qt_disk_dqdbheader *)buf; 80 int ret, blk; 81 82 if (!buf) 83 return -ENOMEM; 84 if (info->dqi_free_blk) { 85 blk = info->dqi_free_blk; 86 ret = read_blk(info, blk, buf); 87 if (ret < 0) 88 goto out_buf; 89 info->dqi_free_blk = le32_to_cpu(dh->dqdh_next_free); 90 } 91 else { 92 memset(buf, 0, info->dqi_usable_bs); 93 /* Assure block allocation... */ 94 ret = write_blk(info, info->dqi_blocks, buf); 95 if (ret < 0) 96 goto out_buf; 97 blk = info->dqi_blocks++; 98 } 99 mark_info_dirty(info->dqi_sb, info->dqi_type); 100 ret = blk; 101 out_buf: 102 kfree(buf); 103 return ret; 104 } 105 106 /* Insert empty block to the list */ 107 static int put_free_dqblk(struct qtree_mem_dqinfo *info, char *buf, uint blk) 108 { 109 struct qt_disk_dqdbheader *dh = (struct qt_disk_dqdbheader *)buf; 110 int err; 111 112 dh->dqdh_next_free = cpu_to_le32(info->dqi_free_blk); 113 dh->dqdh_prev_free = cpu_to_le32(0); 114 dh->dqdh_entries = cpu_to_le16(0); 115 err = write_blk(info, blk, buf); 116 if (err < 0) 117 return err; 118 info->dqi_free_blk = blk; 119 mark_info_dirty(info->dqi_sb, info->dqi_type); 120 return 0; 121 } 122 123 /* Remove given block from the list of blocks with free entries */ 124 static int remove_free_dqentry(struct qtree_mem_dqinfo *info, char *buf, 125 uint blk) 126 { 127 char *tmpbuf = getdqbuf(info->dqi_usable_bs); 128 struct qt_disk_dqdbheader *dh = (struct qt_disk_dqdbheader *)buf; 129 uint nextblk = le32_to_cpu(dh->dqdh_next_free); 130 uint prevblk = le32_to_cpu(dh->dqdh_prev_free); 131 int err; 132 133 if (!tmpbuf) 134 return -ENOMEM; 135 if (nextblk) { 136 err = read_blk(info, nextblk, tmpbuf); 137 if (err < 0) 138 goto out_buf; 139 ((struct qt_disk_dqdbheader *)tmpbuf)->dqdh_prev_free = 140 dh->dqdh_prev_free; 141 err = write_blk(info, nextblk, tmpbuf); 142 if (err < 0) 143 goto out_buf; 144 } 145 if (prevblk) { 146 err = read_blk(info, prevblk, tmpbuf); 147 if (err < 0) 148 goto out_buf; 149 ((struct qt_disk_dqdbheader *)tmpbuf)->dqdh_next_free = 150 dh->dqdh_next_free; 151 err = write_blk(info, prevblk, tmpbuf); 152 if (err < 0) 153 goto out_buf; 154 } else { 155 info->dqi_free_entry = nextblk; 156 mark_info_dirty(info->dqi_sb, info->dqi_type); 157 } 158 kfree(tmpbuf); 159 dh->dqdh_next_free = dh->dqdh_prev_free = cpu_to_le32(0); 160 /* No matter whether write succeeds block is out of list */ 161 if (write_blk(info, blk, buf) < 0) 162 quota_error(info->dqi_sb, "Can't write block (%u) " 163 "with free entries", blk); 164 return 0; 165 out_buf: 166 kfree(tmpbuf); 167 return err; 168 } 169 170 /* Insert given block to the beginning of list with free entries */ 171 static int insert_free_dqentry(struct qtree_mem_dqinfo *info, char *buf, 172 uint blk) 173 { 174 char *tmpbuf = getdqbuf(info->dqi_usable_bs); 175 struct qt_disk_dqdbheader *dh = (struct qt_disk_dqdbheader *)buf; 176 int err; 177 178 if (!tmpbuf) 179 return -ENOMEM; 180 dh->dqdh_next_free = cpu_to_le32(info->dqi_free_entry); 181 dh->dqdh_prev_free = cpu_to_le32(0); 182 err = write_blk(info, blk, buf); 183 if (err < 0) 184 goto out_buf; 185 if (info->dqi_free_entry) { 186 err = read_blk(info, info->dqi_free_entry, tmpbuf); 187 if (err < 0) 188 goto out_buf; 189 ((struct qt_disk_dqdbheader *)tmpbuf)->dqdh_prev_free = 190 cpu_to_le32(blk); 191 err = write_blk(info, info->dqi_free_entry, tmpbuf); 192 if (err < 0) 193 goto out_buf; 194 } 195 kfree(tmpbuf); 196 info->dqi_free_entry = blk; 197 mark_info_dirty(info->dqi_sb, info->dqi_type); 198 return 0; 199 out_buf: 200 kfree(tmpbuf); 201 return err; 202 } 203 204 /* Is the entry in the block free? */ 205 int qtree_entry_unused(struct qtree_mem_dqinfo *info, char *disk) 206 { 207 int i; 208 209 for (i = 0; i < info->dqi_entry_size; i++) 210 if (disk[i]) 211 return 0; 212 return 1; 213 } 214 EXPORT_SYMBOL(qtree_entry_unused); 215 216 /* Find space for dquot */ 217 static uint find_free_dqentry(struct qtree_mem_dqinfo *info, 218 struct dquot *dquot, int *err) 219 { 220 uint blk, i; 221 struct qt_disk_dqdbheader *dh; 222 char *buf = getdqbuf(info->dqi_usable_bs); 223 char *ddquot; 224 225 *err = 0; 226 if (!buf) { 227 *err = -ENOMEM; 228 return 0; 229 } 230 dh = (struct qt_disk_dqdbheader *)buf; 231 if (info->dqi_free_entry) { 232 blk = info->dqi_free_entry; 233 *err = read_blk(info, blk, buf); 234 if (*err < 0) 235 goto out_buf; 236 } else { 237 blk = get_free_dqblk(info); 238 if ((int)blk < 0) { 239 *err = blk; 240 kfree(buf); 241 return 0; 242 } 243 memset(buf, 0, info->dqi_usable_bs); 244 /* This is enough as the block is already zeroed and the entry 245 * list is empty... */ 246 info->dqi_free_entry = blk; 247 mark_info_dirty(dquot->dq_sb, dquot->dq_type); 248 } 249 /* Block will be full? */ 250 if (le16_to_cpu(dh->dqdh_entries) + 1 >= qtree_dqstr_in_blk(info)) { 251 *err = remove_free_dqentry(info, buf, blk); 252 if (*err < 0) { 253 quota_error(dquot->dq_sb, "Can't remove block (%u) " 254 "from entry free list", blk); 255 goto out_buf; 256 } 257 } 258 le16_add_cpu(&dh->dqdh_entries, 1); 259 /* Find free structure in block */ 260 ddquot = buf + sizeof(struct qt_disk_dqdbheader); 261 for (i = 0; i < qtree_dqstr_in_blk(info); i++) { 262 if (qtree_entry_unused(info, ddquot)) 263 break; 264 ddquot += info->dqi_entry_size; 265 } 266 #ifdef __QUOTA_QT_PARANOIA 267 if (i == qtree_dqstr_in_blk(info)) { 268 quota_error(dquot->dq_sb, "Data block full but it shouldn't"); 269 *err = -EIO; 270 goto out_buf; 271 } 272 #endif 273 *err = write_blk(info, blk, buf); 274 if (*err < 0) { 275 quota_error(dquot->dq_sb, "Can't write quota data block %u", 276 blk); 277 goto out_buf; 278 } 279 dquot->dq_off = (blk << info->dqi_blocksize_bits) + 280 sizeof(struct qt_disk_dqdbheader) + 281 i * info->dqi_entry_size; 282 kfree(buf); 283 return blk; 284 out_buf: 285 kfree(buf); 286 return 0; 287 } 288 289 /* Insert reference to structure into the trie */ 290 static int do_insert_tree(struct qtree_mem_dqinfo *info, struct dquot *dquot, 291 uint *treeblk, int depth) 292 { 293 char *buf = getdqbuf(info->dqi_usable_bs); 294 int ret = 0, newson = 0, newact = 0; 295 __le32 *ref; 296 uint newblk; 297 298 if (!buf) 299 return -ENOMEM; 300 if (!*treeblk) { 301 ret = get_free_dqblk(info); 302 if (ret < 0) 303 goto out_buf; 304 *treeblk = ret; 305 memset(buf, 0, info->dqi_usable_bs); 306 newact = 1; 307 } else { 308 ret = read_blk(info, *treeblk, buf); 309 if (ret < 0) { 310 quota_error(dquot->dq_sb, "Can't read tree quota " 311 "block %u", *treeblk); 312 goto out_buf; 313 } 314 } 315 ref = (__le32 *)buf; 316 newblk = le32_to_cpu(ref[get_index(info, dquot->dq_id, depth)]); 317 if (!newblk) 318 newson = 1; 319 if (depth == info->dqi_qtree_depth - 1) { 320 #ifdef __QUOTA_QT_PARANOIA 321 if (newblk) { 322 quota_error(dquot->dq_sb, "Inserting already present " 323 "quota entry (block %u)", 324 le32_to_cpu(ref[get_index(info, 325 dquot->dq_id, depth)])); 326 ret = -EIO; 327 goto out_buf; 328 } 329 #endif 330 newblk = find_free_dqentry(info, dquot, &ret); 331 } else { 332 ret = do_insert_tree(info, dquot, &newblk, depth+1); 333 } 334 if (newson && ret >= 0) { 335 ref[get_index(info, dquot->dq_id, depth)] = 336 cpu_to_le32(newblk); 337 ret = write_blk(info, *treeblk, buf); 338 } else if (newact && ret < 0) { 339 put_free_dqblk(info, buf, *treeblk); 340 } 341 out_buf: 342 kfree(buf); 343 return ret; 344 } 345 346 /* Wrapper for inserting quota structure into tree */ 347 static inline int dq_insert_tree(struct qtree_mem_dqinfo *info, 348 struct dquot *dquot) 349 { 350 int tmp = QT_TREEOFF; 351 return do_insert_tree(info, dquot, &tmp, 0); 352 } 353 354 /* 355 * We don't have to be afraid of deadlocks as we never have quotas on quota 356 * files... 357 */ 358 int qtree_write_dquot(struct qtree_mem_dqinfo *info, struct dquot *dquot) 359 { 360 int type = dquot->dq_type; 361 struct super_block *sb = dquot->dq_sb; 362 ssize_t ret; 363 char *ddquot = getdqbuf(info->dqi_entry_size); 364 365 if (!ddquot) 366 return -ENOMEM; 367 368 /* dq_off is guarded by dqio_mutex */ 369 if (!dquot->dq_off) { 370 ret = dq_insert_tree(info, dquot); 371 if (ret < 0) { 372 quota_error(sb, "Error %zd occurred while creating " 373 "quota", ret); 374 kfree(ddquot); 375 return ret; 376 } 377 } 378 spin_lock(&dq_data_lock); 379 info->dqi_ops->mem2disk_dqblk(ddquot, dquot); 380 spin_unlock(&dq_data_lock); 381 ret = sb->s_op->quota_write(sb, type, ddquot, info->dqi_entry_size, 382 dquot->dq_off); 383 if (ret != info->dqi_entry_size) { 384 quota_error(sb, "dquota write failed"); 385 if (ret >= 0) 386 ret = -ENOSPC; 387 } else { 388 ret = 0; 389 } 390 dqstats_inc(DQST_WRITES); 391 kfree(ddquot); 392 393 return ret; 394 } 395 EXPORT_SYMBOL(qtree_write_dquot); 396 397 /* Free dquot entry in data block */ 398 static int free_dqentry(struct qtree_mem_dqinfo *info, struct dquot *dquot, 399 uint blk) 400 { 401 struct qt_disk_dqdbheader *dh; 402 char *buf = getdqbuf(info->dqi_usable_bs); 403 int ret = 0; 404 405 if (!buf) 406 return -ENOMEM; 407 if (dquot->dq_off >> info->dqi_blocksize_bits != blk) { 408 quota_error(dquot->dq_sb, "Quota structure has offset to " 409 "other block (%u) than it should (%u)", blk, 410 (uint)(dquot->dq_off >> info->dqi_blocksize_bits)); 411 goto out_buf; 412 } 413 ret = read_blk(info, blk, buf); 414 if (ret < 0) { 415 quota_error(dquot->dq_sb, "Can't read quota data block %u", 416 blk); 417 goto out_buf; 418 } 419 dh = (struct qt_disk_dqdbheader *)buf; 420 le16_add_cpu(&dh->dqdh_entries, -1); 421 if (!le16_to_cpu(dh->dqdh_entries)) { /* Block got free? */ 422 ret = remove_free_dqentry(info, buf, blk); 423 if (ret >= 0) 424 ret = put_free_dqblk(info, buf, blk); 425 if (ret < 0) { 426 quota_error(dquot->dq_sb, "Can't move quota data block " 427 "(%u) to free list", blk); 428 goto out_buf; 429 } 430 } else { 431 memset(buf + 432 (dquot->dq_off & ((1 << info->dqi_blocksize_bits) - 1)), 433 0, info->dqi_entry_size); 434 if (le16_to_cpu(dh->dqdh_entries) == 435 qtree_dqstr_in_blk(info) - 1) { 436 /* Insert will write block itself */ 437 ret = insert_free_dqentry(info, buf, blk); 438 if (ret < 0) { 439 quota_error(dquot->dq_sb, "Can't insert quota " 440 "data block (%u) to free entry list", blk); 441 goto out_buf; 442 } 443 } else { 444 ret = write_blk(info, blk, buf); 445 if (ret < 0) { 446 quota_error(dquot->dq_sb, "Can't write quota " 447 "data block %u", blk); 448 goto out_buf; 449 } 450 } 451 } 452 dquot->dq_off = 0; /* Quota is now unattached */ 453 out_buf: 454 kfree(buf); 455 return ret; 456 } 457 458 /* Remove reference to dquot from tree */ 459 static int remove_tree(struct qtree_mem_dqinfo *info, struct dquot *dquot, 460 uint *blk, int depth) 461 { 462 char *buf = getdqbuf(info->dqi_usable_bs); 463 int ret = 0; 464 uint newblk; 465 __le32 *ref = (__le32 *)buf; 466 467 if (!buf) 468 return -ENOMEM; 469 ret = read_blk(info, *blk, buf); 470 if (ret < 0) { 471 quota_error(dquot->dq_sb, "Can't read quota data " 472 "block %u", blk); 473 goto out_buf; 474 } 475 newblk = le32_to_cpu(ref[get_index(info, dquot->dq_id, depth)]); 476 if (depth == info->dqi_qtree_depth - 1) { 477 ret = free_dqentry(info, dquot, newblk); 478 newblk = 0; 479 } else { 480 ret = remove_tree(info, dquot, &newblk, depth+1); 481 } 482 if (ret >= 0 && !newblk) { 483 int i; 484 ref[get_index(info, dquot->dq_id, depth)] = cpu_to_le32(0); 485 /* Block got empty? */ 486 for (i = 0; i < (info->dqi_usable_bs >> 2) && !ref[i]; i++) 487 ; 488 /* Don't put the root block into the free block list */ 489 if (i == (info->dqi_usable_bs >> 2) 490 && *blk != QT_TREEOFF) { 491 put_free_dqblk(info, buf, *blk); 492 *blk = 0; 493 } else { 494 ret = write_blk(info, *blk, buf); 495 if (ret < 0) 496 quota_error(dquot->dq_sb, "Can't write quota " 497 "tree block %u", blk); 498 } 499 } 500 out_buf: 501 kfree(buf); 502 return ret; 503 } 504 505 /* Delete dquot from tree */ 506 int qtree_delete_dquot(struct qtree_mem_dqinfo *info, struct dquot *dquot) 507 { 508 uint tmp = QT_TREEOFF; 509 510 if (!dquot->dq_off) /* Even not allocated? */ 511 return 0; 512 return remove_tree(info, dquot, &tmp, 0); 513 } 514 EXPORT_SYMBOL(qtree_delete_dquot); 515 516 /* Find entry in block */ 517 static loff_t find_block_dqentry(struct qtree_mem_dqinfo *info, 518 struct dquot *dquot, uint blk) 519 { 520 char *buf = getdqbuf(info->dqi_usable_bs); 521 loff_t ret = 0; 522 int i; 523 char *ddquot; 524 525 if (!buf) 526 return -ENOMEM; 527 ret = read_blk(info, blk, buf); 528 if (ret < 0) { 529 quota_error(dquot->dq_sb, "Can't read quota tree " 530 "block %u", blk); 531 goto out_buf; 532 } 533 ddquot = buf + sizeof(struct qt_disk_dqdbheader); 534 for (i = 0; i < qtree_dqstr_in_blk(info); i++) { 535 if (info->dqi_ops->is_id(ddquot, dquot)) 536 break; 537 ddquot += info->dqi_entry_size; 538 } 539 if (i == qtree_dqstr_in_blk(info)) { 540 quota_error(dquot->dq_sb, "Quota for id %u referenced " 541 "but not present", dquot->dq_id); 542 ret = -EIO; 543 goto out_buf; 544 } else { 545 ret = (blk << info->dqi_blocksize_bits) + sizeof(struct 546 qt_disk_dqdbheader) + i * info->dqi_entry_size; 547 } 548 out_buf: 549 kfree(buf); 550 return ret; 551 } 552 553 /* Find entry for given id in the tree */ 554 static loff_t find_tree_dqentry(struct qtree_mem_dqinfo *info, 555 struct dquot *dquot, uint blk, int depth) 556 { 557 char *buf = getdqbuf(info->dqi_usable_bs); 558 loff_t ret = 0; 559 __le32 *ref = (__le32 *)buf; 560 561 if (!buf) 562 return -ENOMEM; 563 ret = read_blk(info, blk, buf); 564 if (ret < 0) { 565 quota_error(dquot->dq_sb, "Can't read quota tree block %u", 566 blk); 567 goto out_buf; 568 } 569 ret = 0; 570 blk = le32_to_cpu(ref[get_index(info, dquot->dq_id, depth)]); 571 if (!blk) /* No reference? */ 572 goto out_buf; 573 if (depth < info->dqi_qtree_depth - 1) 574 ret = find_tree_dqentry(info, dquot, blk, depth+1); 575 else 576 ret = find_block_dqentry(info, dquot, blk); 577 out_buf: 578 kfree(buf); 579 return ret; 580 } 581 582 /* Find entry for given id in the tree - wrapper function */ 583 static inline loff_t find_dqentry(struct qtree_mem_dqinfo *info, 584 struct dquot *dquot) 585 { 586 return find_tree_dqentry(info, dquot, QT_TREEOFF, 0); 587 } 588 589 int qtree_read_dquot(struct qtree_mem_dqinfo *info, struct dquot *dquot) 590 { 591 int type = dquot->dq_type; 592 struct super_block *sb = dquot->dq_sb; 593 loff_t offset; 594 char *ddquot; 595 int ret = 0; 596 597 #ifdef __QUOTA_QT_PARANOIA 598 /* Invalidated quota? */ 599 if (!sb_dqopt(dquot->dq_sb)->files[type]) { 600 quota_error(sb, "Quota invalidated while reading!"); 601 return -EIO; 602 } 603 #endif 604 /* Do we know offset of the dquot entry in the quota file? */ 605 if (!dquot->dq_off) { 606 offset = find_dqentry(info, dquot); 607 if (offset <= 0) { /* Entry not present? */ 608 if (offset < 0) 609 quota_error(sb, "Can't read quota structure " 610 "for id %u", dquot->dq_id); 611 dquot->dq_off = 0; 612 set_bit(DQ_FAKE_B, &dquot->dq_flags); 613 memset(&dquot->dq_dqb, 0, sizeof(struct mem_dqblk)); 614 ret = offset; 615 goto out; 616 } 617 dquot->dq_off = offset; 618 } 619 ddquot = getdqbuf(info->dqi_entry_size); 620 if (!ddquot) 621 return -ENOMEM; 622 ret = sb->s_op->quota_read(sb, type, ddquot, info->dqi_entry_size, 623 dquot->dq_off); 624 if (ret != info->dqi_entry_size) { 625 if (ret >= 0) 626 ret = -EIO; 627 quota_error(sb, "Error while reading quota structure for id %u", 628 dquot->dq_id); 629 set_bit(DQ_FAKE_B, &dquot->dq_flags); 630 memset(&dquot->dq_dqb, 0, sizeof(struct mem_dqblk)); 631 kfree(ddquot); 632 goto out; 633 } 634 spin_lock(&dq_data_lock); 635 info->dqi_ops->disk2mem_dqblk(dquot, ddquot); 636 if (!dquot->dq_dqb.dqb_bhardlimit && 637 !dquot->dq_dqb.dqb_bsoftlimit && 638 !dquot->dq_dqb.dqb_ihardlimit && 639 !dquot->dq_dqb.dqb_isoftlimit) 640 set_bit(DQ_FAKE_B, &dquot->dq_flags); 641 spin_unlock(&dq_data_lock); 642 kfree(ddquot); 643 out: 644 dqstats_inc(DQST_READS); 645 return ret; 646 } 647 EXPORT_SYMBOL(qtree_read_dquot); 648 649 /* Check whether dquot should not be deleted. We know we are 650 * the only one operating on dquot (thanks to dq_lock) */ 651 int qtree_release_dquot(struct qtree_mem_dqinfo *info, struct dquot *dquot) 652 { 653 if (test_bit(DQ_FAKE_B, &dquot->dq_flags) && 654 !(dquot->dq_dqb.dqb_curinodes | dquot->dq_dqb.dqb_curspace)) 655 return qtree_delete_dquot(info, dquot); 656 return 0; 657 } 658 EXPORT_SYMBOL(qtree_release_dquot); 659