projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
[GFS2] Fix sign problem in quota/statfs and cleanup _host structures
[deliverable/linux.git] / fs / gfs2 / inode.c
1 /*
2 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
3 * Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved.
4 *
5 * This copyrighted material is made available to anyone wishing to use,
6 * modify, copy, or redistribute it subject to the terms and conditions
7 * of the GNU General Public License version 2.
8 */
9
10 #include <linux/sched.h>
11 #include <linux/slab.h>
12 #include <linux/spinlock.h>
13 #include <linux/completion.h>
14 #include <linux/buffer_head.h>
15 #include <linux/posix_acl.h>
16 #include <linux/sort.h>
17 #include <linux/gfs2_ondisk.h>
18 #include <linux/crc32.h>
19 #include <linux/lm_interface.h>
20 #include <linux/security.h>
21
22 #include "gfs2.h"
23 #include "incore.h"
24 #include "acl.h"
25 #include "bmap.h"
26 #include "dir.h"
27 #include "eattr.h"
28 #include "glock.h"
29 #include "glops.h"
30 #include "inode.h"
31 #include "log.h"
32 #include "meta_io.h"
33 #include "ops_address.h"
34 #include "ops_file.h"
35 #include "ops_inode.h"
36 #include "quota.h"
37 #include "rgrp.h"
38 #include "trans.h"
39 #include "util.h"
40
41 struct gfs2_inum_range_host {
42 u64 ir_start;
43 u64 ir_length;
44 };
45
46 static int iget_test(struct inode *inode, void *opaque)
47 {
48 struct gfs2_inode *ip = GFS2_I(inode);
49 u64 *no_addr = opaque;
50
51 if (ip->i_no_addr == *no_addr &&
52 inode->i_private != NULL)
53 return 1;
54
55 return 0;
56 }
57
58 static int iget_set(struct inode *inode, void *opaque)
59 {
60 struct gfs2_inode *ip = GFS2_I(inode);
61 u64 *no_addr = opaque;
62
63 inode->i_ino = (unsigned long)*no_addr;
64 ip->i_no_addr = *no_addr;
65 return 0;
66 }
67
68 struct inode *gfs2_ilookup(struct super_block *sb, u64 no_addr)
69 {
70 unsigned long hash = (unsigned long)no_addr;
71 return ilookup5(sb, hash, iget_test, &no_addr);
72 }
73
74 static struct inode *gfs2_iget(struct super_block *sb, u64 no_addr)
75 {
76 unsigned long hash = (unsigned long)no_addr;
77 return iget5_locked(sb, hash, iget_test, iget_set, &no_addr);
78 }
79
80 /**
81 * gfs2_inode_lookup - Lookup an inode
82 * @sb: The super block
83 * @no_addr: The inode number
84 * @type: The type of the inode
85 *
86 * Returns: A VFS inode, or an error
87 */
88
89 struct inode *gfs2_inode_lookup(struct super_block *sb, u64 no_addr, unsigned int type)
90 {
91 struct inode *inode = gfs2_iget(sb, no_addr);
92 struct gfs2_inode *ip = GFS2_I(inode);
93 struct gfs2_glock *io_gl;
94 int error;
95
96 if (!inode)
97 return ERR_PTR(-ENOBUFS);
98
99 if (inode->i_state & I_NEW) {
100 struct gfs2_sbd *sdp = GFS2_SB(inode);
101 umode_t mode = DT2IF(type);
102 inode->i_private = ip;
103 inode->i_mode = mode;
104
105 if (S_ISREG(mode)) {
106 inode->i_op = &gfs2_file_iops;
107 inode->i_fop = &gfs2_file_fops;
108 inode->i_mapping->a_ops = &gfs2_file_aops;
109 } else if (S_ISDIR(mode)) {
110 inode->i_op = &gfs2_dir_iops;
111 inode->i_fop = &gfs2_dir_fops;
112 } else if (S_ISLNK(mode)) {
113 inode->i_op = &gfs2_symlink_iops;
114 } else {
115 inode->i_op = &gfs2_dev_iops;
116 }
117
118 error = gfs2_glock_get(sdp, no_addr, &gfs2_inode_glops, CREATE, &ip->i_gl);
119 if (unlikely(error))
120 goto fail;
121 ip->i_gl->gl_object = ip;
122
123 error = gfs2_glock_get(sdp, no_addr, &gfs2_iopen_glops, CREATE, &io_gl);
124 if (unlikely(error))
125 goto fail_put;
126
127 set_bit(GIF_INVALID, &ip->i_flags);
128 error = gfs2_glock_nq_init(io_gl, LM_ST_SHARED, GL_EXACT, &ip->i_iopen_gh);
129 if (unlikely(error))
130 goto fail_iopen;
131
132 gfs2_glock_put(io_gl);
133 unlock_new_inode(inode);
134 }
135
136 return inode;
137 fail_iopen:
138 gfs2_glock_put(io_gl);
139 fail_put:
140 ip->i_gl->gl_object = NULL;
141 gfs2_glock_put(ip->i_gl);
142 fail:
143 iput(inode);
144 return ERR_PTR(error);
145 }
146
147 static int gfs2_dinode_in(struct gfs2_inode *ip, const void *buf)
148 {
149 struct gfs2_dinode_host *di = &ip->i_di;
150 const struct gfs2_dinode *str = buf;
151
152 if (ip->i_no_addr != be64_to_cpu(str->di_num.no_addr)) {
153 if (gfs2_consist_inode(ip))
154 gfs2_dinode_print(ip);
155 return -EIO;
156 }
157 ip->i_no_formal_ino = be64_to_cpu(str->di_num.no_formal_ino);
158 ip->i_inode.i_mode = be32_to_cpu(str->di_mode);
159 ip->i_inode.i_rdev = 0;
160 switch (ip->i_inode.i_mode & S_IFMT) {
161 case S_IFBLK:
162 case S_IFCHR:
163 ip->i_inode.i_rdev = MKDEV(be32_to_cpu(str->di_major),
164 be32_to_cpu(str->di_minor));
165 break;
166 };
167
168 ip->i_inode.i_uid = be32_to_cpu(str->di_uid);
169 ip->i_inode.i_gid = be32_to_cpu(str->di_gid);
170 /*
171 * We will need to review setting the nlink count here in the
172 * light of the forthcoming ro bind mount work. This is a reminder
173 * to do that.
174 */
175 ip->i_inode.i_nlink = be32_to_cpu(str->di_nlink);
176 di->di_size = be64_to_cpu(str->di_size);
177 i_size_write(&ip->i_inode, di->di_size);
178 di->di_blocks = be64_to_cpu(str->di_blocks);
179 gfs2_set_inode_blocks(&ip->i_inode);
180 ip->i_inode.i_atime.tv_sec = be64_to_cpu(str->di_atime);
181 ip->i_inode.i_atime.tv_nsec = 0;
182 ip->i_inode.i_mtime.tv_sec = be64_to_cpu(str->di_mtime);
183 ip->i_inode.i_mtime.tv_nsec = 0;
184 ip->i_inode.i_ctime.tv_sec = be64_to_cpu(str->di_ctime);
185 ip->i_inode.i_ctime.tv_nsec = 0;
186
187 di->di_goal_meta = be64_to_cpu(str->di_goal_meta);
188 di->di_goal_data = be64_to_cpu(str->di_goal_data);
189 di->di_generation = be64_to_cpu(str->di_generation);
190
191 di->di_flags = be32_to_cpu(str->di_flags);
192 gfs2_set_inode_flags(&ip->i_inode);
193 di->di_height = be16_to_cpu(str->di_height);
194
195 di->di_depth = be16_to_cpu(str->di_depth);
196 di->di_entries = be32_to_cpu(str->di_entries);
197
198 di->di_eattr = be64_to_cpu(str->di_eattr);
199 return 0;
200 }
201
202 /**
203 * gfs2_inode_refresh - Refresh the incore copy of the dinode
204 * @ip: The GFS2 inode
205 *
206 * Returns: errno
207 */
208
209 int gfs2_inode_refresh(struct gfs2_inode *ip)
210 {
211 struct buffer_head *dibh;
212 int error;
213
214 error = gfs2_meta_inode_buffer(ip, &dibh);
215 if (error)
216 return error;
217
218 if (gfs2_metatype_check(GFS2_SB(&ip->i_inode), dibh, GFS2_METATYPE_DI)) {
219 brelse(dibh);
220 return -EIO;
221 }
222
223 error = gfs2_dinode_in(ip, dibh->b_data);
224 brelse(dibh);
225 clear_bit(GIF_INVALID, &ip->i_flags);
226
227 return error;
228 }
229
230 int gfs2_dinode_dealloc(struct gfs2_inode *ip)
231 {
232 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
233 struct gfs2_alloc *al;
234 struct gfs2_rgrpd *rgd;
235 int error;
236
237 if (ip->i_di.di_blocks != 1) {
238 if (gfs2_consist_inode(ip))
239 gfs2_dinode_print(ip);
240 return -EIO;
241 }
242
243 al = gfs2_alloc_get(ip);
244
245 error = gfs2_quota_hold(ip, NO_QUOTA_CHANGE, NO_QUOTA_CHANGE);
246 if (error)
247 goto out;
248
249 error = gfs2_rindex_hold(sdp, &al->al_ri_gh);
250 if (error)
251 goto out_qs;
252
253 rgd = gfs2_blk2rgrpd(sdp, ip->i_no_addr);
254 if (!rgd) {
255 gfs2_consist_inode(ip);
256 error = -EIO;
257 goto out_rindex_relse;
258 }
259
260 error = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_EXCLUSIVE, 0,
261 &al->al_rgd_gh);
262 if (error)
263 goto out_rindex_relse;
264
265 error = gfs2_trans_begin(sdp, RES_RG_BIT + RES_STATFS + RES_QUOTA, 1);
266 if (error)
267 goto out_rg_gunlock;
268
269 gfs2_trans_add_gl(ip->i_gl);
270
271 gfs2_free_di(rgd, ip);
272
273 gfs2_trans_end(sdp);
274 clear_bit(GLF_STICKY, &ip->i_gl->gl_flags);
275
276 out_rg_gunlock:
277 gfs2_glock_dq_uninit(&al->al_rgd_gh);
278 out_rindex_relse:
279 gfs2_glock_dq_uninit(&al->al_ri_gh);
280 out_qs:
281 gfs2_quota_unhold(ip);
282 out:
283 gfs2_alloc_put(ip);
284 return error;
285 }
286
287 /**
288 * gfs2_change_nlink - Change nlink count on inode
289 * @ip: The GFS2 inode
290 * @diff: The change in the nlink count required
291 *
292 * Returns: errno
293 */
294 int gfs2_change_nlink(struct gfs2_inode *ip, int diff)
295 {
296 struct buffer_head *dibh;
297 u32 nlink;
298 int error;
299
300 BUG_ON(diff != 1 && diff != -1);
301 nlink = ip->i_inode.i_nlink + diff;
302
303 /* If we are reducing the nlink count, but the new value ends up being
304 bigger than the old one, we must have underflowed. */
305 if (diff < 0 && nlink > ip->i_inode.i_nlink) {
306 if (gfs2_consist_inode(ip))
307 gfs2_dinode_print(ip);
308 return -EIO;
309 }
310
311 error = gfs2_meta_inode_buffer(ip, &dibh);
312 if (error)
313 return error;
314
315 if (diff > 0)
316 inc_nlink(&ip->i_inode);
317 else
318 drop_nlink(&ip->i_inode);
319
320 ip->i_inode.i_ctime = CURRENT_TIME_SEC;
321
322 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
323 gfs2_dinode_out(ip, dibh->b_data);
324 brelse(dibh);
325 mark_inode_dirty(&ip->i_inode);
326
327 if (ip->i_inode.i_nlink == 0)
328 gfs2_unlink_di(&ip->i_inode); /* mark inode unlinked */
329
330 return error;
331 }
332
333 struct inode *gfs2_lookup_simple(struct inode *dip, const char *name)
334 {
335 struct qstr qstr;
336 struct inode *inode;
337 gfs2_str2qstr(&qstr, name);
338 inode = gfs2_lookupi(dip, &qstr, 1, NULL);
339 /* gfs2_lookupi has inconsistent callers: vfs
340 * related routines expect NULL for no entry found,
341 * gfs2_lookup_simple callers expect ENOENT
342 * and do not check for NULL.
343 */
344 if (inode == NULL)
345 return ERR_PTR(-ENOENT);
346 else
347 return inode;
348 }
349
350
351 /**
352 * gfs2_lookupi - Look up a filename in a directory and return its inode
353 * @d_gh: An initialized holder for the directory glock
354 * @name: The name of the inode to look for
355 * @is_root: If 1, ignore the caller's permissions
356 * @i_gh: An uninitialized holder for the new inode glock
357 *
358 * This can be called via the VFS filldir function when NFS is doing
359 * a readdirplus and the inode which its intending to stat isn't
360 * already in cache. In this case we must not take the directory glock
361 * again, since the readdir call will have already taken that lock.
362 *
363 * Returns: errno
364 */
365
366 struct inode *gfs2_lookupi(struct inode *dir, const struct qstr *name,
367 int is_root, struct nameidata *nd)
368 {
369 struct super_block *sb = dir->i_sb;
370 struct gfs2_inode *dip = GFS2_I(dir);
371 struct gfs2_holder d_gh;
372 int error;
373 struct inode *inode = NULL;
374 int unlock = 0;
375
376 if (!name->len || name->len > GFS2_FNAMESIZE)
377 return ERR_PTR(-ENAMETOOLONG);
378
379 if ((name->len == 1 && memcmp(name->name, ".", 1) == 0) ||
380 (name->len == 2 && memcmp(name->name, "..", 2) == 0 &&
381 dir == sb->s_root->d_inode)) {
382 igrab(dir);
383 return dir;
384 }
385
386 if (gfs2_glock_is_locked_by_me(dip->i_gl) == 0) {
387 error = gfs2_glock_nq_init(dip->i_gl, LM_ST_SHARED, 0, &d_gh);
388 if (error)
389 return ERR_PTR(error);
390 unlock = 1;
391 }
392
393 if (!is_root) {
394 error = permission(dir, MAY_EXEC, NULL);
395 if (error)
396 goto out;
397 }
398
399 inode = gfs2_dir_search(dir, name);
400 if (IS_ERR(inode))
401 error = PTR_ERR(inode);
402 out:
403 if (unlock)
404 gfs2_glock_dq_uninit(&d_gh);
405 if (error == -ENOENT)
406 return NULL;
407 return inode ? inode : ERR_PTR(error);
408 }
409
410 static void gfs2_inum_range_in(struct gfs2_inum_range_host *ir, const void *buf)
411 {
412 const struct gfs2_inum_range *str = buf;
413
414 ir->ir_start = be64_to_cpu(str->ir_start);
415 ir->ir_length = be64_to_cpu(str->ir_length);
416 }
417
418 static void gfs2_inum_range_out(const struct gfs2_inum_range_host *ir, void *buf)
419 {
420 struct gfs2_inum_range *str = buf;
421
422 str->ir_start = cpu_to_be64(ir->ir_start);
423 str->ir_length = cpu_to_be64(ir->ir_length);
424 }
425
426 static int pick_formal_ino_1(struct gfs2_sbd *sdp, u64 *formal_ino)
427 {
428 struct gfs2_inode *ip = GFS2_I(sdp->sd_ir_inode);
429 struct buffer_head *bh;
430 struct gfs2_inum_range_host ir;
431 int error;
432
433 error = gfs2_trans_begin(sdp, RES_DINODE, 0);
434 if (error)
435 return error;
436 mutex_lock(&sdp->sd_inum_mutex);
437
438 error = gfs2_meta_inode_buffer(ip, &bh);
439 if (error) {
440 mutex_unlock(&sdp->sd_inum_mutex);
441 gfs2_trans_end(sdp);
442 return error;
443 }
444
445 gfs2_inum_range_in(&ir, bh->b_data + sizeof(struct gfs2_dinode));
446
447 if (ir.ir_length) {
448 *formal_ino = ir.ir_start++;
449 ir.ir_length--;
450 gfs2_trans_add_bh(ip->i_gl, bh, 1);
451 gfs2_inum_range_out(&ir,
452 bh->b_data + sizeof(struct gfs2_dinode));
453 brelse(bh);
454 mutex_unlock(&sdp->sd_inum_mutex);
455 gfs2_trans_end(sdp);
456 return 0;
457 }
458
459 brelse(bh);
460
461 mutex_unlock(&sdp->sd_inum_mutex);
462 gfs2_trans_end(sdp);
463
464 return 1;
465 }
466
467 static int pick_formal_ino_2(struct gfs2_sbd *sdp, u64 *formal_ino)
468 {
469 struct gfs2_inode *ip = GFS2_I(sdp->sd_ir_inode);
470 struct gfs2_inode *m_ip = GFS2_I(sdp->sd_inum_inode);
471 struct gfs2_holder gh;
472 struct buffer_head *bh;
473 struct gfs2_inum_range_host ir;
474 int error;
475
476 error = gfs2_glock_nq_init(m_ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
477 if (error)
478 return error;
479
480 error = gfs2_trans_begin(sdp, 2 * RES_DINODE, 0);
481 if (error)
482 goto out;
483 mutex_lock(&sdp->sd_inum_mutex);
484
485 error = gfs2_meta_inode_buffer(ip, &bh);
486 if (error)
487 goto out_end_trans;
488
489 gfs2_inum_range_in(&ir, bh->b_data + sizeof(struct gfs2_dinode));
490
491 if (!ir.ir_length) {
492 struct buffer_head *m_bh;
493 u64 x, y;
494 __be64 z;
495
496 error = gfs2_meta_inode_buffer(m_ip, &m_bh);
497 if (error)
498 goto out_brelse;
499
500 z = *(__be64 *)(m_bh->b_data + sizeof(struct gfs2_dinode));
501 x = y = be64_to_cpu(z);
502 ir.ir_start = x;
503 ir.ir_length = GFS2_INUM_QUANTUM;
504 x += GFS2_INUM_QUANTUM;
505 if (x < y)
506 gfs2_consist_inode(m_ip);
507 z = cpu_to_be64(x);
508 gfs2_trans_add_bh(m_ip->i_gl, m_bh, 1);
509 *(__be64 *)(m_bh->b_data + sizeof(struct gfs2_dinode)) = z;
510
511 brelse(m_bh);
512 }
513
514 *formal_ino = ir.ir_start++;
515 ir.ir_length--;
516
517 gfs2_trans_add_bh(ip->i_gl, bh, 1);
518 gfs2_inum_range_out(&ir, bh->b_data + sizeof(struct gfs2_dinode));
519
520 out_brelse:
521 brelse(bh);
522 out_end_trans:
523 mutex_unlock(&sdp->sd_inum_mutex);
524 gfs2_trans_end(sdp);
525 out:
526 gfs2_glock_dq_uninit(&gh);
527 return error;
528 }
529
530 static int pick_formal_ino(struct gfs2_sbd *sdp, u64 *inum)
531 {
532 int error;
533
534 error = pick_formal_ino_1(sdp, inum);
535 if (error <= 0)
536 return error;
537
538 error = pick_formal_ino_2(sdp, inum);
539
540 return error;
541 }
542
543 /**
544 * create_ok - OK to create a new on-disk inode here?
545 * @dip: Directory in which dinode is to be created
546 * @name: Name of new dinode
547 * @mode:
548 *
549 * Returns: errno
550 */
551
552 static int create_ok(struct gfs2_inode *dip, const struct qstr *name,
553 unsigned int mode)
554 {
555 int error;
556
557 error = permission(&dip->i_inode, MAY_WRITE | MAY_EXEC, NULL);
558 if (error)
559 return error;
560
561 /* Don't create entries in an unlinked directory */
562 if (!dip->i_inode.i_nlink)
563 return -EPERM;
564
565 error = gfs2_dir_check(&dip->i_inode, name, NULL);
566 switch (error) {
567 case -ENOENT:
568 error = 0;
569 break;
570 case 0:
571 return -EEXIST;
572 default:
573 return error;
574 }
575
576 if (dip->i_di.di_entries == (u32)-1)
577 return -EFBIG;
578 if (S_ISDIR(mode) && dip->i_inode.i_nlink == (u32)-1)
579 return -EMLINK;
580
581 return 0;
582 }
583
584 static void munge_mode_uid_gid(struct gfs2_inode *dip, unsigned int *mode,
585 unsigned int *uid, unsigned int *gid)
586 {
587 if (GFS2_SB(&dip->i_inode)->sd_args.ar_suiddir &&
588 (dip->i_inode.i_mode & S_ISUID) && dip->i_inode.i_uid) {
589 if (S_ISDIR(*mode))
590 *mode |= S_ISUID;
591 else if (dip->i_inode.i_uid != current->fsuid)
592 *mode &= ~07111;
593 *uid = dip->i_inode.i_uid;
594 } else
595 *uid = current->fsuid;
596
597 if (dip->i_inode.i_mode & S_ISGID) {
598 if (S_ISDIR(*mode))
599 *mode |= S_ISGID;
600 *gid = dip->i_inode.i_gid;
601 } else
602 *gid = current->fsgid;
603 }
604
605 static int alloc_dinode(struct gfs2_inode *dip, u64 *no_addr, u64 *generation)
606 {
607 struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
608 int error;
609
610 gfs2_alloc_get(dip);
611
612 dip->i_alloc.al_requested = RES_DINODE;
613 error = gfs2_inplace_reserve(dip);
614 if (error)
615 goto out;
616
617 error = gfs2_trans_begin(sdp, RES_RG_BIT + RES_STATFS, 0);
618 if (error)
619 goto out_ipreserv;
620
621 *no_addr = gfs2_alloc_di(dip, generation);
622
623 gfs2_trans_end(sdp);
624
625 out_ipreserv:
626 gfs2_inplace_release(dip);
627 out:
628 gfs2_alloc_put(dip);
629 return error;
630 }
631
632 /**
633 * init_dinode - Fill in a new dinode structure
634 * @dip: the directory this inode is being created in
635 * @gl: The glock covering the new inode
636 * @inum: the inode number
637 * @mode: the file permissions
638 * @uid:
639 * @gid:
640 *
641 */
642
643 static void init_dinode(struct gfs2_inode *dip, struct gfs2_glock *gl,
644 const struct gfs2_inum_host *inum, unsigned int mode,
645 unsigned int uid, unsigned int gid,
646 const u64 *generation, dev_t dev)
647 {
648 struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
649 struct gfs2_dinode *di;
650 struct buffer_head *dibh;
651
652 dibh = gfs2_meta_new(gl, inum->no_addr);
653 gfs2_trans_add_bh(gl, dibh, 1);
654 gfs2_metatype_set(dibh, GFS2_METATYPE_DI, GFS2_FORMAT_DI);
655 gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode));
656 di = (struct gfs2_dinode *)dibh->b_data;
657
658 di->di_num.no_formal_ino = cpu_to_be64(inum->no_formal_ino);
659 di->di_num.no_addr = cpu_to_be64(inum->no_addr);
660 di->di_mode = cpu_to_be32(mode);
661 di->di_uid = cpu_to_be32(uid);
662 di->di_gid = cpu_to_be32(gid);
663 di->di_nlink = 0;
664 di->di_size = 0;
665 di->di_blocks = cpu_to_be64(1);
666 di->di_atime = di->di_mtime = di->di_ctime = cpu_to_be64(get_seconds());
667 di->di_major = cpu_to_be32(MAJOR(dev));
668 di->di_minor = cpu_to_be32(MINOR(dev));
669 di->di_goal_meta = di->di_goal_data = cpu_to_be64(inum->no_addr);
670 di->di_generation = cpu_to_be64(*generation);
671 di->di_flags = 0;
672
673 if (S_ISREG(mode)) {
674 if ((dip->i_di.di_flags & GFS2_DIF_INHERIT_JDATA) ||
675 gfs2_tune_get(sdp, gt_new_files_jdata))
676 di->di_flags |= cpu_to_be32(GFS2_DIF_JDATA);
677 if ((dip->i_di.di_flags & GFS2_DIF_INHERIT_DIRECTIO) ||
678 gfs2_tune_get(sdp, gt_new_files_directio))
679 di->di_flags |= cpu_to_be32(GFS2_DIF_DIRECTIO);
680 } else if (S_ISDIR(mode)) {
681 di->di_flags |= cpu_to_be32(dip->i_di.di_flags &
682 GFS2_DIF_INHERIT_DIRECTIO);
683 di->di_flags |= cpu_to_be32(dip->i_di.di_flags &
684 GFS2_DIF_INHERIT_JDATA);
685 }
686
687 di->__pad1 = 0;
688 di->di_payload_format = cpu_to_be32(S_ISDIR(mode) ? GFS2_FORMAT_DE : 0);
689 di->di_height = 0;
690 di->__pad2 = 0;
691 di->__pad3 = 0;
692 di->di_depth = 0;
693 di->di_entries = 0;
694 memset(&di->__pad4, 0, sizeof(di->__pad4));
695 di->di_eattr = 0;
696 memset(&di->di_reserved, 0, sizeof(di->di_reserved));
697
698 brelse(dibh);
699 }
700
701 static int make_dinode(struct gfs2_inode *dip, struct gfs2_glock *gl,
702 unsigned int mode, const struct gfs2_inum_host *inum,
703 const u64 *generation, dev_t dev)
704 {
705 struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
706 unsigned int uid, gid;
707 int error;
708
709 munge_mode_uid_gid(dip, &mode, &uid, &gid);
710 gfs2_alloc_get(dip);
711
712 error = gfs2_quota_lock(dip, uid, gid);
713 if (error)
714 goto out;
715
716 error = gfs2_quota_check(dip, uid, gid);
717 if (error)
718 goto out_quota;
719
720 error = gfs2_trans_begin(sdp, RES_DINODE + RES_QUOTA, 0);
721 if (error)
722 goto out_quota;
723
724 init_dinode(dip, gl, inum, mode, uid, gid, generation, dev);
725 gfs2_quota_change(dip, +1, uid, gid);
726 gfs2_trans_end(sdp);
727
728 out_quota:
729 gfs2_quota_unlock(dip);
730 out:
731 gfs2_alloc_put(dip);
732 return error;
733 }
734
735 static int link_dinode(struct gfs2_inode *dip, const struct qstr *name,
736 struct gfs2_inode *ip)
737 {
738 struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
739 struct gfs2_alloc *al;
740 int alloc_required;
741 struct buffer_head *dibh;
742 int error;
743
744 al = gfs2_alloc_get(dip);
745
746 error = gfs2_quota_lock(dip, NO_QUOTA_CHANGE, NO_QUOTA_CHANGE);
747 if (error)
748 goto fail;
749
750 error = alloc_required = gfs2_diradd_alloc_required(&dip->i_inode, name);
751 if (alloc_required < 0)
752 goto fail;
753 if (alloc_required) {
754 error = gfs2_quota_check(dip, dip->i_inode.i_uid, dip->i_inode.i_gid);
755 if (error)
756 goto fail_quota_locks;
757
758 al->al_requested = sdp->sd_max_dirres;
759
760 error = gfs2_inplace_reserve(dip);
761 if (error)
762 goto fail_quota_locks;
763
764 error = gfs2_trans_begin(sdp, sdp->sd_max_dirres +
765 al->al_rgd->rd_length +
766 2 * RES_DINODE +
767 RES_STATFS + RES_QUOTA, 0);
768 if (error)
769 goto fail_ipreserv;
770 } else {
771 error = gfs2_trans_begin(sdp, RES_LEAF + 2 * RES_DINODE, 0);
772 if (error)
773 goto fail_quota_locks;
774 }
775
776 error = gfs2_dir_add(&dip->i_inode, name, ip, IF2DT(ip->i_inode.i_mode));
777 if (error)
778 goto fail_end_trans;
779
780 error = gfs2_meta_inode_buffer(ip, &dibh);
781 if (error)
782 goto fail_end_trans;
783 ip->i_inode.i_nlink = 1;
784 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
785 gfs2_dinode_out(ip, dibh->b_data);
786 brelse(dibh);
787 return 0;
788
789 fail_end_trans:
790 gfs2_trans_end(sdp);
791
792 fail_ipreserv:
793 if (dip->i_alloc.al_rgd)
794 gfs2_inplace_release(dip);
795
796 fail_quota_locks:
797 gfs2_quota_unlock(dip);
798
799 fail:
800 gfs2_alloc_put(dip);
801 return error;
802 }
803
804 static int gfs2_security_init(struct gfs2_inode *dip, struct gfs2_inode *ip)
805 {
806 int err;
807 size_t len;
808 void *value;
809 char *name;
810 struct gfs2_ea_request er;
811
812 err = security_inode_init_security(&ip->i_inode, &dip->i_inode,
813 &name, &value, &len);
814
815 if (err) {
816 if (err == -EOPNOTSUPP)
817 return 0;
818 return err;
819 }
820
821 memset(&er, 0, sizeof(struct gfs2_ea_request));
822
823 er.er_type = GFS2_EATYPE_SECURITY;
824 er.er_name = name;
825 er.er_data = value;
826 er.er_name_len = strlen(name);
827 er.er_data_len = len;
828
829 err = gfs2_ea_set_i(ip, &er);
830
831 kfree(value);
832 kfree(name);
833
834 return err;
835 }
836
837 /**
838 * gfs2_createi - Create a new inode
839 * @ghs: An array of two holders
840 * @name: The name of the new file
841 * @mode: the permissions on the new inode
842 *
843 * @ghs[0] is an initialized holder for the directory
844 * @ghs[1] is the holder for the inode lock
845 *
846 * If the return value is not NULL, the glocks on both the directory and the new
847 * file are held. A transaction has been started and an inplace reservation
848 * is held, as well.
849 *
850 * Returns: An inode
851 */
852
853 struct inode *gfs2_createi(struct gfs2_holder *ghs, const struct qstr *name,
854 unsigned int mode, dev_t dev)
855 {
856 struct inode *inode;
857 struct gfs2_inode *dip = ghs->gh_gl->gl_object;
858 struct inode *dir = &dip->i_inode;
859 struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
860 struct gfs2_inum_host inum = { .no_addr = 0, .no_formal_ino = 0 };
861 int error;
862 u64 generation;
863
864 if (!name->len || name->len > GFS2_FNAMESIZE)
865 return ERR_PTR(-ENAMETOOLONG);
866
867 gfs2_holder_reinit(LM_ST_EXCLUSIVE, 0, ghs);
868 error = gfs2_glock_nq(ghs);
869 if (error)
870 goto fail;
871
872 error = create_ok(dip, name, mode);
873 if (error)
874 goto fail_gunlock;
875
876 error = pick_formal_ino(sdp, &inum.no_formal_ino);
877 if (error)
878 goto fail_gunlock;
879
880 error = alloc_dinode(dip, &inum.no_addr, &generation);
881 if (error)
882 goto fail_gunlock;
883
884 error = gfs2_glock_nq_num(sdp, inum.no_addr, &gfs2_inode_glops,
885 LM_ST_EXCLUSIVE, GL_SKIP, ghs + 1);
886 if (error)
887 goto fail_gunlock;
888
889 error = make_dinode(dip, ghs[1].gh_gl, mode, &inum, &generation, dev);
890 if (error)
891 goto fail_gunlock2;
892
893 inode = gfs2_inode_lookup(dir->i_sb, inum.no_addr, IF2DT(mode));
894 if (IS_ERR(inode))
895 goto fail_gunlock2;
896
897 error = gfs2_inode_refresh(GFS2_I(inode));
898 if (error)
899 goto fail_iput;
900
901 error = gfs2_acl_create(dip, GFS2_I(inode));
902 if (error)
903 goto fail_iput;
904
905 error = gfs2_security_init(dip, GFS2_I(inode));
906 if (error)
907 goto fail_iput;
908
909 error = link_dinode(dip, name, GFS2_I(inode));
910 if (error)
911 goto fail_iput;
912
913 if (!inode)
914 return ERR_PTR(-ENOMEM);
915 return inode;
916
917 fail_iput:
918 iput(inode);
919 fail_gunlock2:
920 gfs2_glock_dq_uninit(ghs + 1);
921 fail_gunlock:
922 gfs2_glock_dq(ghs);
923 fail:
924 return ERR_PTR(error);
925 }
926
927 /**
928 * gfs2_rmdiri - Remove a directory
929 * @dip: The parent directory of the directory to be removed
930 * @name: The name of the directory to be removed
931 * @ip: The GFS2 inode of the directory to be removed
932 *
933 * Assumes Glocks on dip and ip are held
934 *
935 * Returns: errno
936 */
937
938 int gfs2_rmdiri(struct gfs2_inode *dip, const struct qstr *name,
939 struct gfs2_inode *ip)
940 {
941 struct qstr dotname;
942 int error;
943
944 if (ip->i_di.di_entries != 2) {
945 if (gfs2_consist_inode(ip))
946 gfs2_dinode_print(ip);
947 return -EIO;
948 }
949
950 error = gfs2_dir_del(dip, name);
951 if (error)
952 return error;
953
954 error = gfs2_change_nlink(dip, -1);
955 if (error)
956 return error;
957
958 gfs2_str2qstr(&dotname, ".");
959 error = gfs2_dir_del(ip, &dotname);
960 if (error)
961 return error;
962
963 gfs2_str2qstr(&dotname, "..");
964 error = gfs2_dir_del(ip, &dotname);
965 if (error)
966 return error;
967
968 /* It looks odd, but it really should be done twice */
969 error = gfs2_change_nlink(ip, -1);
970 if (error)
971 return error;
972
973 error = gfs2_change_nlink(ip, -1);
974 if (error)
975 return error;
976
977 return error;
978 }
979
980 /*
981 * gfs2_unlink_ok - check to see that a inode is still in a directory
982 * @dip: the directory
983 * @name: the name of the file
984 * @ip: the inode
985 *
986 * Assumes that the lock on (at least) @dip is held.
987 *
988 * Returns: 0 if the parent/child relationship is correct, errno if it isn't
989 */
990
991 int gfs2_unlink_ok(struct gfs2_inode *dip, const struct qstr *name,
992 const struct gfs2_inode *ip)
993 {
994 int error;
995
996 if (IS_IMMUTABLE(&ip->i_inode) || IS_APPEND(&ip->i_inode))
997 return -EPERM;
998
999 if ((dip->i_inode.i_mode & S_ISVTX) &&
1000 dip->i_inode.i_uid != current->fsuid &&
1001 ip->i_inode.i_uid != current->fsuid && !capable(CAP_FOWNER))
1002 return -EPERM;
1003
1004 if (IS_APPEND(&dip->i_inode))
1005 return -EPERM;
1006
1007 error = permission(&dip->i_inode, MAY_WRITE | MAY_EXEC, NULL);
1008 if (error)
1009 return error;
1010
1011 error = gfs2_dir_check(&dip->i_inode, name, ip);
1012 if (error)
1013 return error;
1014
1015 return 0;
1016 }
1017
1018 /*
1019 * gfs2_ok_to_move - check if it's ok to move a directory to another directory
1020 * @this: move this
1021 * @to: to here
1022 *
1023 * Follow @to back to the root and make sure we don't encounter @this
1024 * Assumes we already hold the rename lock.
1025 *
1026 * Returns: errno
1027 */
1028
1029 int gfs2_ok_to_move(struct gfs2_inode *this, struct gfs2_inode *to)
1030 {
1031 struct inode *dir = &to->i_inode;
1032 struct super_block *sb = dir->i_sb;
1033 struct inode *tmp;
1034 struct qstr dotdot;
1035 int error = 0;
1036
1037 gfs2_str2qstr(&dotdot, "..");
1038
1039 igrab(dir);
1040
1041 for (;;) {
1042 if (dir == &this->i_inode) {
1043 error = -EINVAL;
1044 break;
1045 }
1046 if (dir == sb->s_root->d_inode) {
1047 error = 0;
1048 break;
1049 }
1050
1051 tmp = gfs2_lookupi(dir, &dotdot, 1, NULL);
1052 if (IS_ERR(tmp)) {
1053 error = PTR_ERR(tmp);
1054 break;
1055 }
1056
1057 iput(dir);
1058 dir = tmp;
1059 }
1060
1061 iput(dir);
1062
1063 return error;
1064 }
1065
1066 /**
1067 * gfs2_readlinki - return the contents of a symlink
1068 * @ip: the symlink's inode
1069 * @buf: a pointer to the buffer to be filled
1070 * @len: a pointer to the length of @buf
1071 *
1072 * If @buf is too small, a piece of memory is kmalloc()ed and needs
1073 * to be freed by the caller.
1074 *
1075 * Returns: errno
1076 */
1077
1078 int gfs2_readlinki(struct gfs2_inode *ip, char **buf, unsigned int *len)
1079 {
1080 struct gfs2_holder i_gh;
1081 struct buffer_head *dibh;
1082 unsigned int x;
1083 int error;
1084
1085 gfs2_holder_init(ip->i_gl, LM_ST_SHARED, GL_ATIME, &i_gh);
1086 error = gfs2_glock_nq_atime(&i_gh);
1087 if (error) {
1088 gfs2_holder_uninit(&i_gh);
1089 return error;
1090 }
1091
1092 if (!ip->i_di.di_size) {
1093 gfs2_consist_inode(ip);
1094 error = -EIO;
1095 goto out;
1096 }
1097
1098 error = gfs2_meta_inode_buffer(ip, &dibh);
1099 if (error)
1100 goto out;
1101
1102 x = ip->i_di.di_size + 1;
1103 if (x > *len) {
1104 *buf = kmalloc(x, GFP_KERNEL);
1105 if (!*buf) {
1106 error = -ENOMEM;
1107 goto out_brelse;
1108 }
1109 }
1110
1111 memcpy(*buf, dibh->b_data + sizeof(struct gfs2_dinode), x);
1112 *len = x;
1113
1114 out_brelse:
1115 brelse(dibh);
1116 out:
1117 gfs2_glock_dq_uninit(&i_gh);
1118 return error;
1119 }
1120
1121 /**
1122 * gfs2_glock_nq_atime - Acquire a hold on an inode's glock, and
1123 * conditionally update the inode's atime
1124 * @gh: the holder to acquire
1125 *
1126 * Tests atime (access time) for gfs2_read, gfs2_readdir and gfs2_mmap
1127 * Update if the difference between the current time and the inode's current
1128 * atime is greater than an interval specified at mount.
1129 *
1130 * Returns: errno
1131 */
1132
1133 int gfs2_glock_nq_atime(struct gfs2_holder *gh)
1134 {
1135 struct gfs2_glock *gl = gh->gh_gl;
1136 struct gfs2_sbd *sdp = gl->gl_sbd;
1137 struct gfs2_inode *ip = gl->gl_object;
1138 s64 curtime, quantum = gfs2_tune_get(sdp, gt_atime_quantum);
1139 unsigned int state;
1140 int flags;
1141 int error;
1142
1143 if (gfs2_assert_warn(sdp, gh->gh_flags & GL_ATIME) ||
1144 gfs2_assert_warn(sdp, !(gh->gh_flags & GL_ASYNC)) ||
1145 gfs2_assert_warn(sdp, gl->gl_ops == &gfs2_inode_glops))
1146 return -EINVAL;
1147
1148 state = gh->gh_state;
1149 flags = gh->gh_flags;
1150
1151 error = gfs2_glock_nq(gh);
1152 if (error)
1153 return error;
1154
1155 if (test_bit(SDF_NOATIME, &sdp->sd_flags) ||
1156 (sdp->sd_vfs->s_flags & MS_RDONLY))
1157 return 0;
1158
1159 curtime = get_seconds();
1160 if (curtime - ip->i_inode.i_atime.tv_sec >= quantum) {
1161 gfs2_glock_dq(gh);
1162 gfs2_holder_reinit(LM_ST_EXCLUSIVE, gh->gh_flags & ~LM_FLAG_ANY,
1163 gh);
1164 error = gfs2_glock_nq(gh);
1165 if (error)
1166 return error;
1167
1168 /* Verify that atime hasn't been updated while we were
1169 trying to get exclusive lock. */
1170
1171 curtime = get_seconds();
1172 if (curtime - ip->i_inode.i_atime.tv_sec >= quantum) {
1173 struct buffer_head *dibh;
1174 struct gfs2_dinode *di;
1175
1176 error = gfs2_trans_begin(sdp, RES_DINODE, 0);
1177 if (error == -EROFS)
1178 return 0;
1179 if (error)
1180 goto fail;
1181
1182 error = gfs2_meta_inode_buffer(ip, &dibh);
1183 if (error)
1184 goto fail_end_trans;
1185
1186 ip->i_inode.i_atime.tv_sec = curtime;
1187
1188 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
1189 di = (struct gfs2_dinode *)dibh->b_data;
1190 di->di_atime = cpu_to_be64(ip->i_inode.i_atime.tv_sec);
1191 brelse(dibh);
1192
1193 gfs2_trans_end(sdp);
1194 }
1195
1196 /* If someone else has asked for the glock,
1197 unlock and let them have it. Then reacquire
1198 in the original state. */
1199 if (gfs2_glock_is_blocking(gl)) {
1200 gfs2_glock_dq(gh);
1201 gfs2_holder_reinit(state, flags, gh);
1202 return gfs2_glock_nq(gh);
1203 }
1204 }
1205
1206 return 0;
1207
1208 fail_end_trans:
1209 gfs2_trans_end(sdp);
1210 fail:
1211 gfs2_glock_dq(gh);
1212 return error;
1213 }
1214
1215 static int
1216 __gfs2_setattr_simple(struct gfs2_inode *ip, struct iattr *attr)
1217 {
1218 struct buffer_head *dibh;
1219 int error;
1220
1221 error = gfs2_meta_inode_buffer(ip, &dibh);
1222 if (!error) {
1223 error = inode_setattr(&ip->i_inode, attr);
1224 gfs2_assert_warn(GFS2_SB(&ip->i_inode), !error);
1225 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
1226 gfs2_dinode_out(ip, dibh->b_data);
1227 brelse(dibh);
1228 }
1229 return error;
1230 }
1231
1232 /**
1233 * gfs2_setattr_simple -
1234 * @ip:
1235 * @attr:
1236 *
1237 * Called with a reference on the vnode.
1238 *
1239 * Returns: errno
1240 */
1241
1242 int gfs2_setattr_simple(struct gfs2_inode *ip, struct iattr *attr)
1243 {
1244 int error;
1245
1246 if (current->journal_info)
1247 return __gfs2_setattr_simple(ip, attr);
1248
1249 error = gfs2_trans_begin(GFS2_SB(&ip->i_inode), RES_DINODE, 0);
1250 if (error)
1251 return error;
1252
1253 error = __gfs2_setattr_simple(ip, attr);
1254 gfs2_trans_end(GFS2_SB(&ip->i_inode));
1255 return error;
1256 }
1257
1258 void gfs2_dinode_out(const struct gfs2_inode *ip, void *buf)
1259 {
1260 const struct gfs2_dinode_host *di = &ip->i_di;
1261 struct gfs2_dinode *str = buf;
1262
1263 str->di_header.mh_magic = cpu_to_be32(GFS2_MAGIC);
1264 str->di_header.mh_type = cpu_to_be32(GFS2_METATYPE_DI);
1265 str->di_header.__pad0 = 0;
1266 str->di_header.mh_format = cpu_to_be32(GFS2_FORMAT_DI);
1267 str->di_header.__pad1 = 0;
1268 str->di_num.no_addr = cpu_to_be64(ip->i_no_addr);
1269 str->di_num.no_formal_ino = cpu_to_be64(ip->i_no_formal_ino);
1270 str->di_mode = cpu_to_be32(ip->i_inode.i_mode);
1271 str->di_uid = cpu_to_be32(ip->i_inode.i_uid);
1272 str->di_gid = cpu_to_be32(ip->i_inode.i_gid);
1273 str->di_nlink = cpu_to_be32(ip->i_inode.i_nlink);
1274 str->di_size = cpu_to_be64(di->di_size);
1275 str->di_blocks = cpu_to_be64(di->di_blocks);
1276 str->di_atime = cpu_to_be64(ip->i_inode.i_atime.tv_sec);
1277 str->di_mtime = cpu_to_be64(ip->i_inode.i_mtime.tv_sec);
1278 str->di_ctime = cpu_to_be64(ip->i_inode.i_ctime.tv_sec);
1279
1280 str->di_goal_meta = cpu_to_be64(di->di_goal_meta);
1281 str->di_goal_data = cpu_to_be64(di->di_goal_data);
1282 str->di_generation = cpu_to_be64(di->di_generation);
1283
1284 str->di_flags = cpu_to_be32(di->di_flags);
1285 str->di_height = cpu_to_be16(di->di_height);
1286 str->di_payload_format = cpu_to_be32(S_ISDIR(ip->i_inode.i_mode) &&
1287 !(ip->i_di.di_flags & GFS2_DIF_EXHASH) ?
1288 GFS2_FORMAT_DE : 0);
1289 str->di_depth = cpu_to_be16(di->di_depth);
1290 str->di_entries = cpu_to_be32(di->di_entries);
1291
1292 str->di_eattr = cpu_to_be64(di->di_eattr);
1293 }
1294
1295 void gfs2_dinode_print(const struct gfs2_inode *ip)
1296 {
1297 const struct gfs2_dinode_host *di = &ip->i_di;
1298
1299 printk(KERN_INFO " no_formal_ino = %llu\n",
1300 (unsigned long long)ip->i_no_formal_ino);
1301 printk(KERN_INFO " no_addr = %llu\n",
1302 (unsigned long long)ip->i_no_addr);
1303 printk(KERN_INFO " di_size = %llu\n", (unsigned long long)di->di_size);
1304 printk(KERN_INFO " di_blocks = %llu\n",
1305 (unsigned long long)di->di_blocks);
1306 printk(KERN_INFO " di_goal_meta = %llu\n",
1307 (unsigned long long)di->di_goal_meta);
1308 printk(KERN_INFO " di_goal_data = %llu\n",
1309 (unsigned long long)di->di_goal_data);
1310 printk(KERN_INFO " di_flags = 0x%.8X\n", di->di_flags);
1311 printk(KERN_INFO " di_height = %u\n", di->di_height);
1312 printk(KERN_INFO " di_depth = %u\n", di->di_depth);
1313 printk(KERN_INFO " di_entries = %u\n", di->di_entries);
1314 printk(KERN_INFO " di_eattr = %llu\n",
1315 (unsigned long long)di->di_eattr);
1316 }
1317
Linux kernel - Deliverables
This page took 0.059469 seconds and 6 git commands to generate.