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