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