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