1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  *  Implementation of operations over local quota file
4  */
5 
6 #include <linux/fs.h>
7 #include <linux/slab.h>
8 #include <linux/quota.h>
9 #include <linux/quotaops.h>
10 #include <linux/module.h>
11 
12 #include <cluster/masklog.h>
13 
14 #include "ocfs2_fs.h"
15 #include "ocfs2.h"
16 #include "inode.h"
17 #include "alloc.h"
18 #include "file.h"
19 #include "buffer_head_io.h"
20 #include "journal.h"
21 #include "sysfile.h"
22 #include "dlmglue.h"
23 #include "quota.h"
24 #include "uptodate.h"
25 #include "super.h"
26 #include "ocfs2_trace.h"
27 
28 /* Number of local quota structures per block */
ol_quota_entries_per_block(struct super_block * sb)29 static inline unsigned int ol_quota_entries_per_block(struct super_block *sb)
30 {
31 	return ((sb->s_blocksize - OCFS2_QBLK_RESERVED_SPACE) /
32 		sizeof(struct ocfs2_local_disk_dqblk));
33 }
34 
35 /* Number of blocks with entries in one chunk */
ol_chunk_blocks(struct super_block * sb)36 static inline unsigned int ol_chunk_blocks(struct super_block *sb)
37 {
38 	return ((sb->s_blocksize - sizeof(struct ocfs2_local_disk_chunk) -
39 		 OCFS2_QBLK_RESERVED_SPACE) << 3) /
40 	       ol_quota_entries_per_block(sb);
41 }
42 
43 /* Number of entries in a chunk bitmap */
ol_chunk_entries(struct super_block * sb)44 static unsigned int ol_chunk_entries(struct super_block *sb)
45 {
46 	return ol_chunk_blocks(sb) * ol_quota_entries_per_block(sb);
47 }
48 
49 /* Offset of the chunk in quota file */
ol_quota_chunk_block(struct super_block * sb,int c)50 static unsigned int ol_quota_chunk_block(struct super_block *sb, int c)
51 {
52 	/* 1 block for local quota file info, 1 block per chunk for chunk info */
53 	return 1 + (ol_chunk_blocks(sb) + 1) * c;
54 }
55 
ol_dqblk_block(struct super_block * sb,int c,int off)56 static unsigned int ol_dqblk_block(struct super_block *sb, int c, int off)
57 {
58 	int epb = ol_quota_entries_per_block(sb);
59 
60 	return ol_quota_chunk_block(sb, c) + 1 + off / epb;
61 }
62 
ol_dqblk_block_off(struct super_block * sb,int c,int off)63 static unsigned int ol_dqblk_block_off(struct super_block *sb, int c, int off)
64 {
65 	int epb = ol_quota_entries_per_block(sb);
66 
67 	return (off % epb) * sizeof(struct ocfs2_local_disk_dqblk);
68 }
69 
70 /* Offset of the dquot structure in the quota file */
ol_dqblk_off(struct super_block * sb,int c,int off)71 static loff_t ol_dqblk_off(struct super_block *sb, int c, int off)
72 {
73 	return (ol_dqblk_block(sb, c, off) << sb->s_blocksize_bits) +
74 	       ol_dqblk_block_off(sb, c, off);
75 }
76 
ol_dqblk_block_offset(struct super_block * sb,loff_t off)77 static inline unsigned int ol_dqblk_block_offset(struct super_block *sb, loff_t off)
78 {
79 	return off & ((1 << sb->s_blocksize_bits) - 1);
80 }
81 
82 /* Compute offset in the chunk of a structure with the given offset */
ol_dqblk_chunk_off(struct super_block * sb,int c,loff_t off)83 static int ol_dqblk_chunk_off(struct super_block *sb, int c, loff_t off)
84 {
85 	int epb = ol_quota_entries_per_block(sb);
86 
87 	return ((off >> sb->s_blocksize_bits) -
88 			ol_quota_chunk_block(sb, c) - 1) * epb
89 	       + ((unsigned int)(off & ((1 << sb->s_blocksize_bits) - 1))) /
90 		 sizeof(struct ocfs2_local_disk_dqblk);
91 }
92 
93 /* Write bufferhead into the fs */
ocfs2_modify_bh(struct inode * inode,struct buffer_head * bh,void (* modify)(struct buffer_head *,void *),void * private)94 static int ocfs2_modify_bh(struct inode *inode, struct buffer_head *bh,
95 		void (*modify)(struct buffer_head *, void *), void *private)
96 {
97 	struct super_block *sb = inode->i_sb;
98 	handle_t *handle;
99 	int status;
100 
101 	handle = ocfs2_start_trans(OCFS2_SB(sb),
102 				   OCFS2_QUOTA_BLOCK_UPDATE_CREDITS);
103 	if (IS_ERR(handle)) {
104 		status = PTR_ERR(handle);
105 		mlog_errno(status);
106 		return status;
107 	}
108 	status = ocfs2_journal_access_dq(handle, INODE_CACHE(inode), bh,
109 					 OCFS2_JOURNAL_ACCESS_WRITE);
110 	if (status < 0) {
111 		mlog_errno(status);
112 		ocfs2_commit_trans(OCFS2_SB(sb), handle);
113 		return status;
114 	}
115 	lock_buffer(bh);
116 	modify(bh, private);
117 	unlock_buffer(bh);
118 	ocfs2_journal_dirty(handle, bh);
119 
120 	status = ocfs2_commit_trans(OCFS2_SB(sb), handle);
121 	if (status < 0) {
122 		mlog_errno(status);
123 		return status;
124 	}
125 	return 0;
126 }
127 
128 /*
129  * Read quota block from a given logical offset.
130  *
131  * This function acquires ip_alloc_sem and thus it must not be called with a
132  * transaction started.
133  */
ocfs2_read_quota_block(struct inode * inode,u64 v_block,struct buffer_head ** bh)134 static int ocfs2_read_quota_block(struct inode *inode, u64 v_block,
135 				  struct buffer_head **bh)
136 {
137 	int rc = 0;
138 	struct buffer_head *tmp = *bh;
139 
140 	if (i_size_read(inode) >> inode->i_sb->s_blocksize_bits <= v_block)
141 		return ocfs2_error(inode->i_sb,
142 				"Quota file %llu is probably corrupted! Requested to read block %Lu but file has size only %Lu\n",
143 				(unsigned long long)OCFS2_I(inode)->ip_blkno,
144 				(unsigned long long)v_block,
145 				(unsigned long long)i_size_read(inode));
146 
147 	rc = ocfs2_read_virt_blocks(inode, v_block, 1, &tmp, 0,
148 				    ocfs2_validate_quota_block);
149 	if (rc)
150 		mlog_errno(rc);
151 
152 	/* If ocfs2_read_virt_blocks() got us a new bh, pass it up. */
153 	if (!rc && !*bh)
154 		*bh = tmp;
155 
156 	return rc;
157 }
158 
159 /* Check whether we understand format of quota files */
ocfs2_local_check_quota_file(struct super_block * sb,int type)160 static int ocfs2_local_check_quota_file(struct super_block *sb, int type)
161 {
162 	unsigned int lmagics[OCFS2_MAXQUOTAS] = OCFS2_LOCAL_QMAGICS;
163 	unsigned int lversions[OCFS2_MAXQUOTAS] = OCFS2_LOCAL_QVERSIONS;
164 	unsigned int gmagics[OCFS2_MAXQUOTAS] = OCFS2_GLOBAL_QMAGICS;
165 	unsigned int gversions[OCFS2_MAXQUOTAS] = OCFS2_GLOBAL_QVERSIONS;
166 	unsigned int ino[OCFS2_MAXQUOTAS] = { USER_QUOTA_SYSTEM_INODE,
167 					      GROUP_QUOTA_SYSTEM_INODE };
168 	struct buffer_head *bh = NULL;
169 	struct inode *linode = sb_dqopt(sb)->files[type];
170 	struct inode *ginode = NULL;
171 	struct ocfs2_disk_dqheader *dqhead;
172 	int status, ret = 0;
173 
174 	/* First check whether we understand local quota file */
175 	status = ocfs2_read_quota_block(linode, 0, &bh);
176 	if (status) {
177 		mlog_errno(status);
178 		mlog(ML_ERROR, "failed to read quota file header (type=%d)\n",
179 			type);
180 		goto out_err;
181 	}
182 	dqhead = (struct ocfs2_disk_dqheader *)(bh->b_data);
183 	if (le32_to_cpu(dqhead->dqh_magic) != lmagics[type]) {
184 		mlog(ML_ERROR, "quota file magic does not match (%u != %u),"
185 			" type=%d\n", le32_to_cpu(dqhead->dqh_magic),
186 			lmagics[type], type);
187 		goto out_err;
188 	}
189 	if (le32_to_cpu(dqhead->dqh_version) != lversions[type]) {
190 		mlog(ML_ERROR, "quota file version does not match (%u != %u),"
191 			" type=%d\n", le32_to_cpu(dqhead->dqh_version),
192 			lversions[type], type);
193 		goto out_err;
194 	}
195 	brelse(bh);
196 	bh = NULL;
197 
198 	/* Next check whether we understand global quota file */
199 	ginode = ocfs2_get_system_file_inode(OCFS2_SB(sb), ino[type],
200 						OCFS2_INVALID_SLOT);
201 	if (!ginode) {
202 		mlog(ML_ERROR, "cannot get global quota file inode "
203 				"(type=%d)\n", type);
204 		goto out_err;
205 	}
206 	/* Since the header is read only, we don't care about locking */
207 	status = ocfs2_read_quota_block(ginode, 0, &bh);
208 	if (status) {
209 		mlog_errno(status);
210 		mlog(ML_ERROR, "failed to read global quota file header "
211 				"(type=%d)\n", type);
212 		goto out_err;
213 	}
214 	dqhead = (struct ocfs2_disk_dqheader *)(bh->b_data);
215 	if (le32_to_cpu(dqhead->dqh_magic) != gmagics[type]) {
216 		mlog(ML_ERROR, "global quota file magic does not match "
217 			"(%u != %u), type=%d\n",
218 			le32_to_cpu(dqhead->dqh_magic), gmagics[type], type);
219 		goto out_err;
220 	}
221 	if (le32_to_cpu(dqhead->dqh_version) != gversions[type]) {
222 		mlog(ML_ERROR, "global quota file version does not match "
223 			"(%u != %u), type=%d\n",
224 			le32_to_cpu(dqhead->dqh_version), gversions[type],
225 			type);
226 		goto out_err;
227 	}
228 
229 	ret = 1;
230 out_err:
231 	brelse(bh);
232 	iput(ginode);
233 	return ret;
234 }
235 
236 /* Release given list of quota file chunks */
ocfs2_release_local_quota_bitmaps(struct list_head * head)237 static void ocfs2_release_local_quota_bitmaps(struct list_head *head)
238 {
239 	struct ocfs2_quota_chunk *pos, *next;
240 
241 	list_for_each_entry_safe(pos, next, head, qc_chunk) {
242 		list_del(&pos->qc_chunk);
243 		brelse(pos->qc_headerbh);
244 		kmem_cache_free(ocfs2_qf_chunk_cachep, pos);
245 	}
246 }
247 
248 /* Load quota bitmaps into memory */
ocfs2_load_local_quota_bitmaps(struct inode * inode,struct ocfs2_local_disk_dqinfo * ldinfo,struct list_head * head)249 static int ocfs2_load_local_quota_bitmaps(struct inode *inode,
250 			struct ocfs2_local_disk_dqinfo *ldinfo,
251 			struct list_head *head)
252 {
253 	struct ocfs2_quota_chunk *newchunk;
254 	int i, status;
255 
256 	INIT_LIST_HEAD(head);
257 	for (i = 0; i < le32_to_cpu(ldinfo->dqi_chunks); i++) {
258 		newchunk = kmem_cache_alloc(ocfs2_qf_chunk_cachep, GFP_NOFS);
259 		if (!newchunk) {
260 			ocfs2_release_local_quota_bitmaps(head);
261 			return -ENOMEM;
262 		}
263 		newchunk->qc_num = i;
264 		newchunk->qc_headerbh = NULL;
265 		status = ocfs2_read_quota_block(inode,
266 				ol_quota_chunk_block(inode->i_sb, i),
267 				&newchunk->qc_headerbh);
268 		if (status) {
269 			mlog_errno(status);
270 			kmem_cache_free(ocfs2_qf_chunk_cachep, newchunk);
271 			ocfs2_release_local_quota_bitmaps(head);
272 			return status;
273 		}
274 		list_add_tail(&newchunk->qc_chunk, head);
275 	}
276 	return 0;
277 }
278 
olq_update_info(struct buffer_head * bh,void * private)279 static void olq_update_info(struct buffer_head *bh, void *private)
280 {
281 	struct mem_dqinfo *info = private;
282 	struct ocfs2_mem_dqinfo *oinfo = info->dqi_priv;
283 	struct ocfs2_local_disk_dqinfo *ldinfo;
284 
285 	ldinfo = (struct ocfs2_local_disk_dqinfo *)(bh->b_data +
286 						OCFS2_LOCAL_INFO_OFF);
287 	spin_lock(&dq_data_lock);
288 	ldinfo->dqi_flags = cpu_to_le32(oinfo->dqi_flags);
289 	ldinfo->dqi_chunks = cpu_to_le32(oinfo->dqi_chunks);
290 	ldinfo->dqi_blocks = cpu_to_le32(oinfo->dqi_blocks);
291 	spin_unlock(&dq_data_lock);
292 }
293 
ocfs2_add_recovery_chunk(struct super_block * sb,struct ocfs2_local_disk_chunk * dchunk,int chunk,struct list_head * head)294 static int ocfs2_add_recovery_chunk(struct super_block *sb,
295 				    struct ocfs2_local_disk_chunk *dchunk,
296 				    int chunk,
297 				    struct list_head *head)
298 {
299 	struct ocfs2_recovery_chunk *rc;
300 
301 	rc = kmalloc(sizeof(struct ocfs2_recovery_chunk), GFP_NOFS);
302 	if (!rc)
303 		return -ENOMEM;
304 	rc->rc_chunk = chunk;
305 	rc->rc_bitmap = kmalloc(sb->s_blocksize, GFP_NOFS);
306 	if (!rc->rc_bitmap) {
307 		kfree(rc);
308 		return -ENOMEM;
309 	}
310 	memcpy(rc->rc_bitmap, dchunk->dqc_bitmap,
311 	       (ol_chunk_entries(sb) + 7) >> 3);
312 	list_add_tail(&rc->rc_list, head);
313 	return 0;
314 }
315 
free_recovery_list(struct list_head * head)316 static void free_recovery_list(struct list_head *head)
317 {
318 	struct ocfs2_recovery_chunk *next;
319 	struct ocfs2_recovery_chunk *rchunk;
320 
321 	list_for_each_entry_safe(rchunk, next, head, rc_list) {
322 		list_del(&rchunk->rc_list);
323 		kfree(rchunk->rc_bitmap);
324 		kfree(rchunk);
325 	}
326 }
327 
ocfs2_free_quota_recovery(struct ocfs2_quota_recovery * rec)328 void ocfs2_free_quota_recovery(struct ocfs2_quota_recovery *rec)
329 {
330 	int type;
331 
332 	for (type = 0; type < OCFS2_MAXQUOTAS; type++)
333 		free_recovery_list(&(rec->r_list[type]));
334 	kfree(rec);
335 }
336 
337 /* Load entries in our quota file we have to recover*/
ocfs2_recovery_load_quota(struct inode * lqinode,struct ocfs2_local_disk_dqinfo * ldinfo,int type,struct list_head * head)338 static int ocfs2_recovery_load_quota(struct inode *lqinode,
339 				     struct ocfs2_local_disk_dqinfo *ldinfo,
340 				     int type,
341 				     struct list_head *head)
342 {
343 	struct super_block *sb = lqinode->i_sb;
344 	struct buffer_head *hbh;
345 	struct ocfs2_local_disk_chunk *dchunk;
346 	int i, chunks = le32_to_cpu(ldinfo->dqi_chunks);
347 	int status = 0;
348 
349 	for (i = 0; i < chunks; i++) {
350 		hbh = NULL;
351 		status = ocfs2_read_quota_block(lqinode,
352 						ol_quota_chunk_block(sb, i),
353 						&hbh);
354 		if (status) {
355 			mlog_errno(status);
356 			break;
357 		}
358 		dchunk = (struct ocfs2_local_disk_chunk *)hbh->b_data;
359 		if (le32_to_cpu(dchunk->dqc_free) < ol_chunk_entries(sb))
360 			status = ocfs2_add_recovery_chunk(sb, dchunk, i, head);
361 		brelse(hbh);
362 		if (status < 0)
363 			break;
364 	}
365 	if (status < 0)
366 		free_recovery_list(head);
367 	return status;
368 }
369 
ocfs2_alloc_quota_recovery(void)370 static struct ocfs2_quota_recovery *ocfs2_alloc_quota_recovery(void)
371 {
372 	int type;
373 	struct ocfs2_quota_recovery *rec;
374 
375 	rec = kmalloc(sizeof(struct ocfs2_quota_recovery), GFP_NOFS);
376 	if (!rec)
377 		return NULL;
378 	for (type = 0; type < OCFS2_MAXQUOTAS; type++)
379 		INIT_LIST_HEAD(&(rec->r_list[type]));
380 	return rec;
381 }
382 
383 /* Load information we need for quota recovery into memory */
ocfs2_begin_quota_recovery(struct ocfs2_super * osb,int slot_num)384 struct ocfs2_quota_recovery *ocfs2_begin_quota_recovery(
385 						struct ocfs2_super *osb,
386 						int slot_num)
387 {
388 	unsigned int feature[OCFS2_MAXQUOTAS] = {
389 					OCFS2_FEATURE_RO_COMPAT_USRQUOTA,
390 					OCFS2_FEATURE_RO_COMPAT_GRPQUOTA};
391 	unsigned int ino[OCFS2_MAXQUOTAS] = { LOCAL_USER_QUOTA_SYSTEM_INODE,
392 					      LOCAL_GROUP_QUOTA_SYSTEM_INODE };
393 	struct super_block *sb = osb->sb;
394 	struct ocfs2_local_disk_dqinfo *ldinfo;
395 	struct inode *lqinode;
396 	struct buffer_head *bh;
397 	int type;
398 	int status = 0;
399 	struct ocfs2_quota_recovery *rec;
400 
401 	printk(KERN_NOTICE "ocfs2: Beginning quota recovery on device (%s) for "
402 	       "slot %u\n", osb->dev_str, slot_num);
403 
404 	rec = ocfs2_alloc_quota_recovery();
405 	if (!rec)
406 		return ERR_PTR(-ENOMEM);
407 	/* First init... */
408 
409 	for (type = 0; type < OCFS2_MAXQUOTAS; type++) {
410 		if (!OCFS2_HAS_RO_COMPAT_FEATURE(sb, feature[type]))
411 			continue;
412 		/* At this point, journal of the slot is already replayed so
413 		 * we can trust metadata and data of the quota file */
414 		lqinode = ocfs2_get_system_file_inode(osb, ino[type], slot_num);
415 		if (!lqinode) {
416 			status = -ENOENT;
417 			goto out;
418 		}
419 		status = ocfs2_inode_lock_full(lqinode, NULL, 1,
420 					       OCFS2_META_LOCK_RECOVERY);
421 		if (status < 0) {
422 			mlog_errno(status);
423 			goto out_put;
424 		}
425 		/* Now read local header */
426 		bh = NULL;
427 		status = ocfs2_read_quota_block(lqinode, 0, &bh);
428 		if (status) {
429 			mlog_errno(status);
430 			mlog(ML_ERROR, "failed to read quota file info header "
431 				"(slot=%d type=%d)\n", slot_num, type);
432 			goto out_lock;
433 		}
434 		ldinfo = (struct ocfs2_local_disk_dqinfo *)(bh->b_data +
435 							OCFS2_LOCAL_INFO_OFF);
436 		status = ocfs2_recovery_load_quota(lqinode, ldinfo, type,
437 						   &rec->r_list[type]);
438 		brelse(bh);
439 out_lock:
440 		ocfs2_inode_unlock(lqinode, 1);
441 out_put:
442 		iput(lqinode);
443 		if (status < 0)
444 			break;
445 	}
446 out:
447 	if (status < 0) {
448 		ocfs2_free_quota_recovery(rec);
449 		rec = ERR_PTR(status);
450 	}
451 	return rec;
452 }
453 
454 /* Sync changes in local quota file into global quota file and
455  * reinitialize local quota file.
456  * The function expects local quota file to be already locked and
457  * s_umount locked in shared mode. */
ocfs2_recover_local_quota_file(struct inode * lqinode,int type,struct ocfs2_quota_recovery * rec)458 static int ocfs2_recover_local_quota_file(struct inode *lqinode,
459 					  int type,
460 					  struct ocfs2_quota_recovery *rec)
461 {
462 	struct super_block *sb = lqinode->i_sb;
463 	struct ocfs2_mem_dqinfo *oinfo = sb_dqinfo(sb, type)->dqi_priv;
464 	struct ocfs2_local_disk_chunk *dchunk;
465 	struct ocfs2_local_disk_dqblk *dqblk;
466 	struct dquot *dquot;
467 	handle_t *handle;
468 	struct buffer_head *hbh = NULL, *qbh = NULL;
469 	int status = 0;
470 	int bit, chunk;
471 	struct ocfs2_recovery_chunk *rchunk, *next;
472 	qsize_t spacechange, inodechange;
473 
474 	trace_ocfs2_recover_local_quota_file((unsigned long)lqinode->i_ino, type);
475 
476 	list_for_each_entry_safe(rchunk, next, &(rec->r_list[type]), rc_list) {
477 		chunk = rchunk->rc_chunk;
478 		hbh = NULL;
479 		status = ocfs2_read_quota_block(lqinode,
480 						ol_quota_chunk_block(sb, chunk),
481 						&hbh);
482 		if (status) {
483 			mlog_errno(status);
484 			break;
485 		}
486 		dchunk = (struct ocfs2_local_disk_chunk *)hbh->b_data;
487 		for_each_set_bit(bit, rchunk->rc_bitmap, ol_chunk_entries(sb)) {
488 			qbh = NULL;
489 			status = ocfs2_read_quota_block(lqinode,
490 						ol_dqblk_block(sb, chunk, bit),
491 						&qbh);
492 			if (status) {
493 				mlog_errno(status);
494 				break;
495 			}
496 			dqblk = (struct ocfs2_local_disk_dqblk *)(qbh->b_data +
497 				ol_dqblk_block_off(sb, chunk, bit));
498 			dquot = dqget(sb,
499 				      make_kqid(&init_user_ns, type,
500 						le64_to_cpu(dqblk->dqb_id)));
501 			if (IS_ERR(dquot)) {
502 				status = PTR_ERR(dquot);
503 				mlog(ML_ERROR, "Failed to get quota structure "
504 				     "for id %u, type %d. Cannot finish quota "
505 				     "file recovery.\n",
506 				     (unsigned)le64_to_cpu(dqblk->dqb_id),
507 				     type);
508 				goto out_put_bh;
509 			}
510 			status = ocfs2_lock_global_qf(oinfo, 1);
511 			if (status < 0) {
512 				mlog_errno(status);
513 				goto out_put_dquot;
514 			}
515 
516 			handle = ocfs2_start_trans(OCFS2_SB(sb),
517 						   OCFS2_QSYNC_CREDITS);
518 			if (IS_ERR(handle)) {
519 				status = PTR_ERR(handle);
520 				mlog_errno(status);
521 				goto out_drop_lock;
522 			}
523 			down_write(&sb_dqopt(sb)->dqio_sem);
524 			spin_lock(&dquot->dq_dqb_lock);
525 			/* Add usage from quota entry into quota changes
526 			 * of our node. Auxiliary variables are important
527 			 * due to signedness */
528 			spacechange = le64_to_cpu(dqblk->dqb_spacemod);
529 			inodechange = le64_to_cpu(dqblk->dqb_inodemod);
530 			dquot->dq_dqb.dqb_curspace += spacechange;
531 			dquot->dq_dqb.dqb_curinodes += inodechange;
532 			spin_unlock(&dquot->dq_dqb_lock);
533 			/* We want to drop reference held by the crashed
534 			 * node. Since we have our own reference we know
535 			 * global structure actually won't be freed. */
536 			status = ocfs2_global_release_dquot(dquot);
537 			if (status < 0) {
538 				mlog_errno(status);
539 				goto out_commit;
540 			}
541 			/* Release local quota file entry */
542 			status = ocfs2_journal_access_dq(handle,
543 					INODE_CACHE(lqinode),
544 					qbh, OCFS2_JOURNAL_ACCESS_WRITE);
545 			if (status < 0) {
546 				mlog_errno(status);
547 				goto out_commit;
548 			}
549 			lock_buffer(qbh);
550 			WARN_ON(!ocfs2_test_bit_unaligned(bit, dchunk->dqc_bitmap));
551 			ocfs2_clear_bit_unaligned(bit, dchunk->dqc_bitmap);
552 			le32_add_cpu(&dchunk->dqc_free, 1);
553 			unlock_buffer(qbh);
554 			ocfs2_journal_dirty(handle, qbh);
555 out_commit:
556 			up_write(&sb_dqopt(sb)->dqio_sem);
557 			ocfs2_commit_trans(OCFS2_SB(sb), handle);
558 out_drop_lock:
559 			ocfs2_unlock_global_qf(oinfo, 1);
560 out_put_dquot:
561 			dqput(dquot);
562 out_put_bh:
563 			brelse(qbh);
564 			if (status < 0)
565 				break;
566 		}
567 		brelse(hbh);
568 		list_del(&rchunk->rc_list);
569 		kfree(rchunk->rc_bitmap);
570 		kfree(rchunk);
571 		if (status < 0)
572 			break;
573 	}
574 	if (status < 0)
575 		free_recovery_list(&(rec->r_list[type]));
576 	if (status)
577 		mlog_errno(status);
578 	return status;
579 }
580 
581 /* Recover local quota files for given node different from us */
ocfs2_finish_quota_recovery(struct ocfs2_super * osb,struct ocfs2_quota_recovery * rec,int slot_num)582 int ocfs2_finish_quota_recovery(struct ocfs2_super *osb,
583 				struct ocfs2_quota_recovery *rec,
584 				int slot_num)
585 {
586 	unsigned int ino[OCFS2_MAXQUOTAS] = { LOCAL_USER_QUOTA_SYSTEM_INODE,
587 					      LOCAL_GROUP_QUOTA_SYSTEM_INODE };
588 	struct super_block *sb = osb->sb;
589 	struct ocfs2_local_disk_dqinfo *ldinfo;
590 	struct buffer_head *bh;
591 	handle_t *handle;
592 	int type;
593 	int status = 0;
594 	struct inode *lqinode;
595 	unsigned int flags;
596 
597 	printk(KERN_NOTICE "ocfs2: Finishing quota recovery on device (%s) for "
598 	       "slot %u\n", osb->dev_str, slot_num);
599 
600 	down_read(&sb->s_umount);
601 	for (type = 0; type < OCFS2_MAXQUOTAS; type++) {
602 		if (list_empty(&(rec->r_list[type])))
603 			continue;
604 		trace_ocfs2_finish_quota_recovery(slot_num);
605 		lqinode = ocfs2_get_system_file_inode(osb, ino[type], slot_num);
606 		if (!lqinode) {
607 			status = -ENOENT;
608 			goto out;
609 		}
610 		status = ocfs2_inode_lock_full(lqinode, NULL, 1,
611 						       OCFS2_META_LOCK_NOQUEUE);
612 		/* Someone else is holding the lock? Then he must be
613 		 * doing the recovery. Just skip the file... */
614 		if (status == -EAGAIN) {
615 			printk(KERN_NOTICE "ocfs2: Skipping quota recovery on "
616 			       "device (%s) for slot %d because quota file is "
617 			       "locked.\n", osb->dev_str, slot_num);
618 			status = 0;
619 			goto out_put;
620 		} else if (status < 0) {
621 			mlog_errno(status);
622 			goto out_put;
623 		}
624 		/* Now read local header */
625 		bh = NULL;
626 		status = ocfs2_read_quota_block(lqinode, 0, &bh);
627 		if (status) {
628 			mlog_errno(status);
629 			mlog(ML_ERROR, "failed to read quota file info header "
630 				"(slot=%d type=%d)\n", slot_num, type);
631 			goto out_lock;
632 		}
633 		ldinfo = (struct ocfs2_local_disk_dqinfo *)(bh->b_data +
634 							OCFS2_LOCAL_INFO_OFF);
635 		/* Is recovery still needed? */
636 		flags = le32_to_cpu(ldinfo->dqi_flags);
637 		if (!(flags & OLQF_CLEAN))
638 			status = ocfs2_recover_local_quota_file(lqinode,
639 								type,
640 								rec);
641 		/* We don't want to mark file as clean when it is actually
642 		 * active */
643 		if (slot_num == osb->slot_num)
644 			goto out_bh;
645 		/* Mark quota file as clean if we are recovering quota file of
646 		 * some other node. */
647 		handle = ocfs2_start_trans(osb,
648 					   OCFS2_LOCAL_QINFO_WRITE_CREDITS);
649 		if (IS_ERR(handle)) {
650 			status = PTR_ERR(handle);
651 			mlog_errno(status);
652 			goto out_bh;
653 		}
654 		status = ocfs2_journal_access_dq(handle, INODE_CACHE(lqinode),
655 						 bh,
656 						 OCFS2_JOURNAL_ACCESS_WRITE);
657 		if (status < 0) {
658 			mlog_errno(status);
659 			goto out_trans;
660 		}
661 		lock_buffer(bh);
662 		ldinfo->dqi_flags = cpu_to_le32(flags | OLQF_CLEAN);
663 		unlock_buffer(bh);
664 		ocfs2_journal_dirty(handle, bh);
665 out_trans:
666 		ocfs2_commit_trans(osb, handle);
667 out_bh:
668 		brelse(bh);
669 out_lock:
670 		ocfs2_inode_unlock(lqinode, 1);
671 out_put:
672 		iput(lqinode);
673 		if (status < 0)
674 			break;
675 	}
676 out:
677 	up_read(&sb->s_umount);
678 	kfree(rec);
679 	return status;
680 }
681 
682 /* Read information header from quota file */
ocfs2_local_read_info(struct super_block * sb,int type)683 static int ocfs2_local_read_info(struct super_block *sb, int type)
684 {
685 	struct ocfs2_local_disk_dqinfo *ldinfo;
686 	struct mem_dqinfo *info = sb_dqinfo(sb, type);
687 	struct ocfs2_mem_dqinfo *oinfo;
688 	struct inode *lqinode = sb_dqopt(sb)->files[type];
689 	int status;
690 	struct buffer_head *bh = NULL;
691 	struct ocfs2_quota_recovery *rec;
692 	int locked = 0;
693 
694 	info->dqi_max_spc_limit = 0x7fffffffffffffffLL;
695 	info->dqi_max_ino_limit = 0x7fffffffffffffffLL;
696 	oinfo = kmalloc(sizeof(struct ocfs2_mem_dqinfo), GFP_NOFS);
697 	if (!oinfo) {
698 		mlog(ML_ERROR, "failed to allocate memory for ocfs2 quota"
699 			       " info.");
700 		goto out_err;
701 	}
702 	info->dqi_priv = oinfo;
703 	oinfo->dqi_type = type;
704 	INIT_LIST_HEAD(&oinfo->dqi_chunk);
705 	oinfo->dqi_rec = NULL;
706 	oinfo->dqi_lqi_bh = NULL;
707 	oinfo->dqi_libh = NULL;
708 
709 	status = ocfs2_global_read_info(sb, type);
710 	if (status < 0)
711 		goto out_err;
712 
713 	status = ocfs2_inode_lock(lqinode, &oinfo->dqi_lqi_bh, 1);
714 	if (status < 0) {
715 		mlog_errno(status);
716 		goto out_err;
717 	}
718 	locked = 1;
719 
720 	/* Now read local header */
721 	status = ocfs2_read_quota_block(lqinode, 0, &bh);
722 	if (status) {
723 		mlog_errno(status);
724 		mlog(ML_ERROR, "failed to read quota file info header "
725 			"(type=%d)\n", type);
726 		goto out_err;
727 	}
728 	ldinfo = (struct ocfs2_local_disk_dqinfo *)(bh->b_data +
729 						OCFS2_LOCAL_INFO_OFF);
730 	oinfo->dqi_flags = le32_to_cpu(ldinfo->dqi_flags);
731 	oinfo->dqi_chunks = le32_to_cpu(ldinfo->dqi_chunks);
732 	oinfo->dqi_blocks = le32_to_cpu(ldinfo->dqi_blocks);
733 	oinfo->dqi_libh = bh;
734 
735 	/* We crashed when using local quota file? */
736 	if (!(oinfo->dqi_flags & OLQF_CLEAN)) {
737 		rec = OCFS2_SB(sb)->quota_rec;
738 		if (!rec) {
739 			rec = ocfs2_alloc_quota_recovery();
740 			if (!rec) {
741 				status = -ENOMEM;
742 				mlog_errno(status);
743 				goto out_err;
744 			}
745 			OCFS2_SB(sb)->quota_rec = rec;
746 		}
747 
748 		status = ocfs2_recovery_load_quota(lqinode, ldinfo, type,
749                                                    &rec->r_list[type]);
750 		if (status < 0) {
751 			mlog_errno(status);
752 			goto out_err;
753 		}
754 	}
755 
756 	status = ocfs2_load_local_quota_bitmaps(lqinode,
757 						ldinfo,
758 						&oinfo->dqi_chunk);
759 	if (status < 0) {
760 		mlog_errno(status);
761 		goto out_err;
762 	}
763 
764 	/* Now mark quota file as used */
765 	oinfo->dqi_flags &= ~OLQF_CLEAN;
766 	status = ocfs2_modify_bh(lqinode, bh, olq_update_info, info);
767 	if (status < 0) {
768 		mlog_errno(status);
769 		goto out_err;
770 	}
771 
772 	return 0;
773 out_err:
774 	if (oinfo) {
775 		iput(oinfo->dqi_gqinode);
776 		ocfs2_simple_drop_lockres(OCFS2_SB(sb), &oinfo->dqi_gqlock);
777 		ocfs2_lock_res_free(&oinfo->dqi_gqlock);
778 		brelse(oinfo->dqi_lqi_bh);
779 		if (locked)
780 			ocfs2_inode_unlock(lqinode, 1);
781 		ocfs2_release_local_quota_bitmaps(&oinfo->dqi_chunk);
782 		kfree(oinfo);
783 	}
784 	brelse(bh);
785 	return -1;
786 }
787 
788 /* Write local info to quota file */
ocfs2_local_write_info(struct super_block * sb,int type)789 static int ocfs2_local_write_info(struct super_block *sb, int type)
790 {
791 	struct mem_dqinfo *info = sb_dqinfo(sb, type);
792 	struct buffer_head *bh = ((struct ocfs2_mem_dqinfo *)info->dqi_priv)
793 						->dqi_libh;
794 	int status;
795 
796 	status = ocfs2_modify_bh(sb_dqopt(sb)->files[type], bh, olq_update_info,
797 				 info);
798 	if (status < 0) {
799 		mlog_errno(status);
800 		return -1;
801 	}
802 
803 	return 0;
804 }
805 
806 /* Release info from memory */
ocfs2_local_free_info(struct super_block * sb,int type)807 static int ocfs2_local_free_info(struct super_block *sb, int type)
808 {
809 	struct mem_dqinfo *info = sb_dqinfo(sb, type);
810 	struct ocfs2_mem_dqinfo *oinfo = info->dqi_priv;
811 	struct ocfs2_quota_chunk *chunk;
812 	struct ocfs2_local_disk_chunk *dchunk;
813 	int mark_clean = 1, len;
814 	int status;
815 
816 	iput(oinfo->dqi_gqinode);
817 	ocfs2_simple_drop_lockres(OCFS2_SB(sb), &oinfo->dqi_gqlock);
818 	ocfs2_lock_res_free(&oinfo->dqi_gqlock);
819 	list_for_each_entry(chunk, &oinfo->dqi_chunk, qc_chunk) {
820 		dchunk = (struct ocfs2_local_disk_chunk *)
821 					(chunk->qc_headerbh->b_data);
822 		if (chunk->qc_num < oinfo->dqi_chunks - 1) {
823 			len = ol_chunk_entries(sb);
824 		} else {
825 			len = (oinfo->dqi_blocks -
826 			       ol_quota_chunk_block(sb, chunk->qc_num) - 1)
827 			      * ol_quota_entries_per_block(sb);
828 		}
829 		/* Not all entries free? Bug! */
830 		if (le32_to_cpu(dchunk->dqc_free) != len) {
831 			mlog(ML_ERROR, "releasing quota file with used "
832 					"entries (type=%d)\n", type);
833 			mark_clean = 0;
834 		}
835 	}
836 	ocfs2_release_local_quota_bitmaps(&oinfo->dqi_chunk);
837 
838 	/*
839 	 * s_umount held in exclusive mode protects us against racing with
840 	 * recovery thread...
841 	 */
842 	if (oinfo->dqi_rec) {
843 		ocfs2_free_quota_recovery(oinfo->dqi_rec);
844 		mark_clean = 0;
845 	}
846 
847 	if (!mark_clean)
848 		goto out;
849 
850 	/* Mark local file as clean */
851 	oinfo->dqi_flags |= OLQF_CLEAN;
852 	status = ocfs2_modify_bh(sb_dqopt(sb)->files[type],
853 				 oinfo->dqi_libh,
854 				 olq_update_info,
855 				 info);
856 	if (status < 0) {
857 		mlog_errno(status);
858 		goto out;
859 	}
860 
861 out:
862 	ocfs2_inode_unlock(sb_dqopt(sb)->files[type], 1);
863 	brelse(oinfo->dqi_libh);
864 	brelse(oinfo->dqi_lqi_bh);
865 	kfree(oinfo);
866 	return 0;
867 }
868 
olq_set_dquot(struct buffer_head * bh,void * private)869 static void olq_set_dquot(struct buffer_head *bh, void *private)
870 {
871 	struct ocfs2_dquot *od = private;
872 	struct ocfs2_local_disk_dqblk *dqblk;
873 	struct super_block *sb = od->dq_dquot.dq_sb;
874 
875 	dqblk = (struct ocfs2_local_disk_dqblk *)(bh->b_data
876 		+ ol_dqblk_block_offset(sb, od->dq_local_off));
877 
878 	dqblk->dqb_id = cpu_to_le64(from_kqid(&init_user_ns,
879 					      od->dq_dquot.dq_id));
880 	spin_lock(&od->dq_dquot.dq_dqb_lock);
881 	dqblk->dqb_spacemod = cpu_to_le64(od->dq_dquot.dq_dqb.dqb_curspace -
882 					  od->dq_origspace);
883 	dqblk->dqb_inodemod = cpu_to_le64(od->dq_dquot.dq_dqb.dqb_curinodes -
884 					  od->dq_originodes);
885 	spin_unlock(&od->dq_dquot.dq_dqb_lock);
886 	trace_olq_set_dquot(
887 		(unsigned long long)le64_to_cpu(dqblk->dqb_spacemod),
888 		(unsigned long long)le64_to_cpu(dqblk->dqb_inodemod),
889 		from_kqid(&init_user_ns, od->dq_dquot.dq_id));
890 }
891 
892 /* Write dquot to local quota file */
ocfs2_local_write_dquot(struct dquot * dquot)893 int ocfs2_local_write_dquot(struct dquot *dquot)
894 {
895 	struct super_block *sb = dquot->dq_sb;
896 	struct ocfs2_dquot *od = OCFS2_DQUOT(dquot);
897 	struct buffer_head *bh;
898 	struct inode *lqinode = sb_dqopt(sb)->files[dquot->dq_id.type];
899 	int status;
900 
901 	status = ocfs2_read_quota_phys_block(lqinode, od->dq_local_phys_blk,
902 					     &bh);
903 	if (status) {
904 		mlog_errno(status);
905 		goto out;
906 	}
907 	status = ocfs2_modify_bh(lqinode, bh, olq_set_dquot, od);
908 	if (status < 0) {
909 		mlog_errno(status);
910 		goto out;
911 	}
912 out:
913 	brelse(bh);
914 	return status;
915 }
916 
917 /* Find free entry in local quota file */
ocfs2_find_free_entry(struct super_block * sb,int type,int * offset)918 static struct ocfs2_quota_chunk *ocfs2_find_free_entry(struct super_block *sb,
919 						       int type,
920 						       int *offset)
921 {
922 	struct mem_dqinfo *info = sb_dqinfo(sb, type);
923 	struct ocfs2_mem_dqinfo *oinfo = info->dqi_priv;
924 	struct ocfs2_quota_chunk *chunk;
925 	struct ocfs2_local_disk_chunk *dchunk;
926 	int found = 0, len;
927 
928 	list_for_each_entry(chunk, &oinfo->dqi_chunk, qc_chunk) {
929 		dchunk = (struct ocfs2_local_disk_chunk *)
930 						chunk->qc_headerbh->b_data;
931 		if (le32_to_cpu(dchunk->dqc_free) > 0) {
932 			found = 1;
933 			break;
934 		}
935 	}
936 	if (!found)
937 		return NULL;
938 
939 	if (chunk->qc_num < oinfo->dqi_chunks - 1) {
940 		len = ol_chunk_entries(sb);
941 	} else {
942 		len = (oinfo->dqi_blocks -
943 		       ol_quota_chunk_block(sb, chunk->qc_num) - 1)
944 		      * ol_quota_entries_per_block(sb);
945 	}
946 
947 	found = ocfs2_find_next_zero_bit_unaligned(dchunk->dqc_bitmap, len, 0);
948 	/* We failed? */
949 	if (found == len) {
950 		mlog(ML_ERROR, "Did not find empty entry in chunk %d with %u"
951 		     " entries free (type=%d)\n", chunk->qc_num,
952 		     le32_to_cpu(dchunk->dqc_free), type);
953 		return ERR_PTR(-EIO);
954 	}
955 	*offset = found;
956 	return chunk;
957 }
958 
959 /* Add new chunk to the local quota file */
ocfs2_local_quota_add_chunk(struct super_block * sb,int type,int * offset)960 static struct ocfs2_quota_chunk *ocfs2_local_quota_add_chunk(
961 							struct super_block *sb,
962 							int type,
963 							int *offset)
964 {
965 	struct mem_dqinfo *info = sb_dqinfo(sb, type);
966 	struct ocfs2_mem_dqinfo *oinfo = info->dqi_priv;
967 	struct inode *lqinode = sb_dqopt(sb)->files[type];
968 	struct ocfs2_quota_chunk *chunk = NULL;
969 	struct ocfs2_local_disk_chunk *dchunk;
970 	int status;
971 	handle_t *handle;
972 	struct buffer_head *bh = NULL, *dbh = NULL;
973 	u64 p_blkno;
974 
975 	/* We are protected by dqio_sem so no locking needed */
976 	status = ocfs2_extend_no_holes(lqinode, NULL,
977 				       i_size_read(lqinode) + 2 * sb->s_blocksize,
978 				       i_size_read(lqinode));
979 	if (status < 0) {
980 		mlog_errno(status);
981 		goto out;
982 	}
983 	status = ocfs2_simple_size_update(lqinode, oinfo->dqi_lqi_bh,
984 					  i_size_read(lqinode) + 2 * sb->s_blocksize);
985 	if (status < 0) {
986 		mlog_errno(status);
987 		goto out;
988 	}
989 
990 	chunk = kmem_cache_alloc(ocfs2_qf_chunk_cachep, GFP_NOFS);
991 	if (!chunk) {
992 		status = -ENOMEM;
993 		mlog_errno(status);
994 		goto out;
995 	}
996 	/* Local quota info and two new blocks we initialize */
997 	handle = ocfs2_start_trans(OCFS2_SB(sb),
998 			OCFS2_LOCAL_QINFO_WRITE_CREDITS +
999 			2 * OCFS2_QUOTA_BLOCK_UPDATE_CREDITS);
1000 	if (IS_ERR(handle)) {
1001 		status = PTR_ERR(handle);
1002 		mlog_errno(status);
1003 		goto out;
1004 	}
1005 
1006 	/* Initialize chunk header */
1007 	status = ocfs2_extent_map_get_blocks(lqinode, oinfo->dqi_blocks,
1008 					     &p_blkno, NULL, NULL);
1009 	if (status < 0) {
1010 		mlog_errno(status);
1011 		goto out_trans;
1012 	}
1013 	bh = sb_getblk(sb, p_blkno);
1014 	if (!bh) {
1015 		status = -ENOMEM;
1016 		mlog_errno(status);
1017 		goto out_trans;
1018 	}
1019 	dchunk = (struct ocfs2_local_disk_chunk *)bh->b_data;
1020 	ocfs2_set_new_buffer_uptodate(INODE_CACHE(lqinode), bh);
1021 	status = ocfs2_journal_access_dq(handle, INODE_CACHE(lqinode), bh,
1022 					 OCFS2_JOURNAL_ACCESS_CREATE);
1023 	if (status < 0) {
1024 		mlog_errno(status);
1025 		goto out_trans;
1026 	}
1027 	lock_buffer(bh);
1028 	dchunk->dqc_free = cpu_to_le32(ol_quota_entries_per_block(sb));
1029 	memset(dchunk->dqc_bitmap, 0,
1030 	       sb->s_blocksize - sizeof(struct ocfs2_local_disk_chunk) -
1031 	       OCFS2_QBLK_RESERVED_SPACE);
1032 	unlock_buffer(bh);
1033 	ocfs2_journal_dirty(handle, bh);
1034 
1035 	/* Initialize new block with structures */
1036 	status = ocfs2_extent_map_get_blocks(lqinode, oinfo->dqi_blocks + 1,
1037 					     &p_blkno, NULL, NULL);
1038 	if (status < 0) {
1039 		mlog_errno(status);
1040 		goto out_trans;
1041 	}
1042 	dbh = sb_getblk(sb, p_blkno);
1043 	if (!dbh) {
1044 		status = -ENOMEM;
1045 		mlog_errno(status);
1046 		goto out_trans;
1047 	}
1048 	ocfs2_set_new_buffer_uptodate(INODE_CACHE(lqinode), dbh);
1049 	status = ocfs2_journal_access_dq(handle, INODE_CACHE(lqinode), dbh,
1050 					 OCFS2_JOURNAL_ACCESS_CREATE);
1051 	if (status < 0) {
1052 		mlog_errno(status);
1053 		goto out_trans;
1054 	}
1055 	lock_buffer(dbh);
1056 	memset(dbh->b_data, 0, sb->s_blocksize - OCFS2_QBLK_RESERVED_SPACE);
1057 	unlock_buffer(dbh);
1058 	ocfs2_journal_dirty(handle, dbh);
1059 
1060 	/* Update local quotafile info */
1061 	oinfo->dqi_blocks += 2;
1062 	oinfo->dqi_chunks++;
1063 	status = ocfs2_local_write_info(sb, type);
1064 	if (status < 0) {
1065 		mlog_errno(status);
1066 		goto out_trans;
1067 	}
1068 	status = ocfs2_commit_trans(OCFS2_SB(sb), handle);
1069 	if (status < 0) {
1070 		mlog_errno(status);
1071 		goto out;
1072 	}
1073 
1074 	list_add_tail(&chunk->qc_chunk, &oinfo->dqi_chunk);
1075 	chunk->qc_num = list_entry(chunk->qc_chunk.prev,
1076 				   struct ocfs2_quota_chunk,
1077 				   qc_chunk)->qc_num + 1;
1078 	chunk->qc_headerbh = bh;
1079 	*offset = 0;
1080 	return chunk;
1081 out_trans:
1082 	ocfs2_commit_trans(OCFS2_SB(sb), handle);
1083 out:
1084 	brelse(bh);
1085 	brelse(dbh);
1086 	kmem_cache_free(ocfs2_qf_chunk_cachep, chunk);
1087 	return ERR_PTR(status);
1088 }
1089 
1090 /* Find free entry in local quota file */
ocfs2_extend_local_quota_file(struct super_block * sb,int type,int * offset)1091 static struct ocfs2_quota_chunk *ocfs2_extend_local_quota_file(
1092 						       struct super_block *sb,
1093 						       int type,
1094 						       int *offset)
1095 {
1096 	struct mem_dqinfo *info = sb_dqinfo(sb, type);
1097 	struct ocfs2_mem_dqinfo *oinfo = info->dqi_priv;
1098 	struct ocfs2_quota_chunk *chunk;
1099 	struct inode *lqinode = sb_dqopt(sb)->files[type];
1100 	struct ocfs2_local_disk_chunk *dchunk;
1101 	int epb = ol_quota_entries_per_block(sb);
1102 	unsigned int chunk_blocks;
1103 	struct buffer_head *bh;
1104 	u64 p_blkno;
1105 	int status;
1106 	handle_t *handle;
1107 
1108 	if (list_empty(&oinfo->dqi_chunk))
1109 		return ocfs2_local_quota_add_chunk(sb, type, offset);
1110 	/* Is the last chunk full? */
1111 	chunk = list_entry(oinfo->dqi_chunk.prev,
1112 			struct ocfs2_quota_chunk, qc_chunk);
1113 	chunk_blocks = oinfo->dqi_blocks -
1114 			ol_quota_chunk_block(sb, chunk->qc_num) - 1;
1115 	if (ol_chunk_blocks(sb) == chunk_blocks)
1116 		return ocfs2_local_quota_add_chunk(sb, type, offset);
1117 
1118 	/* We are protected by dqio_sem so no locking needed */
1119 	status = ocfs2_extend_no_holes(lqinode, NULL,
1120 				       i_size_read(lqinode) + sb->s_blocksize,
1121 				       i_size_read(lqinode));
1122 	if (status < 0) {
1123 		mlog_errno(status);
1124 		goto out;
1125 	}
1126 	status = ocfs2_simple_size_update(lqinode, oinfo->dqi_lqi_bh,
1127 					  i_size_read(lqinode) + sb->s_blocksize);
1128 	if (status < 0) {
1129 		mlog_errno(status);
1130 		goto out;
1131 	}
1132 
1133 	/* Get buffer from the just added block */
1134 	status = ocfs2_extent_map_get_blocks(lqinode, oinfo->dqi_blocks,
1135 					     &p_blkno, NULL, NULL);
1136 	if (status < 0) {
1137 		mlog_errno(status);
1138 		goto out;
1139 	}
1140 	bh = sb_getblk(sb, p_blkno);
1141 	if (!bh) {
1142 		status = -ENOMEM;
1143 		mlog_errno(status);
1144 		goto out;
1145 	}
1146 	ocfs2_set_new_buffer_uptodate(INODE_CACHE(lqinode), bh);
1147 
1148 	/* Local quota info, chunk header and the new block we initialize */
1149 	handle = ocfs2_start_trans(OCFS2_SB(sb),
1150 			OCFS2_LOCAL_QINFO_WRITE_CREDITS +
1151 			2 * OCFS2_QUOTA_BLOCK_UPDATE_CREDITS);
1152 	if (IS_ERR(handle)) {
1153 		status = PTR_ERR(handle);
1154 		mlog_errno(status);
1155 		goto out;
1156 	}
1157 	/* Zero created block */
1158 	status = ocfs2_journal_access_dq(handle, INODE_CACHE(lqinode), bh,
1159 				 OCFS2_JOURNAL_ACCESS_CREATE);
1160 	if (status < 0) {
1161 		mlog_errno(status);
1162 		goto out_trans;
1163 	}
1164 	lock_buffer(bh);
1165 	memset(bh->b_data, 0, sb->s_blocksize);
1166 	unlock_buffer(bh);
1167 	ocfs2_journal_dirty(handle, bh);
1168 
1169 	/* Update chunk header */
1170 	status = ocfs2_journal_access_dq(handle, INODE_CACHE(lqinode),
1171 					 chunk->qc_headerbh,
1172 				 OCFS2_JOURNAL_ACCESS_WRITE);
1173 	if (status < 0) {
1174 		mlog_errno(status);
1175 		goto out_trans;
1176 	}
1177 
1178 	dchunk = (struct ocfs2_local_disk_chunk *)chunk->qc_headerbh->b_data;
1179 	lock_buffer(chunk->qc_headerbh);
1180 	le32_add_cpu(&dchunk->dqc_free, ol_quota_entries_per_block(sb));
1181 	unlock_buffer(chunk->qc_headerbh);
1182 	ocfs2_journal_dirty(handle, chunk->qc_headerbh);
1183 
1184 	/* Update file header */
1185 	oinfo->dqi_blocks++;
1186 	status = ocfs2_local_write_info(sb, type);
1187 	if (status < 0) {
1188 		mlog_errno(status);
1189 		goto out_trans;
1190 	}
1191 
1192 	status = ocfs2_commit_trans(OCFS2_SB(sb), handle);
1193 	if (status < 0) {
1194 		mlog_errno(status);
1195 		goto out;
1196 	}
1197 	*offset = chunk_blocks * epb;
1198 	return chunk;
1199 out_trans:
1200 	ocfs2_commit_trans(OCFS2_SB(sb), handle);
1201 out:
1202 	return ERR_PTR(status);
1203 }
1204 
olq_alloc_dquot(struct buffer_head * bh,void * private)1205 static void olq_alloc_dquot(struct buffer_head *bh, void *private)
1206 {
1207 	int *offset = private;
1208 	struct ocfs2_local_disk_chunk *dchunk;
1209 
1210 	dchunk = (struct ocfs2_local_disk_chunk *)bh->b_data;
1211 	ocfs2_set_bit_unaligned(*offset, dchunk->dqc_bitmap);
1212 	le32_add_cpu(&dchunk->dqc_free, -1);
1213 }
1214 
1215 /* Create dquot in the local file for given id */
ocfs2_create_local_dquot(struct dquot * dquot)1216 int ocfs2_create_local_dquot(struct dquot *dquot)
1217 {
1218 	struct super_block *sb = dquot->dq_sb;
1219 	int type = dquot->dq_id.type;
1220 	struct inode *lqinode = sb_dqopt(sb)->files[type];
1221 	struct ocfs2_quota_chunk *chunk;
1222 	struct ocfs2_dquot *od = OCFS2_DQUOT(dquot);
1223 	int offset;
1224 	int status;
1225 	u64 pcount;
1226 
1227 	down_write(&OCFS2_I(lqinode)->ip_alloc_sem);
1228 	chunk = ocfs2_find_free_entry(sb, type, &offset);
1229 	if (!chunk) {
1230 		chunk = ocfs2_extend_local_quota_file(sb, type, &offset);
1231 		if (IS_ERR(chunk)) {
1232 			status = PTR_ERR(chunk);
1233 			goto out;
1234 		}
1235 	} else if (IS_ERR(chunk)) {
1236 		status = PTR_ERR(chunk);
1237 		goto out;
1238 	}
1239 	od->dq_local_off = ol_dqblk_off(sb, chunk->qc_num, offset);
1240 	od->dq_chunk = chunk;
1241 	status = ocfs2_extent_map_get_blocks(lqinode,
1242 				     ol_dqblk_block(sb, chunk->qc_num, offset),
1243 				     &od->dq_local_phys_blk,
1244 				     &pcount,
1245 				     NULL);
1246 
1247 	/* Initialize dquot structure on disk */
1248 	status = ocfs2_local_write_dquot(dquot);
1249 	if (status < 0) {
1250 		mlog_errno(status);
1251 		goto out;
1252 	}
1253 
1254 	/* Mark structure as allocated */
1255 	status = ocfs2_modify_bh(lqinode, chunk->qc_headerbh, olq_alloc_dquot,
1256 				 &offset);
1257 	if (status < 0) {
1258 		mlog_errno(status);
1259 		goto out;
1260 	}
1261 out:
1262 	up_write(&OCFS2_I(lqinode)->ip_alloc_sem);
1263 	return status;
1264 }
1265 
1266 /*
1267  * Release dquot structure from local quota file. ocfs2_release_dquot() has
1268  * already started a transaction and written all changes to global quota file
1269  */
ocfs2_local_release_dquot(handle_t * handle,struct dquot * dquot)1270 int ocfs2_local_release_dquot(handle_t *handle, struct dquot *dquot)
1271 {
1272 	int status;
1273 	int type = dquot->dq_id.type;
1274 	struct ocfs2_dquot *od = OCFS2_DQUOT(dquot);
1275 	struct super_block *sb = dquot->dq_sb;
1276 	struct ocfs2_local_disk_chunk *dchunk;
1277 	int offset;
1278 
1279 	status = ocfs2_journal_access_dq(handle,
1280 			INODE_CACHE(sb_dqopt(sb)->files[type]),
1281 			od->dq_chunk->qc_headerbh, OCFS2_JOURNAL_ACCESS_WRITE);
1282 	if (status < 0) {
1283 		mlog_errno(status);
1284 		goto out;
1285 	}
1286 	offset = ol_dqblk_chunk_off(sb, od->dq_chunk->qc_num,
1287 					     od->dq_local_off);
1288 	dchunk = (struct ocfs2_local_disk_chunk *)
1289 			(od->dq_chunk->qc_headerbh->b_data);
1290 	/* Mark structure as freed */
1291 	lock_buffer(od->dq_chunk->qc_headerbh);
1292 	ocfs2_clear_bit_unaligned(offset, dchunk->dqc_bitmap);
1293 	le32_add_cpu(&dchunk->dqc_free, 1);
1294 	unlock_buffer(od->dq_chunk->qc_headerbh);
1295 	ocfs2_journal_dirty(handle, od->dq_chunk->qc_headerbh);
1296 
1297 out:
1298 	return status;
1299 }
1300 
1301 static const struct quota_format_ops ocfs2_format_ops = {
1302 	.check_quota_file	= ocfs2_local_check_quota_file,
1303 	.read_file_info		= ocfs2_local_read_info,
1304 	.write_file_info	= ocfs2_global_write_info,
1305 	.free_file_info		= ocfs2_local_free_info,
1306 };
1307 
1308 struct quota_format_type ocfs2_quota_format = {
1309 	.qf_fmt_id = QFMT_OCFS2,
1310 	.qf_ops = &ocfs2_format_ops,
1311 	.qf_owner = THIS_MODULE
1312 };
1313