Aditya Kali | f239fef | 2011-07-20 11:40:02 -0700 | [diff] [blame] | 1 | /* |
| 2 | * mkquota.c --- create quota files for a filesystem |
| 3 | * |
| 4 | * Aditya Kali <adityakali@google.com> |
| 5 | */ |
Theodore Ts'o | d1154eb | 2011-09-18 17:34:37 -0400 | [diff] [blame] | 6 | #include "config.h" |
Aditya Kali | f239fef | 2011-07-20 11:40:02 -0700 | [diff] [blame] | 7 | #include <sys/types.h> |
| 8 | #include <sys/stat.h> |
| 9 | #include <unistd.h> |
| 10 | #include <errno.h> |
| 11 | #include <string.h> |
| 12 | #include <fcntl.h> |
| 13 | |
| 14 | #include "ext2fs/ext2_fs.h" |
| 15 | #include "ext2fs/ext2fs.h" |
| 16 | #include "e2p/e2p.h" |
| 17 | |
Aditya Kali | f239fef | 2011-07-20 11:40:02 -0700 | [diff] [blame] | 18 | #include "quotaio.h" |
| 19 | #include "quotaio_v2.h" |
| 20 | #include "quotaio_tree.h" |
| 21 | #include "mkquota.h" |
| 22 | #include "common.h" |
| 23 | |
| 24 | /* Needed for architectures where sizeof(int) != sizeof(void *) */ |
| 25 | #define UINT_TO_VOIDPTR(val) ((void *)(intptr_t)(val)) |
| 26 | #define VOIDPTR_TO_UINT(ptr) ((unsigned int)(intptr_t)(ptr)) |
| 27 | |
Andreas Dilger | 00eb0ee | 2012-11-29 05:47:53 -0700 | [diff] [blame] | 28 | #if DEBUG_QUOTA |
Aditya Kali | f239fef | 2011-07-20 11:40:02 -0700 | [diff] [blame] | 29 | static void print_inode(struct ext2_inode *inode) |
| 30 | { |
| 31 | if (!inode) |
| 32 | return; |
| 33 | |
| 34 | fprintf(stderr, " i_mode = %d\n", inode->i_mode); |
| 35 | fprintf(stderr, " i_uid = %d\n", inode->i_uid); |
| 36 | fprintf(stderr, " i_size = %d\n", inode->i_size); |
| 37 | fprintf(stderr, " i_atime = %d\n", inode->i_atime); |
| 38 | fprintf(stderr, " i_ctime = %d\n", inode->i_ctime); |
| 39 | fprintf(stderr, " i_mtime = %d\n", inode->i_mtime); |
| 40 | fprintf(stderr, " i_dtime = %d\n", inode->i_dtime); |
| 41 | fprintf(stderr, " i_gid = %d\n", inode->i_gid); |
| 42 | fprintf(stderr, " i_links_count = %d\n", inode->i_links_count); |
| 43 | fprintf(stderr, " i_blocks = %d\n", inode->i_blocks); |
| 44 | fprintf(stderr, " i_flags = %d\n", inode->i_flags); |
| 45 | |
| 46 | return; |
| 47 | } |
Andreas Dilger | 00eb0ee | 2012-11-29 05:47:53 -0700 | [diff] [blame] | 48 | #endif |
Aditya Kali | f239fef | 2011-07-20 11:40:02 -0700 | [diff] [blame] | 49 | |
Aditya Kali | f239fef | 2011-07-20 11:40:02 -0700 | [diff] [blame] | 50 | /* |
| 51 | * Returns 0 if not able to find the quota file, otherwise returns its |
| 52 | * inode number. |
| 53 | */ |
Aditya Kali | a86d55d | 2011-11-14 10:55:54 -0500 | [diff] [blame] | 54 | int quota_file_exists(ext2_filsys fs, int qtype, int fmt) |
Aditya Kali | f239fef | 2011-07-20 11:40:02 -0700 | [diff] [blame] | 55 | { |
| 56 | char qf_name[256]; |
| 57 | errcode_t ret; |
| 58 | ext2_ino_t ino; |
| 59 | |
Theodore Ts'o | 36e4e21 | 2011-10-04 11:38:47 -0400 | [diff] [blame] | 60 | if (qtype >= MAXQUOTAS) |
Aditya Kali | f239fef | 2011-07-20 11:40:02 -0700 | [diff] [blame] | 61 | return -EINVAL; |
| 62 | |
Jan Kara | 2ae58b6 | 2012-06-04 12:51:55 -0400 | [diff] [blame] | 63 | quota_get_qf_name(qtype, QFMT_VFS_V1, qf_name); |
Aditya Kali | f239fef | 2011-07-20 11:40:02 -0700 | [diff] [blame] | 64 | |
| 65 | ret = ext2fs_lookup(fs, EXT2_ROOT_INO, qf_name, strlen(qf_name), 0, |
| 66 | &ino); |
| 67 | if (ret) |
| 68 | return 0; |
| 69 | |
| 70 | return ino; |
| 71 | } |
| 72 | |
| 73 | /* |
| 74 | * Set the value for reserved quota inode number field in superblock. |
| 75 | */ |
Aditya Kali | a86d55d | 2011-11-14 10:55:54 -0500 | [diff] [blame] | 76 | void quota_set_sb_inum(ext2_filsys fs, ext2_ino_t ino, int qtype) |
Aditya Kali | f239fef | 2011-07-20 11:40:02 -0700 | [diff] [blame] | 77 | { |
| 78 | ext2_ino_t *inump; |
| 79 | |
| 80 | inump = (qtype == USRQUOTA) ? &fs->super->s_usr_quota_inum : |
| 81 | &fs->super->s_grp_quota_inum; |
| 82 | |
| 83 | log_debug("setting quota ino in superblock: ino=%u, type=%d", ino, |
| 84 | qtype); |
| 85 | *inump = ino; |
| 86 | ext2fs_mark_super_dirty(fs); |
| 87 | } |
| 88 | |
Aditya Kali | a86d55d | 2011-11-14 10:55:54 -0500 | [diff] [blame] | 89 | errcode_t quota_remove_inode(ext2_filsys fs, int qtype) |
Aditya Kali | f239fef | 2011-07-20 11:40:02 -0700 | [diff] [blame] | 90 | { |
| 91 | ext2_ino_t qf_ino; |
| 92 | |
| 93 | ext2fs_read_bitmaps(fs); |
| 94 | qf_ino = (qtype == USRQUOTA) ? fs->super->s_usr_quota_inum : |
| 95 | fs->super->s_grp_quota_inum; |
Aditya Kali | a86d55d | 2011-11-14 10:55:54 -0500 | [diff] [blame] | 96 | quota_set_sb_inum(fs, 0, qtype); |
Aditya Kali | f239fef | 2011-07-20 11:40:02 -0700 | [diff] [blame] | 97 | /* Truncate the inode only if its a reserved one. */ |
| 98 | if (qf_ino < EXT2_FIRST_INODE(fs->super)) |
Aditya Kali | a86d55d | 2011-11-14 10:55:54 -0500 | [diff] [blame] | 99 | quota_inode_truncate(fs, qf_ino); |
Aditya Kali | f239fef | 2011-07-20 11:40:02 -0700 | [diff] [blame] | 100 | |
| 101 | ext2fs_mark_super_dirty(fs); |
| 102 | ext2fs_write_bitmaps(fs); |
| 103 | return 0; |
| 104 | } |
| 105 | |
| 106 | static void write_dquots(dict_t *dict, struct quota_handle *qh) |
| 107 | { |
Aditya Kali | f239fef | 2011-07-20 11:40:02 -0700 | [diff] [blame] | 108 | dnode_t *n; |
| 109 | struct dquot *dq; |
Aditya Kali | f239fef | 2011-07-20 11:40:02 -0700 | [diff] [blame] | 110 | |
| 111 | for (n = dict_first(dict); n; n = dict_next(dict, n)) { |
| 112 | dq = dnode_get(n); |
| 113 | if (dq) { |
| 114 | dq->dq_h = qh; |
| 115 | update_grace_times(dq); |
Theodore Ts'o | b5ba6f5 | 2011-10-05 13:26:59 -0400 | [diff] [blame] | 116 | qh->qh_ops->commit_dquot(dq); |
Aditya Kali | f239fef | 2011-07-20 11:40:02 -0700 | [diff] [blame] | 117 | } |
| 118 | } |
| 119 | } |
| 120 | |
Aditya Kali | a86d55d | 2011-11-14 10:55:54 -0500 | [diff] [blame] | 121 | errcode_t quota_write_inode(quota_ctx_t qctx, int qtype) |
Aditya Kali | f239fef | 2011-07-20 11:40:02 -0700 | [diff] [blame] | 122 | { |
Theodore Ts'o | edbfd75 | 2011-10-04 11:20:50 -0400 | [diff] [blame] | 123 | int retval = 0, i; |
Aditya Kali | f239fef | 2011-07-20 11:40:02 -0700 | [diff] [blame] | 124 | dict_t *dict; |
| 125 | ext2_filsys fs; |
Andreas Dilger | 00eb0ee | 2012-11-29 05:47:53 -0700 | [diff] [blame] | 126 | struct quota_handle *h = NULL; |
Aditya Kali | f239fef | 2011-07-20 11:40:02 -0700 | [diff] [blame] | 127 | int fmt = QFMT_VFS_V1; |
| 128 | |
| 129 | if (!qctx) |
Theodore Ts'o | edbfd75 | 2011-10-04 11:20:50 -0400 | [diff] [blame] | 130 | return 0; |
Aditya Kali | f239fef | 2011-07-20 11:40:02 -0700 | [diff] [blame] | 131 | |
| 132 | fs = qctx->fs; |
Aditya Kali | a86d55d | 2011-11-14 10:55:54 -0500 | [diff] [blame] | 133 | retval = ext2fs_get_mem(sizeof(struct quota_handle), &h); |
| 134 | if (retval) { |
Andreas Dilger | 0ce0172 | 2012-11-29 05:47:54 -0700 | [diff] [blame] | 135 | log_err("Unable to allocate quota handle"); |
Aditya Kali | a86d55d | 2011-11-14 10:55:54 -0500 | [diff] [blame] | 136 | goto out; |
| 137 | } |
| 138 | |
Aditya Kali | f239fef | 2011-07-20 11:40:02 -0700 | [diff] [blame] | 139 | ext2fs_read_bitmaps(fs); |
| 140 | |
| 141 | for (i = 0; i < MAXQUOTAS; i++) { |
| 142 | if ((qtype != -1) && (i != qtype)) |
| 143 | continue; |
| 144 | |
| 145 | dict = qctx->quota_dict[i]; |
| 146 | if (!dict) |
| 147 | continue; |
| 148 | |
Aditya Kali | a86d55d | 2011-11-14 10:55:54 -0500 | [diff] [blame] | 149 | retval = quota_file_create(h, fs, i, fmt); |
Aditya Kali | f239fef | 2011-07-20 11:40:02 -0700 | [diff] [blame] | 150 | if (retval < 0) { |
Andreas Dilger | 0ce0172 | 2012-11-29 05:47:54 -0700 | [diff] [blame] | 151 | log_err("Cannot initialize io on quotafile"); |
Aditya Kali | f239fef | 2011-07-20 11:40:02 -0700 | [diff] [blame] | 152 | continue; |
| 153 | } |
| 154 | |
| 155 | write_dquots(dict, h); |
Aditya Kali | a86d55d | 2011-11-14 10:55:54 -0500 | [diff] [blame] | 156 | retval = quota_file_close(h); |
Aditya Kali | f239fef | 2011-07-20 11:40:02 -0700 | [diff] [blame] | 157 | if (retval < 0) { |
| 158 | log_err("Cannot finish IO on new quotafile: %s", |
| 159 | strerror(errno)); |
| 160 | if (h->qh_qf.e2_file) |
| 161 | ext2fs_file_close(h->qh_qf.e2_file); |
Aditya Kali | a86d55d | 2011-11-14 10:55:54 -0500 | [diff] [blame] | 162 | quota_inode_truncate(fs, h->qh_qf.ino); |
Aditya Kali | f239fef | 2011-07-20 11:40:02 -0700 | [diff] [blame] | 163 | continue; |
| 164 | } |
| 165 | |
| 166 | /* Set quota inode numbers in superblock. */ |
Aditya Kali | a86d55d | 2011-11-14 10:55:54 -0500 | [diff] [blame] | 167 | quota_set_sb_inum(fs, h->qh_qf.ino, i); |
Aditya Kali | f239fef | 2011-07-20 11:40:02 -0700 | [diff] [blame] | 168 | ext2fs_mark_super_dirty(fs); |
| 169 | ext2fs_mark_bb_dirty(fs); |
| 170 | fs->flags &= ~EXT2_FLAG_SUPER_ONLY; |
| 171 | } |
| 172 | |
| 173 | ext2fs_write_bitmaps(fs); |
Aditya Kali | a86d55d | 2011-11-14 10:55:54 -0500 | [diff] [blame] | 174 | out: |
| 175 | if (h) |
| 176 | ext2fs_free_mem(&h); |
Aditya Kali | f239fef | 2011-07-20 11:40:02 -0700 | [diff] [blame] | 177 | return retval; |
| 178 | } |
| 179 | |
| 180 | /******************************************************************/ |
| 181 | /* Helper functions for computing quota in memory. */ |
| 182 | /******************************************************************/ |
| 183 | |
| 184 | static int dict_uint_cmp(const void *a, const void *b) |
| 185 | { |
| 186 | unsigned int c, d; |
| 187 | |
| 188 | c = VOIDPTR_TO_UINT(a); |
| 189 | d = VOIDPTR_TO_UINT(b); |
| 190 | |
| 191 | return c - d; |
| 192 | } |
| 193 | |
Aditya Kali | a86d55d | 2011-11-14 10:55:54 -0500 | [diff] [blame] | 194 | static inline qid_t get_qid(struct ext2_inode *inode, int qtype) |
Aditya Kali | f239fef | 2011-07-20 11:40:02 -0700 | [diff] [blame] | 195 | { |
Aditya Kali | a86d55d | 2011-11-14 10:55:54 -0500 | [diff] [blame] | 196 | if (qtype == USRQUOTA) |
Aditya Kali | f239fef | 2011-07-20 11:40:02 -0700 | [diff] [blame] | 197 | return inode_uid(*inode); |
Aditya Kali | a86d55d | 2011-11-14 10:55:54 -0500 | [diff] [blame] | 198 | return inode_gid(*inode); |
Aditya Kali | f239fef | 2011-07-20 11:40:02 -0700 | [diff] [blame] | 199 | } |
| 200 | |
| 201 | static void quota_dnode_free(dnode_t *node, |
| 202 | void *context EXT2FS_ATTR((unused))) |
| 203 | { |
| 204 | void *ptr = node ? dnode_get(node) : 0; |
| 205 | |
Aditya Kali | a86d55d | 2011-11-14 10:55:54 -0500 | [diff] [blame] | 206 | ext2fs_free_mem(&ptr); |
Aditya Kali | f239fef | 2011-07-20 11:40:02 -0700 | [diff] [blame] | 207 | free(node); |
| 208 | } |
| 209 | |
| 210 | /* |
Aditya Kali | a86d55d | 2011-11-14 10:55:54 -0500 | [diff] [blame] | 211 | * Set up the quota tracking data structures. |
Aditya Kali | f239fef | 2011-07-20 11:40:02 -0700 | [diff] [blame] | 212 | */ |
Aditya Kali | a86d55d | 2011-11-14 10:55:54 -0500 | [diff] [blame] | 213 | errcode_t quota_init_context(quota_ctx_t *qctx, ext2_filsys fs, int qtype) |
Aditya Kali | f239fef | 2011-07-20 11:40:02 -0700 | [diff] [blame] | 214 | { |
Aditya Kali | a86d55d | 2011-11-14 10:55:54 -0500 | [diff] [blame] | 215 | int i, err = 0; |
Aditya Kali | f239fef | 2011-07-20 11:40:02 -0700 | [diff] [blame] | 216 | dict_t *dict; |
| 217 | quota_ctx_t ctx; |
| 218 | |
Aditya Kali | a86d55d | 2011-11-14 10:55:54 -0500 | [diff] [blame] | 219 | err = ext2fs_get_mem(sizeof(struct quota_ctx), &ctx); |
| 220 | if (err) { |
Andreas Dilger | 0ce0172 | 2012-11-29 05:47:54 -0700 | [diff] [blame] | 221 | log_err("Failed to allocate quota context"); |
Aditya Kali | a86d55d | 2011-11-14 10:55:54 -0500 | [diff] [blame] | 222 | return err; |
| 223 | } |
| 224 | |
Aditya Kali | f239fef | 2011-07-20 11:40:02 -0700 | [diff] [blame] | 225 | memset(ctx, 0, sizeof(struct quota_ctx)); |
| 226 | for (i = 0; i < MAXQUOTAS; i++) { |
| 227 | if ((qtype != -1) && (i != qtype)) |
| 228 | continue; |
Aditya Kali | a86d55d | 2011-11-14 10:55:54 -0500 | [diff] [blame] | 229 | err = ext2fs_get_mem(sizeof(dict_t), &dict); |
| 230 | if (err) { |
Andreas Dilger | 0ce0172 | 2012-11-29 05:47:54 -0700 | [diff] [blame] | 231 | log_err("Failed to allocate dictionary"); |
Aditya Kali | a86d55d | 2011-11-14 10:55:54 -0500 | [diff] [blame] | 232 | return err; |
| 233 | } |
Aditya Kali | f239fef | 2011-07-20 11:40:02 -0700 | [diff] [blame] | 234 | ctx->quota_dict[i] = dict; |
| 235 | dict_init(dict, DICTCOUNT_T_MAX, dict_uint_cmp); |
| 236 | dict_set_allocator(dict, NULL, quota_dnode_free, NULL); |
| 237 | } |
| 238 | |
| 239 | ctx->fs = fs; |
| 240 | *qctx = ctx; |
Aditya Kali | a86d55d | 2011-11-14 10:55:54 -0500 | [diff] [blame] | 241 | return 0; |
Aditya Kali | f239fef | 2011-07-20 11:40:02 -0700 | [diff] [blame] | 242 | } |
| 243 | |
Aditya Kali | a86d55d | 2011-11-14 10:55:54 -0500 | [diff] [blame] | 244 | void quota_release_context(quota_ctx_t *qctx) |
Aditya Kali | f239fef | 2011-07-20 11:40:02 -0700 | [diff] [blame] | 245 | { |
| 246 | dict_t *dict; |
| 247 | int i; |
| 248 | quota_ctx_t ctx; |
| 249 | |
| 250 | if (!qctx) |
| 251 | return; |
| 252 | |
| 253 | ctx = *qctx; |
| 254 | for (i = 0; i < MAXQUOTAS; i++) { |
| 255 | dict = ctx->quota_dict[i]; |
| 256 | ctx->quota_dict[i] = 0; |
| 257 | if (dict) { |
| 258 | dict_free_nodes(dict); |
| 259 | free(dict); |
| 260 | } |
| 261 | } |
| 262 | *qctx = NULL; |
| 263 | free(ctx); |
| 264 | } |
| 265 | |
| 266 | static struct dquot *get_dq(dict_t *dict, __u32 key) |
| 267 | { |
| 268 | struct dquot *dq; |
| 269 | dnode_t *n; |
| 270 | |
| 271 | n = dict_lookup(dict, UINT_TO_VOIDPTR(key)); |
| 272 | if (n) |
| 273 | dq = dnode_get(n); |
| 274 | else { |
Aditya Kali | a86d55d | 2011-11-14 10:55:54 -0500 | [diff] [blame] | 275 | if (ext2fs_get_mem(sizeof(struct dquot), &dq)) { |
Andreas Dilger | 0ce0172 | 2012-11-29 05:47:54 -0700 | [diff] [blame] | 276 | log_err("Unable to allocate dquot"); |
Aditya Kali | a86d55d | 2011-11-14 10:55:54 -0500 | [diff] [blame] | 277 | return NULL; |
| 278 | } |
Aditya Kali | f239fef | 2011-07-20 11:40:02 -0700 | [diff] [blame] | 279 | memset(dq, 0, sizeof(struct dquot)); |
| 280 | dict_alloc_insert(dict, UINT_TO_VOIDPTR(key), dq); |
Niu Yawei | 1527d99 | 2011-11-14 11:36:12 -0500 | [diff] [blame] | 281 | dq->dq_id = key; |
Aditya Kali | f239fef | 2011-07-20 11:40:02 -0700 | [diff] [blame] | 282 | } |
| 283 | return dq; |
| 284 | } |
| 285 | |
| 286 | |
| 287 | /* |
| 288 | * Called to update the blocks used by a particular inode |
| 289 | */ |
| 290 | void quota_data_add(quota_ctx_t qctx, struct ext2_inode *inode, ext2_ino_t ino, |
| 291 | qsize_t space) |
| 292 | { |
| 293 | struct dquot *dq; |
| 294 | dict_t *dict; |
| 295 | int i; |
| 296 | |
| 297 | if (!qctx) |
| 298 | return; |
| 299 | |
| 300 | log_debug("ADD_DATA: Inode: %u, UID/GID: %u/%u, space: %ld", ino, |
| 301 | inode_uid(*inode), |
| 302 | inode_gid(*inode), space); |
| 303 | for (i = 0; i < MAXQUOTAS; i++) { |
| 304 | dict = qctx->quota_dict[i]; |
| 305 | if (dict) { |
| 306 | dq = get_dq(dict, get_qid(inode, i)); |
Aditya Kali | a86d55d | 2011-11-14 10:55:54 -0500 | [diff] [blame] | 307 | if (dq) |
| 308 | dq->dq_dqb.dqb_curspace += space; |
Aditya Kali | f239fef | 2011-07-20 11:40:02 -0700 | [diff] [blame] | 309 | } |
| 310 | } |
| 311 | } |
| 312 | |
| 313 | /* |
| 314 | * Called to remove some blocks used by a particular inode |
| 315 | */ |
| 316 | void quota_data_sub(quota_ctx_t qctx, struct ext2_inode *inode, ext2_ino_t ino, |
| 317 | qsize_t space) |
| 318 | { |
| 319 | struct dquot *dq; |
| 320 | dict_t *dict; |
| 321 | int i; |
| 322 | |
| 323 | if (!qctx) |
| 324 | return; |
| 325 | |
| 326 | log_debug("SUB_DATA: Inode: %u, UID/GID: %u/%u, space: %ld", ino, |
| 327 | inode_uid(*inode), |
| 328 | inode_gid(*inode), space); |
| 329 | for (i = 0; i < MAXQUOTAS; i++) { |
| 330 | dict = qctx->quota_dict[i]; |
| 331 | if (dict) { |
| 332 | dq = get_dq(dict, get_qid(inode, i)); |
| 333 | dq->dq_dqb.dqb_curspace -= space; |
| 334 | } |
| 335 | } |
| 336 | } |
| 337 | |
| 338 | /* |
| 339 | * Called to count the files used by an inode's user/group |
| 340 | */ |
| 341 | void quota_data_inodes(quota_ctx_t qctx, struct ext2_inode *inode, |
| 342 | ext2_ino_t ino, int adjust) |
| 343 | { |
| 344 | struct dquot *dq; |
| 345 | dict_t *dict; |
| 346 | int i; |
| 347 | |
| 348 | if (!qctx) |
| 349 | return; |
| 350 | |
| 351 | log_debug("ADJ_INODE: Inode: %u, UID/GID: %u/%u, adjust: %d", ino, |
| 352 | inode_uid(*inode), |
| 353 | inode_gid(*inode), adjust); |
| 354 | for (i = 0; i < MAXQUOTAS; i++) { |
| 355 | dict = qctx->quota_dict[i]; |
| 356 | if (dict) { |
| 357 | dq = get_dq(dict, get_qid(inode, i)); |
| 358 | dq->dq_dqb.dqb_curinodes += adjust; |
| 359 | } |
| 360 | } |
| 361 | } |
| 362 | |
Aditya Kali | a86d55d | 2011-11-14 10:55:54 -0500 | [diff] [blame] | 363 | errcode_t quota_compute_usage(quota_ctx_t qctx) |
Aditya Kali | f239fef | 2011-07-20 11:40:02 -0700 | [diff] [blame] | 364 | { |
| 365 | ext2_filsys fs; |
Aditya Kali | f239fef | 2011-07-20 11:40:02 -0700 | [diff] [blame] | 366 | ext2_ino_t ino; |
| 367 | errcode_t ret; |
| 368 | struct ext2_inode inode; |
| 369 | qsize_t space; |
| 370 | ext2_inode_scan scan; |
| 371 | |
| 372 | if (!qctx) |
Theodore Ts'o | edbfd75 | 2011-10-04 11:20:50 -0400 | [diff] [blame] | 373 | return 0; |
Aditya Kali | f239fef | 2011-07-20 11:40:02 -0700 | [diff] [blame] | 374 | |
| 375 | fs = qctx->fs; |
| 376 | ret = ext2fs_open_inode_scan(fs, 0, &scan); |
| 377 | if (ret) { |
| 378 | log_err("while opening inode scan. ret=%ld", ret); |
| 379 | return ret; |
| 380 | } |
| 381 | |
| 382 | while (1) { |
| 383 | ret = ext2fs_get_next_inode(scan, &ino, &inode); |
| 384 | if (ret) { |
| 385 | log_err("while getting next inode. ret=%ld", ret); |
| 386 | ext2fs_close_inode_scan(scan); |
| 387 | return ret; |
| 388 | } |
| 389 | if (ino == 0) |
| 390 | break; |
Aditya Kali | 5027751 | 2012-07-13 15:25:06 -0700 | [diff] [blame] | 391 | if (inode.i_links_count && |
| 392 | (ino == EXT2_ROOT_INO || |
| 393 | ino >= EXT2_FIRST_INODE(fs->super))) { |
Niu | 7bed9a7 | 2011-11-14 10:58:28 -0500 | [diff] [blame] | 394 | space = ext2fs_inode_i_blocks(fs, &inode) << 9; |
Aditya Kali | f239fef | 2011-07-20 11:40:02 -0700 | [diff] [blame] | 395 | quota_data_add(qctx, &inode, ino, space); |
| 396 | quota_data_inodes(qctx, &inode, ino, +1); |
| 397 | } |
| 398 | } |
| 399 | |
| 400 | ext2fs_close_inode_scan(scan); |
| 401 | |
| 402 | return 0; |
| 403 | } |
Niu | 198d20f | 2011-11-14 10:58:28 -0500 | [diff] [blame] | 404 | |
| 405 | struct scan_dquots_data { |
Aditya Kali | 7943ccf | 2012-04-24 14:46:08 -0400 | [diff] [blame] | 406 | dict_t *quota_dict; |
| 407 | int update_limits; /* update limits from disk */ |
| 408 | int update_usage; |
| 409 | int usage_is_inconsistent; |
Niu | 198d20f | 2011-11-14 10:58:28 -0500 | [diff] [blame] | 410 | }; |
| 411 | |
| 412 | static int scan_dquots_callback(struct dquot *dquot, void *cb_data) |
| 413 | { |
Aditya Kali | 7943ccf | 2012-04-24 14:46:08 -0400 | [diff] [blame] | 414 | struct scan_dquots_data *scan_data = cb_data; |
| 415 | dict_t *quota_dict = scan_data->quota_dict; |
Niu | 198d20f | 2011-11-14 10:58:28 -0500 | [diff] [blame] | 416 | struct dquot *dq; |
| 417 | |
Aditya Kali | 7943ccf | 2012-04-24 14:46:08 -0400 | [diff] [blame] | 418 | dq = get_dq(quota_dict, dquot->dq_id); |
Niu | 198d20f | 2011-11-14 10:58:28 -0500 | [diff] [blame] | 419 | dq->dq_id = dquot->dq_id; |
Aditya Kali | 5027751 | 2012-07-13 15:25:06 -0700 | [diff] [blame] | 420 | dq->dq_dqb.u.v2_mdqb.dqb_off = dquot->dq_dqb.u.v2_mdqb.dqb_off; |
Aditya Kali | 7943ccf | 2012-04-24 14:46:08 -0400 | [diff] [blame] | 421 | |
| 422 | /* Check if there is inconsistancy. */ |
| 423 | if (dq->dq_dqb.dqb_curspace != dquot->dq_dqb.dqb_curspace || |
| 424 | dq->dq_dqb.dqb_curinodes != dquot->dq_dqb.dqb_curinodes) { |
| 425 | scan_data->usage_is_inconsistent = 1; |
Aditya Kali | 5027751 | 2012-07-13 15:25:06 -0700 | [diff] [blame] | 426 | fprintf(stderr, "[QUOTA WARNING] Usage inconsistent for ID %d:" |
| 427 | "actual (%llu, %llu) != expected (%llu, %llu)\n", |
Andreas Dilger | 0ce0172 | 2012-11-29 05:47:54 -0700 | [diff] [blame] | 428 | dq->dq_id, (long long)dq->dq_dqb.dqb_curspace, |
| 429 | (long long)dq->dq_dqb.dqb_curinodes, |
| 430 | (long long)dquot->dq_dqb.dqb_curspace, |
| 431 | (long long)dquot->dq_dqb.dqb_curinodes); |
Aditya Kali | 7943ccf | 2012-04-24 14:46:08 -0400 | [diff] [blame] | 432 | } |
| 433 | |
| 434 | if (scan_data->update_limits) { |
Niu | 198d20f | 2011-11-14 10:58:28 -0500 | [diff] [blame] | 435 | dq->dq_dqb.dqb_ihardlimit = dquot->dq_dqb.dqb_ihardlimit; |
| 436 | dq->dq_dqb.dqb_isoftlimit = dquot->dq_dqb.dqb_isoftlimit; |
| 437 | dq->dq_dqb.dqb_bhardlimit = dquot->dq_dqb.dqb_bhardlimit; |
| 438 | dq->dq_dqb.dqb_bsoftlimit = dquot->dq_dqb.dqb_bsoftlimit; |
Niu | 198d20f | 2011-11-14 10:58:28 -0500 | [diff] [blame] | 439 | } |
Aditya Kali | 7943ccf | 2012-04-24 14:46:08 -0400 | [diff] [blame] | 440 | |
| 441 | if (scan_data->update_usage) { |
| 442 | dq->dq_dqb.dqb_curspace = dquot->dq_dqb.dqb_curspace; |
| 443 | dq->dq_dqb.dqb_curinodes = dquot->dq_dqb.dqb_curinodes; |
| 444 | } |
| 445 | |
Niu | 198d20f | 2011-11-14 10:58:28 -0500 | [diff] [blame] | 446 | return 0; |
| 447 | } |
| 448 | |
| 449 | /* |
| 450 | * Read all dquots from quota file into memory |
| 451 | */ |
| 452 | static errcode_t quota_read_all_dquots(struct quota_handle *qh, |
Aditya Kali | 7943ccf | 2012-04-24 14:46:08 -0400 | [diff] [blame] | 453 | quota_ctx_t qctx, int update_limits) |
Niu | 198d20f | 2011-11-14 10:58:28 -0500 | [diff] [blame] | 454 | { |
| 455 | struct scan_dquots_data scan_data; |
| 456 | |
Aditya Kali | 7943ccf | 2012-04-24 14:46:08 -0400 | [diff] [blame] | 457 | scan_data.quota_dict = qctx->quota_dict[qh->qh_type]; |
| 458 | scan_data.update_limits = update_limits; |
| 459 | scan_data.update_usage = 0; |
Niu | 198d20f | 2011-11-14 10:58:28 -0500 | [diff] [blame] | 460 | |
| 461 | return qh->qh_ops->scan_dquots(qh, scan_dquots_callback, &scan_data); |
| 462 | } |
| 463 | |
| 464 | /* |
| 465 | * Write all memory dquots into quota file |
| 466 | */ |
Andreas Dilger | 0ce0172 | 2012-11-29 05:47:54 -0700 | [diff] [blame] | 467 | #if 0 /* currently unused, but may be useful in the future? */ |
Niu | 198d20f | 2011-11-14 10:58:28 -0500 | [diff] [blame] | 468 | static errcode_t quota_write_all_dquots(struct quota_handle *qh, |
| 469 | quota_ctx_t qctx) |
| 470 | { |
| 471 | errcode_t err; |
| 472 | |
| 473 | err = ext2fs_read_bitmaps(qctx->fs); |
| 474 | if (err) |
| 475 | return err; |
| 476 | write_dquots(qctx->quota_dict[qh->qh_type], qh); |
| 477 | ext2fs_mark_bb_dirty(qctx->fs); |
| 478 | qctx->fs->flags &= ~EXT2_FLAG_SUPER_ONLY; |
| 479 | ext2fs_write_bitmaps(qctx->fs); |
| 480 | return 0; |
| 481 | } |
Andreas Dilger | 0ce0172 | 2012-11-29 05:47:54 -0700 | [diff] [blame] | 482 | #endif |
Niu | 198d20f | 2011-11-14 10:58:28 -0500 | [diff] [blame] | 483 | |
| 484 | /* |
Aditya Kali | 5027751 | 2012-07-13 15:25:06 -0700 | [diff] [blame] | 485 | * Updates the in-memory quota limits from the given quota inode. |
Niu | 198d20f | 2011-11-14 10:58:28 -0500 | [diff] [blame] | 486 | */ |
Aditya Kali | 5027751 | 2012-07-13 15:25:06 -0700 | [diff] [blame] | 487 | errcode_t quota_update_limits(quota_ctx_t qctx, ext2_ino_t qf_ino, int type) |
Niu | 198d20f | 2011-11-14 10:58:28 -0500 | [diff] [blame] | 488 | { |
| 489 | struct quota_handle *qh; |
| 490 | errcode_t err; |
| 491 | |
| 492 | if (!qctx) |
| 493 | return 0; |
| 494 | |
| 495 | err = ext2fs_get_mem(sizeof(struct quota_handle), &qh); |
| 496 | if (err) { |
Andreas Dilger | 0ce0172 | 2012-11-29 05:47:54 -0700 | [diff] [blame] | 497 | log_err("Unable to allocate quota handle"); |
Niu | 198d20f | 2011-11-14 10:58:28 -0500 | [diff] [blame] | 498 | return err; |
| 499 | } |
| 500 | |
Aditya Kali | 5027751 | 2012-07-13 15:25:06 -0700 | [diff] [blame] | 501 | err = quota_file_open(qh, qctx->fs, qf_ino, type, -1, 0); |
Niu | 198d20f | 2011-11-14 10:58:28 -0500 | [diff] [blame] | 502 | if (err) { |
Andreas Dilger | 0ce0172 | 2012-11-29 05:47:54 -0700 | [diff] [blame] | 503 | log_err("Open quota file failed"); |
Niu | 198d20f | 2011-11-14 10:58:28 -0500 | [diff] [blame] | 504 | goto out; |
| 505 | } |
| 506 | |
| 507 | quota_read_all_dquots(qh, qctx, 1); |
Niu | 198d20f | 2011-11-14 10:58:28 -0500 | [diff] [blame] | 508 | |
| 509 | err = quota_file_close(qh); |
| 510 | if (err) { |
| 511 | log_err("Cannot finish IO on new quotafile: %s", |
| 512 | strerror(errno)); |
| 513 | if (qh->qh_qf.e2_file) |
| 514 | ext2fs_file_close(qh->qh_qf.e2_file); |
| 515 | } |
| 516 | out: |
| 517 | ext2fs_free_mem(&qh); |
| 518 | return err; |
| 519 | } |
Aditya Kali | 7943ccf | 2012-04-24 14:46:08 -0400 | [diff] [blame] | 520 | |
| 521 | /* |
| 522 | * Compares the measured quota in qctx->quota_dict with that in the quota inode |
| 523 | * on disk and updates the limits in qctx->quota_dict. 'usage_inconsistent' is |
| 524 | * set to 1 if the supplied and on-disk quota usage values are not identical. |
| 525 | */ |
| 526 | errcode_t quota_compare_and_update(quota_ctx_t qctx, int qtype, |
| 527 | int *usage_inconsistent) |
| 528 | { |
| 529 | ext2_filsys fs = qctx->fs; |
| 530 | struct quota_handle qh; |
| 531 | struct scan_dquots_data scan_data; |
| 532 | ext2_ino_t qf_ino; |
| 533 | errcode_t err = 0; |
| 534 | |
| 535 | if (!qctx->quota_dict[qtype]) |
| 536 | goto out; |
| 537 | |
| 538 | qf_ino = qtype == USRQUOTA ? fs->super->s_usr_quota_inum : |
| 539 | fs->super->s_grp_quota_inum; |
| 540 | err = quota_file_open(&qh, fs, qf_ino, qtype, -1, 0); |
| 541 | if (err) { |
Andreas Dilger | 0ce0172 | 2012-11-29 05:47:54 -0700 | [diff] [blame] | 542 | log_err("Open quota file failed"); |
Aditya Kali | 7943ccf | 2012-04-24 14:46:08 -0400 | [diff] [blame] | 543 | goto out; |
| 544 | } |
| 545 | |
| 546 | scan_data.quota_dict = qctx->quota_dict[qtype]; |
| 547 | scan_data.update_limits = 1; |
| 548 | scan_data.update_usage = 0; |
| 549 | scan_data.usage_is_inconsistent = 0; |
| 550 | err = qh.qh_ops->scan_dquots(&qh, scan_dquots_callback, &scan_data); |
| 551 | if (err) { |
Andreas Dilger | 0ce0172 | 2012-11-29 05:47:54 -0700 | [diff] [blame] | 552 | log_err("Error scanning dquots"); |
Aditya Kali | 7943ccf | 2012-04-24 14:46:08 -0400 | [diff] [blame] | 553 | goto out; |
| 554 | } |
| 555 | *usage_inconsistent = scan_data.usage_is_inconsistent; |
| 556 | |
| 557 | out: |
| 558 | return err; |
| 559 | } |