quotaio.c revision 18a1444b4f1e6a0948fd38fa0de382d86cfe04de 
1/** quotaio.c
2 *
3 * Generic IO operations on quotafiles
4 * Jan Kara <jack@suse.cz> - sponsored by SuSE CR
5 * Aditya Kali <adityakali@google.com> - Ported to e2fsprogs
6 */
7
8#include <stdio.h>
9#include <errno.h>
10#include <string.h>
11#include <unistd.h>
12#include <stdlib.h>
13#include <time.h>
14#include <sys/types.h>
15#include <sys/stat.h>
16#include <sys/file.h>
17
18#include "common.h"
19#include "quotaio.h"
20
21static const char * const extensions[MAXQUOTAS] = {"user", "group"};
22static const char * const basenames[] = {
23	"",		/* undefined */
24	"quota",	/* QFMT_VFS_OLD */
25	"aquota",	/* QFMT_VFS_V0 */
26	"",		/* QFMT_OCFS2 */
27	"aquota"	/* QFMT_VFS_V1 */
28};
29
30/* Header in all newer quotafiles */
31struct disk_dqheader {
32	u_int32_t dqh_magic;
33	u_int32_t dqh_version;
34} __attribute__ ((packed));
35
36/**
37 * Convert type of quota to written representation
38 */
39const char *type2name(int type)
40{
41	return extensions[type];
42}
43
44/**
45 * Creates a quota file name for given type and format.
46 */
47const char *quota_get_qf_name(int type, int fmt, char *buf)
48{
49	if (!buf)
50		return NULL;
51	snprintf(buf, QUOTA_NAME_LEN, "%s.%s",
52		 basenames[fmt], extensions[type]);
53
54	return buf;
55}
56
57const char *quota_get_qf_path(const char *mntpt, int qtype, int fmt,
58			      char *path_buf, size_t path_buf_size)
59{
60	char qf_name[QUOTA_NAME_LEN];
61
62	if (!mntpt || !path_buf || !path_buf_size)
63		return NULL;
64
65	strncpy(path_buf, mntpt, path_buf_size);
66	strncat(path_buf, "/", 1);
67	strncat(path_buf, quota_get_qf_name(qtype, fmt, qf_name),
68		path_buf_size - strlen(path_buf));
69
70	return path_buf;
71}
72
73/*
74 * Set grace time if needed
75 */
76void update_grace_times(struct dquot *q)
77{
78	time_t now;
79
80	time(&now);
81	if (q->dq_dqb.dqb_bsoftlimit && toqb(q->dq_dqb.dqb_curspace) >
82			q->dq_dqb.dqb_bsoftlimit) {
83		if (!q->dq_dqb.dqb_btime)
84			q->dq_dqb.dqb_btime =
85				now + q->dq_h->qh_info.dqi_bgrace;
86	} else {
87		q->dq_dqb.dqb_btime = 0;
88	}
89
90	if (q->dq_dqb.dqb_isoftlimit && q->dq_dqb.dqb_curinodes >
91			q->dq_dqb.dqb_isoftlimit) {
92		if (!q->dq_dqb.dqb_itime)
93				q->dq_dqb.dqb_itime =
94					now + q->dq_h->qh_info.dqi_igrace;
95	} else {
96		q->dq_dqb.dqb_itime = 0;
97	}
98}
99
100static int compute_num_blocks_proc(ext2_filsys fs, blk64_t *blocknr,
101			       e2_blkcnt_t blockcnt EXT2FS_ATTR((unused)),
102			       blk64_t ref_block EXT2FS_ATTR((unused)),
103			       int ref_offset EXT2FS_ATTR((unused)),
104			       void *private)
105{
106	blk64_t *num_blocks = private;
107
108	*num_blocks += 1;
109	return 0;
110}
111
112errcode_t quota_inode_truncate(ext2_filsys fs, ext2_ino_t ino)
113{
114	struct ext2_inode inode;
115	errcode_t err;
116
117	if ((err = ext2fs_read_inode(fs, ino, &inode)))
118		return err;
119
120	if ((ino == EXT4_USR_QUOTA_INO) || (ino == EXT4_GRP_QUOTA_INO)) {
121		inode.i_dtime = fs->now ? fs->now : time(0);
122		if (!ext2fs_inode_has_valid_blocks2(fs, &inode))
123			return 0;
124		err = ext2fs_punch(fs, ino, &inode, NULL, 0, ~0ULL);
125		if (err)
126			return err;
127		fs->flags &= ~EXT2_FLAG_SUPER_ONLY;
128		memset(&inode, 0, sizeof(struct ext2_inode));
129	} else {
130		inode.i_flags &= ~EXT2_IMMUTABLE_FL;
131	}
132	err = ext2fs_write_inode(fs, ino, &inode);
133	return err;
134}
135
136static ext2_off64_t compute_inode_size(ext2_filsys fs, ext2_ino_t ino)
137{
138	blk64_t num_blocks = 0;
139
140	ext2fs_block_iterate3(fs, ino,
141			      BLOCK_FLAG_READ_ONLY,
142			      NULL,
143			      compute_num_blocks_proc,
144			      &num_blocks);
145	return num_blocks * fs->blocksize;
146}
147
148/* Functions to read/write quota file. */
149static unsigned int quota_write_nomount(struct quota_file *qf,
150					ext2_loff_t offset,
151					void *buf, unsigned int size)
152{
153	ext2_file_t	e2_file = qf->e2_file;
154	unsigned int	bytes_written = 0;
155	errcode_t	err;
156
157	err = ext2fs_file_llseek(e2_file, offset, EXT2_SEEK_SET, NULL);
158	if (err) {
159		log_err("ext2fs_file_llseek failed: %ld", err);
160		return 0;
161	}
162
163	err = ext2fs_file_write(e2_file, buf, size, &bytes_written);
164	if (err) {
165		log_err("ext2fs_file_write failed: %ld", err);
166		return 0;
167	}
168
169	/* Correct inode.i_size is set in end_io. */
170	return bytes_written;
171}
172
173static unsigned int quota_read_nomount(struct quota_file *qf,
174				       ext2_loff_t offset,
175				       void *buf, unsigned int size)
176{
177	ext2_file_t	e2_file = qf->e2_file;
178	unsigned int	bytes_read = 0;
179	errcode_t	err;
180
181	err = ext2fs_file_llseek(e2_file, offset, EXT2_SEEK_SET, NULL);
182	if (err) {
183		log_err("ext2fs_file_llseek failed: %ld", err);
184		return 0;
185	}
186
187	err = ext2fs_file_read(e2_file, buf, size, &bytes_read);
188	if (err) {
189		log_err("ext2fs_file_read failed: %ld", err);
190		return 0;
191	}
192
193	return bytes_read;
194}
195
196/*
197 * Detect quota format and initialize quota IO
198 */
199errcode_t quota_file_open(struct quota_handle *h, ext2_filsys fs,
200			  ext2_ino_t qf_ino, int type, int fmt, int flags)
201{
202	ext2_file_t e2_file;
203	errcode_t err;
204
205	if (fmt == -1)
206		fmt = QFMT_VFS_V1;
207
208	err = ext2fs_read_bitmaps(fs);
209	if (err)
210		return err;
211
212	log_debug("Opening quota ino=%lu, type=%d", qf_ino, type);
213	err = ext2fs_file_open(fs, qf_ino, flags, &e2_file);
214	if (err) {
215		log_err("ext2fs_file_open failed: %s", error_message(err));
216		return err;
217	}
218	h->qh_qf.e2_file = e2_file;
219
220	h->qh_qf.fs = fs;
221	h->qh_qf.ino = qf_ino;
222	h->e2fs_write = quota_write_nomount;
223	h->e2fs_read = quota_read_nomount;
224	h->qh_io_flags = 0;
225	h->qh_type = type;
226	h->qh_fmt = fmt;
227	memset(&h->qh_info, 0, sizeof(h->qh_info));
228	h->qh_ops = &quotafile_ops_2;
229
230	if (h->qh_ops->check_file &&
231	    (h->qh_ops->check_file(h, type, fmt) == 0)) {
232		log_err("qh_ops->check_file failed");
233		ext2fs_file_close(e2_file);
234		return -1;
235	}
236
237	if (h->qh_ops->init_io && (h->qh_ops->init_io(h) < 0)) {
238		log_err("qh_ops->init_io failed");
239		ext2fs_file_close(e2_file);
240		return -1;
241	}
242
243	return 0;
244}
245
246static errcode_t quota_inode_init_new(ext2_filsys fs, ext2_ino_t ino)
247{
248	struct ext2_inode inode;
249	errcode_t err = 0;
250
251	err = ext2fs_read_inode(fs, ino, &inode);
252	if (err) {
253		log_err("ex2fs_read_inode failed");
254		return err;
255	}
256
257	if (EXT2_I_SIZE(&inode))
258		quota_inode_truncate(fs, ino);
259
260	memset(&inode, 0, sizeof(struct ext2_inode));
261	ext2fs_iblk_set(fs, &inode, 0);
262	inode.i_atime = inode.i_mtime =
263		inode.i_ctime = fs->now ? fs->now : time(0);
264	inode.i_links_count = 1;
265	inode.i_mode = LINUX_S_IFREG | 0600;
266	inode.i_flags |= EXT2_IMMUTABLE_FL;
267	if (fs->super->s_feature_incompat &
268			EXT3_FEATURE_INCOMPAT_EXTENTS)
269		inode.i_flags |= EXT4_EXTENTS_FL;
270
271	err = ext2fs_write_new_inode(fs, ino, &inode);
272	if (err) {
273		log_err("ext2fs_write_new_inode failed: %ld", err);
274		return err;
275	}
276	return err;
277}
278
279/*
280 * Create new quotafile of specified format on given filesystem
281 */
282errcode_t quota_file_create(struct quota_handle *h, ext2_filsys fs, int type, int fmt)
283{
284	ext2_file_t e2_file;
285	int err;
286	unsigned long qf_inum;
287
288	if (fmt == -1)
289		fmt = QFMT_VFS_V1;
290
291	h->qh_qf.fs = fs;
292	if (type == USRQUOTA)
293		qf_inum = EXT4_USR_QUOTA_INO;
294	else if (type == GRPQUOTA)
295		qf_inum = EXT4_GRP_QUOTA_INO;
296	else
297		return -1;
298
299	err = ext2fs_read_bitmaps(fs);
300	if (err)
301		goto out_err;
302
303	err = quota_inode_init_new(fs, qf_inum);
304	if (err) {
305		log_err("init_new_quota_inode failed");
306		goto out_err;
307	}
308	h->qh_qf.ino = qf_inum;
309	h->e2fs_write = quota_write_nomount;
310	h->e2fs_read = quota_read_nomount;
311
312	log_debug("Creating quota ino=%lu, type=%d", qf_inum, type);
313	err = ext2fs_file_open(fs, qf_inum,
314			EXT2_FILE_WRITE | EXT2_FILE_CREATE, &e2_file);
315	if (err) {
316		log_err("ext2fs_file_open failed: %d", err);
317		goto out_err;
318	}
319	h->qh_qf.e2_file = e2_file;
320
321	h->qh_io_flags = 0;
322	h->qh_type = type;
323	h->qh_fmt = fmt;
324	memset(&h->qh_info, 0, sizeof(h->qh_info));
325	h->qh_ops = &quotafile_ops_2;
326
327	if (h->qh_ops->new_io && (h->qh_ops->new_io(h) < 0)) {
328		log_err("qh_ops->new_io failed");
329		goto out_err1;
330	}
331
332	return 0;
333
334out_err1:
335	ext2fs_file_close(e2_file);
336out_err:
337
338	if (qf_inum)
339		quota_inode_truncate(fs, qf_inum);
340
341	return -1;
342}
343
344/*
345 * Close quotafile and release handle
346 */
347errcode_t quota_file_close(struct quota_handle *h)
348{
349	if (h->qh_io_flags & IOFL_INFODIRTY) {
350		if (h->qh_ops->write_info && h->qh_ops->write_info(h) < 0)
351			return -1;
352		h->qh_io_flags &= ~IOFL_INFODIRTY;
353	}
354
355	if (h->qh_ops->end_io && h->qh_ops->end_io(h) < 0)
356		return -1;
357	if (h->qh_qf.e2_file) {
358		ext2fs_file_flush(h->qh_qf.e2_file);
359		ext2fs_file_set_size2(h->qh_qf.e2_file,
360			compute_inode_size(h->qh_qf.fs, h->qh_qf.ino));
361		ext2fs_file_close(h->qh_qf.e2_file);
362	}
363
364	return 0;
365}
366
367/*
368 * Create empty quota structure
369 */
370struct dquot *get_empty_dquot(void)
371{
372	struct dquot *dquot;
373
374	if (ext2fs_get_memzero(sizeof(struct dquot), &dquot)) {
375		log_err("Failed to allocate dquot");
376		return NULL;
377	}
378
379	dquot->dq_id = -1;
380	return dquot;
381}
382