Lines Matching refs:qd
82 struct gfs2_quota_data *qd;
93 qd = list_entry(qd_lru_list.next,
95 sdp = qd->qd_gl->gl_sbd;
98 list_del(&qd->qd_list);
100 gfs2_assert_warn(sdp, !qd->qd_change);
101 gfs2_assert_warn(sdp, !qd->qd_slot_count);
102 gfs2_assert_warn(sdp, !qd->qd_bh_count);
104 gfs2_glock_put(qd->qd_gl);
108 list_del_init(&qd->qd_reclaim);
111 kmem_cache_free(gfs2_quotad_cachep, qd);
121 static u64 qd2offset(struct gfs2_quota_data *qd)
125 offset = 2 * (u64)qd->qd_id + !test_bit(QDF_USER, &qd->qd_flags);
134 struct gfs2_quota_data *qd;
137 qd = kmem_cache_zalloc(gfs2_quotad_cachep, GFP_NOFS);
138 if (!qd)
141 atomic_set(&qd->qd_count, 1);
142 qd->qd_id = id;
144 set_bit(QDF_USER, &qd->qd_flags);
145 qd->qd_slot = -1;
146 INIT_LIST_HEAD(&qd->qd_reclaim);
149 &gfs2_quota_glops, CREATE, &qd->qd_gl);
153 *qdp = qd;
158 kmem_cache_free(gfs2_quotad_cachep, qd);
165 struct gfs2_quota_data *qd = NULL, *new_qd = NULL;
173 list_for_each_entry(qd, &sdp->sd_quota_list, qd_list) {
174 if (qd->qd_id == id &&
175 !test_bit(QDF_USER, &qd->qd_flags) == !user) {
176 if (!atomic_read(&qd->qd_count) &&
177 !list_empty(&qd->qd_reclaim)) {
179 list_del_init(&qd->qd_reclaim);
182 atomic_inc(&qd->qd_count);
189 qd = NULL;
191 if (!qd && new_qd) {
192 qd = new_qd;
193 list_add(&qd->qd_list, &sdp->sd_quota_list);
200 if (qd) {
205 *qdp = qd;
215 static void qd_hold(struct gfs2_quota_data *qd)
217 struct gfs2_sbd *sdp = qd->qd_gl->gl_sbd;
218 gfs2_assert(sdp, atomic_read(&qd->qd_count));
219 atomic_inc(&qd->qd_count);
222 static void qd_put(struct gfs2_quota_data *qd)
224 if (atomic_dec_and_lock(&qd->qd_count, &qd_lru_lock)) {
226 list_add_tail(&qd->qd_reclaim, &qd_lru_list);
232 static int slot_get(struct gfs2_quota_data *qd)
234 struct gfs2_sbd *sdp = qd->qd_gl->gl_sbd;
240 if (qd->qd_slot_count++) {
258 qd->qd_slot = c * (8 * PAGE_SIZE) + o * 8 + b;
260 if (qd->qd_slot >= sdp->sd_quota_slots)
270 qd->qd_slot_count--;
275 static void slot_hold(struct gfs2_quota_data *qd)
277 struct gfs2_sbd *sdp = qd->qd_gl->gl_sbd;
280 gfs2_assert(sdp, qd->qd_slot_count);
281 qd->qd_slot_count++;
285 static void slot_put(struct gfs2_quota_data *qd)
287 struct gfs2_sbd *sdp = qd->qd_gl->gl_sbd;
290 gfs2_assert(sdp, qd->qd_slot_count);
291 if (!--qd->qd_slot_count) {
292 gfs2_icbit_munge(sdp, sdp->sd_quota_bitmap, qd->qd_slot, 0);
293 qd->qd_slot = -1;
298 static int bh_get(struct gfs2_quota_data *qd)
300 struct gfs2_sbd *sdp = qd->qd_gl->gl_sbd;
309 if (qd->qd_bh_count++) {
314 block = qd->qd_slot / sdp->sd_qc_per_block;
315 offset = qd->qd_slot % sdp->sd_qc_per_block;
328 qd->qd_bh = bh;
329 qd->qd_bh_qc = (struct gfs2_quota_change *)
340 qd->qd_bh_count--;
345 static void bh_put(struct gfs2_quota_data *qd)
347 struct gfs2_sbd *sdp = qd->qd_gl->gl_sbd;
350 gfs2_assert(sdp, qd->qd_bh_count);
351 if (!--qd->qd_bh_count) {
352 brelse(qd->qd_bh);
353 qd->qd_bh = NULL;
354 qd->qd_bh_qc = NULL;
361 struct gfs2_quota_data *qd = NULL;
372 list_for_each_entry(qd, &sdp->sd_quota_list, qd_list) {
373 if (test_bit(QDF_LOCKED, &qd->qd_flags) ||
374 !test_bit(QDF_CHANGE, &qd->qd_flags) ||
375 qd->qd_sync_gen >= sdp->sd_quota_sync_gen)
378 list_move_tail(&qd->qd_list, &sdp->sd_quota_list);
380 set_bit(QDF_LOCKED, &qd->qd_flags);
381 gfs2_assert_warn(sdp, atomic_read(&qd->qd_count));
382 atomic_inc(&qd->qd_count);
383 qd->qd_change_sync = qd->qd_change;
384 gfs2_assert_warn(sdp, qd->qd_slot_count);
385 qd->qd_slot_count++;
392 qd = NULL;
396 if (qd) {
397 gfs2_assert_warn(sdp, qd->qd_change_sync);
398 error = bh_get(qd);
400 clear_bit(QDF_LOCKED, &qd->qd_flags);
401 slot_put(qd);
402 qd_put(qd);
407 *qdp = qd;
412 static int qd_trylock(struct gfs2_quota_data *qd)
414 struct gfs2_sbd *sdp = qd->qd_gl->gl_sbd;
421 if (test_bit(QDF_LOCKED, &qd->qd_flags) ||
422 !test_bit(QDF_CHANGE, &qd->qd_flags)) {
427 list_move_tail(&qd->qd_list, &sdp->sd_quota_list);
429 set_bit(QDF_LOCKED, &qd->qd_flags);
430 gfs2_assert_warn(sdp, atomic_read(&qd->qd_count));
431 atomic_inc(&qd->qd_count);
432 qd->qd_change_sync = qd->qd_change;
433 gfs2_assert_warn(sdp, qd->qd_slot_count);
434 qd->qd_slot_count++;
438 gfs2_assert_warn(sdp, qd->qd_change_sync);
439 if (bh_get(qd)) {
440 clear_bit(QDF_LOCKED, &qd->qd_flags);
441 slot_put(qd);
442 qd_put(qd);
449 static void qd_unlock(struct gfs2_quota_data *qd)
451 gfs2_assert_warn(qd->qd_gl->gl_sbd,
452 test_bit(QDF_LOCKED, &qd->qd_flags));
453 clear_bit(QDF_LOCKED, &qd->qd_flags);
454 bh_put(qd);
455 slot_put(qd);
456 qd_put(qd);
485 static void qdsb_put(struct gfs2_quota_data *qd)
487 bh_put(qd);
488 slot_put(qd);
489 qd_put(qd);
496 struct gfs2_quota_data **qd = al->al_qd;
506 error = qdsb_get(sdp, QUOTA_USER, ip->i_inode.i_uid, qd);
510 qd++;
512 error = qdsb_get(sdp, QUOTA_GROUP, ip->i_inode.i_gid, qd);
516 qd++;
519 error = qdsb_get(sdp, QUOTA_USER, uid, qd);
523 qd++;
527 error = qdsb_get(sdp, QUOTA_GROUP, gid, qd);
531 qd++;
575 static void do_qc(struct gfs2_quota_data *qd, s64 change)
577 struct gfs2_sbd *sdp = qd->qd_gl->gl_sbd;
579 struct gfs2_quota_change *qc = qd->qd_bh_qc;
583 gfs2_trans_add_bh(ip->i_gl, qd->qd_bh, 1);
585 if (!test_bit(QDF_CHANGE, &qd->qd_flags)) {
588 if (test_bit(QDF_USER, &qd->qd_flags))
590 qc->qc_id = cpu_to_be32(qd->qd_id);
597 qd->qd_change = x;
601 gfs2_assert_warn(sdp, test_bit(QDF_CHANGE, &qd->qd_flags));
602 clear_bit(QDF_CHANGE, &qd->qd_flags);
605 slot_put(qd);
606 qd_put(qd);
607 } else if (!test_and_set_bit(QDF_CHANGE, &qd->qd_flags)) {
608 qd_hold(qd);
609 slot_hold(qd);
620 * @qd: The quota data
630 s64 change, struct gfs2_quota_data *qd,
658 qd->qd_qb.qb_value = qp->qu_value;
662 qd->qd_qb.qb_warn = qp->qu_warn;
666 qd->qd_qb.qb_limit = qp->qu_limit;
763 struct gfs2_quota_data *qd;
827 qd = qda[x];
828 offset = qd2offset(qd);
829 error = gfs2_adjust_quota(ip, offset, qd->qd_change_sync, qd, NULL);
833 do_qc(qd, -qd->qd_change_sync);
855 static int update_qd(struct gfs2_sbd *sdp, struct gfs2_quota_data *qd)
864 pos = qd2offset(qd);
869 qlvb = (struct gfs2_quota_lvb *)qd->qd_gl->gl_lvb;
875 qd->qd_qb = *qlvb;
880 static int do_glock(struct gfs2_quota_data *qd, int force_refresh,
883 struct gfs2_sbd *sdp = qd->qd_gl->gl_sbd;
889 error = gfs2_glock_nq_init(qd->qd_gl, LM_ST_SHARED, 0, q_gh);
893 qd->qd_qb = *(struct gfs2_quota_lvb *)qd->qd_gl->gl_lvb;
895 if (force_refresh || qd->qd_qb.qb_magic != cpu_to_be32(GFS2_MAGIC)) {
897 error = gfs2_glock_nq_init(qd->qd_gl, LM_ST_EXCLUSIVE,
906 error = update_qd(sdp, qd);
958 static int need_sync(struct gfs2_quota_data *qd)
960 struct gfs2_sbd *sdp = qd->qd_gl->gl_sbd;
966 if (!qd->qd_qb.qb_limit)
970 value = qd->qd_change;
980 else if ((s64)be64_to_cpu(qd->qd_qb.qb_value) >=
981 (s64)be64_to_cpu(qd->qd_qb.qb_limit))
986 value += (s64)be64_to_cpu(qd->qd_qb.qb_value);
987 if (value < (s64)be64_to_cpu(qd->qd_qb.qb_limit))
1005 struct gfs2_quota_data *qd;
1008 qd = al->al_qd[x];
1009 sync = need_sync(qd);
1013 if (sync && qd_trylock(qd))
1014 qda[count++] = qd;
1029 static int print_message(struct gfs2_quota_data *qd, char *type)
1031 struct gfs2_sbd *sdp = qd->qd_gl->gl_sbd;
1035 (test_bit(QDF_USER, &qd->qd_flags)) ? "user" : "group",
1036 qd->qd_id);
1045 struct gfs2_quota_data *qd;
1057 qd = al->al_qd[x];
1059 if (!((qd->qd_id == uid && test_bit(QDF_USER, &qd->qd_flags)) ||
1060 (qd->qd_id == gid && !test_bit(QDF_USER, &qd->qd_flags))))
1063 value = (s64)be64_to_cpu(qd->qd_qb.qb_value);
1065 value += qd->qd_change;
1068 if (be64_to_cpu(qd->qd_qb.qb_limit) && (s64)be64_to_cpu(qd->qd_qb.qb_limit) < value) {
1069 print_message(qd, "exceeded");
1070 quota_send_warning(test_bit(QDF_USER, &qd->qd_flags) ?
1071 USRQUOTA : GRPQUOTA, qd->qd_id,
1076 } else if (be64_to_cpu(qd->qd_qb.qb_warn) &&
1077 (s64)be64_to_cpu(qd->qd_qb.qb_warn) < value &&
1078 time_after_eq(jiffies, qd->qd_last_warn +
1081 quota_send_warning(test_bit(QDF_USER, &qd->qd_flags) ?
1082 USRQUOTA : GRPQUOTA, qd->qd_id,
1084 error = print_message(qd, "warning");
1085 qd->qd_last_warn = jiffies;
1096 struct gfs2_quota_data *qd;
1105 qd = al->al_qd[x];
1107 if ((qd->qd_id == uid && test_bit(QDF_USER, &qd->qd_flags)) ||
1108 (qd->qd_id == gid && !test_bit(QDF_USER, &qd->qd_flags))) {
1109 do_qc(qd, change);
1165 struct gfs2_quota_data *qd;
1169 error = qd_get(sdp, user, id, &qd);
1173 error = do_glock(qd, FORCE, &q_gh);
1177 qd_put(qd);
1243 struct gfs2_quota_data *qd;
1252 qc.qc_id, &qd);
1258 set_bit(QDF_CHANGE, &qd->qd_flags);
1259 qd->qd_change = qc.qc_change;
1260 qd->qd_slot = slot;
1261 qd->qd_slot_count = 1;
1265 list_add(&qd->qd_list, &sdp->sd_quota_list);
1290 struct gfs2_quota_data *qd;
1295 qd = list_entry(head->prev, struct gfs2_quota_data, qd_list);
1297 if (atomic_read(&qd->qd_count) > 1 ||
1298 (atomic_read(&qd->qd_count) &&
1299 !test_bit(QDF_CHANGE, &qd->qd_flags))) {
1300 list_move(&qd->qd_list, head);
1307 list_del(&qd->qd_list);
1308 /* Also remove if this qd exists in the reclaim list */
1309 if (!list_empty(&qd->qd_reclaim)) {
1310 list_del_init(&qd->qd_reclaim);
1316 if (!atomic_read(&qd->qd_count)) {
1317 gfs2_assert_warn(sdp, !qd->qd_change);
1318 gfs2_assert_warn(sdp, !qd->qd_slot_count);
1320 gfs2_assert_warn(sdp, qd->qd_slot_count == 1);
1321 gfs2_assert_warn(sdp, !qd->qd_bh_count);
1323 gfs2_glock_put(qd->qd_gl);
1324 kmem_cache_free(gfs2_quotad_cachep, qd);
1476 struct gfs2_quota_data *qd;
1492 error = qd_get(sdp, type, id, &qd);
1495 error = do_glock(qd, FORCE, &q_gh);
1499 qlvb = (struct gfs2_quota_lvb *)qd->qd_gl->gl_lvb;
1509 qd_put(qd);
1521 struct gfs2_quota_data *qd;
1553 error = qd_get(sdp, type, id, &qd);
1558 error = gfs2_glock_nq_init(qd->qd_gl, LM_ST_EXCLUSIVE, 0, &q_gh);
1566 error = update_qd(sdp, qd);
1572 (fdq->d_blk_softlimit == be64_to_cpu(qd->qd_qb.qb_warn)))
1575 (fdq->d_blk_hardlimit == be64_to_cpu(qd->qd_qb.qb_limit)))
1580 offset = qd2offset(qd);
1599 error = gfs2_adjust_quota(ip, offset, 0, qd, fdq);
1614 qd_put(qd);