← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-ti-omap4/precise

« back to all changes in this revision

Viewing changes to fs/gfs2/inode.c

  • Committer: Bazaar Package Importer
  • Author(s): Paolo Pisati
  • Date: 2011-06-29 15:23:51 UTC
  • mfrom: (26.1.1 natty-proposed)
  • Revision ID: james.westby@ubuntu.com-20110629152351-xs96tm303d95rpbk
Tags: 3.0.0-1200.2
* Rebased against 3.0.0-6.7
* BSP from TI based on 3.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
fs/gfs2/inode.c
1
1
/*
2
2
 * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
3
 
 * Copyright (C) 2004-2008 Red Hat, Inc.  All rights reserved.
 
3
 * Copyright (C) 2004-2011 Red Hat, Inc.  All rights reserved.
4
4
 *
5
5
 * This copyrighted material is made available to anyone wishing to use,
6
6
 * modify, copy, or redistribute it subject to the terms and conditions
7
7
 * of the GNU General Public License version 2.
8
8
 */
9
9
 
10
 
#include <linux/sched.h>
11
10
#include <linux/slab.h>
12
11
#include <linux/spinlock.h>
13
12
#include <linux/completion.h>
14
13
#include <linux/buffer_head.h>
 
14
#include <linux/namei.h>
 
15
#include <linux/mm.h>
 
16
#include <linux/xattr.h>
15
17
#include <linux/posix_acl.h>
16
 
#include <linux/sort.h>
17
18
#include <linux/gfs2_ondisk.h>
18
19
#include <linux/crc32.h>
 
20
#include <linux/fiemap.h>
19
21
#include <linux/security.h>
20
 
#include <linux/time.h>
 
22
#include <asm/uaccess.h>
21
23
 
22
24
#include "gfs2.h"
23
25
#include "incore.h"
26
28
#include "dir.h"
27
29
#include "xattr.h"
28
30
#include "glock.h"
29
 
#include "glops.h"
30
31
#include "inode.h"
31
 
#include "log.h"
32
32
#include "meta_io.h"
33
33
#include "quota.h"
34
34
#include "rgrp.h"
35
35
#include "trans.h"
36
36
#include "util.h"
 
37
#include "super.h"
 
38
#include "glops.h"
37
39
 
38
 
struct gfs2_inum_range_host {
39
 
        u64 ir_start;
40
 
        u64 ir_length;
 
40
struct gfs2_skip_data {
 
41
        u64 no_addr;
 
42
        int skipped;
 
43
        int non_block;
41
44
};
42
45
 
43
46
static int iget_test(struct inode *inode, void *opaque)
44
47
{
45
48
        struct gfs2_inode *ip = GFS2_I(inode);
46
 
        u64 *no_addr = opaque;
 
49
        struct gfs2_skip_data *data = opaque;
47
50
 
48
 
        if (ip->i_no_addr == *no_addr)
 
51
        if (ip->i_no_addr == data->no_addr) {
 
52
                if (data->non_block &&
 
53
                    inode->i_state & (I_FREEING|I_CLEAR|I_WILL_FREE)) {
 
54
                        data->skipped = 1;
 
55
                        return 0;
 
56
                }
49
57
                return 1;
50
 
 
 
58
        }
51
59
        return 0;
52
60
}
53
61
 
54
62
static int iget_set(struct inode *inode, void *opaque)
55
63
{
56
64
        struct gfs2_inode *ip = GFS2_I(inode);
57
 
        u64 *no_addr = opaque;
 
65
        struct gfs2_skip_data *data = opaque;
58
66
 
59
 
        inode->i_ino = (unsigned long)*no_addr;
60
 
        ip->i_no_addr = *no_addr;
 
67
        if (data->skipped)
 
68
                return -ENOENT;
 
69
        inode->i_ino = (unsigned long)(data->no_addr);
 
70
        ip->i_no_addr = data->no_addr;
61
71
        return 0;
62
72
}
63
73
 
64
 
struct inode *gfs2_ilookup(struct super_block *sb, u64 no_addr)
 
74
struct inode *gfs2_ilookup(struct super_block *sb, u64 no_addr, int non_block)
65
75
{
66
76
        unsigned long hash = (unsigned long)no_addr;
67
 
        return ilookup5(sb, hash, iget_test, &no_addr);
 
77
        struct gfs2_skip_data data;
 
78
 
 
79
        data.no_addr = no_addr;
 
80
        data.skipped = 0;
 
81
        data.non_block = non_block;
 
82
        return ilookup5(sb, hash, iget_test, &data);
68
83
}
69
84
 
70
 
static struct inode *gfs2_iget(struct super_block *sb, u64 no_addr)
 
85
static struct inode *gfs2_iget(struct super_block *sb, u64 no_addr,
 
86
                               int non_block)
71
87
{
 
88
        struct gfs2_skip_data data;
72
89
        unsigned long hash = (unsigned long)no_addr;
73
 
        return iget5_locked(sb, hash, iget_test, iget_set, &no_addr);
 
90
 
 
91
        data.no_addr = no_addr;
 
92
        data.skipped = 0;
 
93
        data.non_block = non_block;
 
94
        return iget5_locked(sb, hash, iget_test, iget_set, &data);
74
95
}
75
96
 
76
97
/**
111
132
 * @sb: The super block
112
133
 * @no_addr: The inode number
113
134
 * @type: The type of the inode
 
135
 * non_block: Can we block on inodes that are being freed?
114
136
 *
115
137
 * Returns: A VFS inode, or an error
116
138
 */
117
139
 
118
140
struct inode *gfs2_inode_lookup(struct super_block *sb, unsigned int type,
119
 
                                u64 no_addr, u64 no_formal_ino)
 
141
                                u64 no_addr, u64 no_formal_ino, int non_block)
120
142
{
121
143
        struct inode *inode;
122
144
        struct gfs2_inode *ip;
123
145
        struct gfs2_glock *io_gl = NULL;
124
146
        int error;
125
147
 
126
 
        inode = gfs2_iget(sb, no_addr);
 
148
        inode = gfs2_iget(sb, no_addr, non_block);
127
149
        ip = GFS2_I(inode);
128
150
 
129
151
        if (!inode)
185
207
{
186
208
        struct super_block *sb = sdp->sd_vfs;
187
209
        struct gfs2_holder i_gh;
188
 
        struct inode *inode;
 
210
        struct inode *inode = NULL;
189
211
        int error;
190
212
 
 
213
        /* Must not read in block until block type is verified */
191
214
        error = gfs2_glock_nq_num(sdp, no_addr, &gfs2_inode_glops,
192
 
                                  LM_ST_SHARED, LM_FLAG_ANY, &i_gh);
 
215
                                  LM_ST_EXCLUSIVE, GL_SKIP, &i_gh);
193
216
        if (error)
194
217
                return ERR_PTR(error);
195
218
 
197
220
        if (error)
198
221
                goto fail;
199
222
 
200
 
        inode = gfs2_inode_lookup(sb, DT_UNKNOWN, no_addr, 0);
 
223
        inode = gfs2_inode_lookup(sb, DT_UNKNOWN, no_addr, 0, 1);
201
224
        if (IS_ERR(inode))
202
225
                goto fail;
203
226
 
222
245
        goto fail;
223
246
}
224
247
 
225
 
static int gfs2_dinode_in(struct gfs2_inode *ip, const void *buf)
226
 
{
227
 
        const struct gfs2_dinode *str = buf;
228
 
        struct timespec atime;
229
 
        u16 height, depth;
230
 
 
231
 
        if (unlikely(ip->i_no_addr != be64_to_cpu(str->di_num.no_addr)))
232
 
                goto corrupt;
233
 
        ip->i_no_formal_ino = be64_to_cpu(str->di_num.no_formal_ino);
234
 
        ip->i_inode.i_mode = be32_to_cpu(str->di_mode);
235
 
        ip->i_inode.i_rdev = 0;
236
 
        switch (ip->i_inode.i_mode & S_IFMT) {
237
 
        case S_IFBLK:
238
 
        case S_IFCHR:
239
 
                ip->i_inode.i_rdev = MKDEV(be32_to_cpu(str->di_major),
240
 
                                           be32_to_cpu(str->di_minor));
241
 
                break;
242
 
        };
243
 
 
244
 
        ip->i_inode.i_uid = be32_to_cpu(str->di_uid);
245
 
        ip->i_inode.i_gid = be32_to_cpu(str->di_gid);
246
 
        /*
247
 
         * We will need to review setting the nlink count here in the
248
 
         * light of the forthcoming ro bind mount work. This is a reminder
249
 
         * to do that.
250
 
         */
251
 
        ip->i_inode.i_nlink = be32_to_cpu(str->di_nlink);
252
 
        i_size_write(&ip->i_inode, be64_to_cpu(str->di_size));
253
 
        gfs2_set_inode_blocks(&ip->i_inode, be64_to_cpu(str->di_blocks));
254
 
        atime.tv_sec = be64_to_cpu(str->di_atime);
255
 
        atime.tv_nsec = be32_to_cpu(str->di_atime_nsec);
256
 
        if (timespec_compare(&ip->i_inode.i_atime, &atime) < 0)
257
 
                ip->i_inode.i_atime = atime;
258
 
        ip->i_inode.i_mtime.tv_sec = be64_to_cpu(str->di_mtime);
259
 
        ip->i_inode.i_mtime.tv_nsec = be32_to_cpu(str->di_mtime_nsec);
260
 
        ip->i_inode.i_ctime.tv_sec = be64_to_cpu(str->di_ctime);
261
 
        ip->i_inode.i_ctime.tv_nsec = be32_to_cpu(str->di_ctime_nsec);
262
 
 
263
 
        ip->i_goal = be64_to_cpu(str->di_goal_meta);
264
 
        ip->i_generation = be64_to_cpu(str->di_generation);
265
 
 
266
 
        ip->i_diskflags = be32_to_cpu(str->di_flags);
267
 
        gfs2_set_inode_flags(&ip->i_inode);
268
 
        height = be16_to_cpu(str->di_height);
269
 
        if (unlikely(height > GFS2_MAX_META_HEIGHT))
270
 
                goto corrupt;
271
 
        ip->i_height = (u8)height;
272
 
 
273
 
        depth = be16_to_cpu(str->di_depth);
274
 
        if (unlikely(depth > GFS2_DIR_MAX_DEPTH))
275
 
                goto corrupt;
276
 
        ip->i_depth = (u8)depth;
277
 
        ip->i_entries = be32_to_cpu(str->di_entries);
278
 
 
279
 
        ip->i_eattr = be64_to_cpu(str->di_eattr);
280
 
        if (S_ISREG(ip->i_inode.i_mode))
281
 
                gfs2_set_aops(&ip->i_inode);
282
 
 
283
 
        return 0;
284
 
corrupt:
285
 
        if (gfs2_consist_inode(ip))
286
 
                gfs2_dinode_print(ip);
287
 
        return -EIO;
288
 
}
289
 
 
290
 
/**
291
 
 * gfs2_inode_refresh - Refresh the incore copy of the dinode
292
 
 * @ip: The GFS2 inode
293
 
 *
294
 
 * Returns: errno
295
 
 */
296
 
 
297
 
int gfs2_inode_refresh(struct gfs2_inode *ip)
298
 
{
299
 
        struct buffer_head *dibh;
300
 
        int error;
301
 
 
302
 
        error = gfs2_meta_inode_buffer(ip, &dibh);
303
 
        if (error)
304
 
                return error;
305
 
 
306
 
        if (gfs2_metatype_check(GFS2_SB(&ip->i_inode), dibh, GFS2_METATYPE_DI)) {
307
 
                brelse(dibh);
308
 
                return -EIO;
309
 
        }
310
 
 
311
 
        error = gfs2_dinode_in(ip, dibh->b_data);
312
 
        brelse(dibh);
313
 
        clear_bit(GIF_INVALID, &ip->i_flags);
314
 
 
315
 
        return error;
316
 
}
317
 
 
318
 
int gfs2_dinode_dealloc(struct gfs2_inode *ip)
319
 
{
320
 
        struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
321
 
        struct gfs2_alloc *al;
322
 
        struct gfs2_rgrpd *rgd;
323
 
        int error;
324
 
 
325
 
        if (gfs2_get_inode_blocks(&ip->i_inode) != 1) {
326
 
                if (gfs2_consist_inode(ip))
327
 
                        gfs2_dinode_print(ip);
328
 
                return -EIO;
329
 
        }
330
 
 
331
 
        al = gfs2_alloc_get(ip);
332
 
        if (!al)
333
 
                return -ENOMEM;
334
 
 
335
 
        error = gfs2_quota_hold(ip, NO_QUOTA_CHANGE, NO_QUOTA_CHANGE);
336
 
        if (error)
337
 
                goto out;
338
 
 
339
 
        error = gfs2_rindex_hold(sdp, &al->al_ri_gh);
340
 
        if (error)
341
 
                goto out_qs;
342
 
 
343
 
        rgd = gfs2_blk2rgrpd(sdp, ip->i_no_addr);
344
 
        if (!rgd) {
345
 
                gfs2_consist_inode(ip);
346
 
                error = -EIO;
347
 
                goto out_rindex_relse;
348
 
        }
349
 
 
350
 
        error = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_EXCLUSIVE, 0,
351
 
                                   &al->al_rgd_gh);
352
 
        if (error)
353
 
                goto out_rindex_relse;
354
 
 
355
 
        error = gfs2_trans_begin(sdp, RES_RG_BIT + RES_STATFS + RES_QUOTA, 1);
356
 
        if (error)
357
 
                goto out_rg_gunlock;
358
 
 
359
 
        set_bit(GLF_DIRTY, &ip->i_gl->gl_flags);
360
 
        set_bit(GLF_LFLUSH, &ip->i_gl->gl_flags);
361
 
 
362
 
        gfs2_free_di(rgd, ip);
363
 
 
364
 
        gfs2_trans_end(sdp);
365
 
 
366
 
out_rg_gunlock:
367
 
        gfs2_glock_dq_uninit(&al->al_rgd_gh);
368
 
out_rindex_relse:
369
 
        gfs2_glock_dq_uninit(&al->al_ri_gh);
370
 
out_qs:
371
 
        gfs2_quota_unhold(ip);
372
 
out:
373
 
        gfs2_alloc_put(ip);
374
 
        return error;
375
 
}
376
 
 
377
 
/**
378
 
 * gfs2_change_nlink - Change nlink count on inode
379
 
 * @ip: The GFS2 inode
380
 
 * @diff: The change in the nlink count required
381
 
 *
382
 
 * Returns: errno
383
 
 */
384
 
int gfs2_change_nlink(struct gfs2_inode *ip, int diff)
385
 
{
386
 
        struct buffer_head *dibh;
387
 
        u32 nlink;
388
 
        int error;
389
 
 
390
 
        BUG_ON(diff != 1 && diff != -1);
391
 
        nlink = ip->i_inode.i_nlink + diff;
392
 
 
393
 
        /* If we are reducing the nlink count, but the new value ends up being
394
 
           bigger than the old one, we must have underflowed. */
395
 
        if (diff < 0 && nlink > ip->i_inode.i_nlink) {
396
 
                if (gfs2_consist_inode(ip))
397
 
                        gfs2_dinode_print(ip);
398
 
                return -EIO;
399
 
        }
400
 
 
401
 
        error = gfs2_meta_inode_buffer(ip, &dibh);
402
 
        if (error)
403
 
                return error;
404
 
 
405
 
        if (diff > 0)
406
 
                inc_nlink(&ip->i_inode);
407
 
        else
408
 
                drop_nlink(&ip->i_inode);
409
 
 
410
 
        ip->i_inode.i_ctime = CURRENT_TIME;
411
 
 
412
 
        gfs2_trans_add_bh(ip->i_gl, dibh, 1);
413
 
        gfs2_dinode_out(ip, dibh->b_data);
414
 
        brelse(dibh);
415
 
        mark_inode_dirty(&ip->i_inode);
416
 
 
417
 
        if (ip->i_inode.i_nlink == 0)
418
 
                gfs2_unlink_di(&ip->i_inode); /* mark inode unlinked */
419
 
 
420
 
        return error;
421
 
}
422
248
 
423
249
struct inode *gfs2_lookup_simple(struct inode *dip, const char *name)
424
250
{
517
343
 
518
344
        /*  Don't create entries in an unlinked directory  */
519
345
        if (!dip->i_inode.i_nlink)
520
 
                return -EPERM;
 
346
                return -ENOENT;
521
347
 
522
348
        error = gfs2_dir_check(&dip->i_inode, name, NULL);
523
349
        switch (error) {
587
413
        return error;
588
414
}
589
415
 
 
416
static void gfs2_init_dir(struct buffer_head *dibh,
 
417
                          const struct gfs2_inode *parent)
 
418
{
 
419
        struct gfs2_dinode *di = (struct gfs2_dinode *)dibh->b_data;
 
420
        struct gfs2_dirent *dent = (struct gfs2_dirent *)(di+1);
 
421
 
 
422
        gfs2_qstr2dirent(&gfs2_qdot, GFS2_DIRENT_SIZE(gfs2_qdot.len), dent);
 
423
        dent->de_inum = di->di_num; /* already GFS2 endian */
 
424
        dent->de_type = cpu_to_be16(DT_DIR);
 
425
 
 
426
        dent = (struct gfs2_dirent *)((char*)dent + GFS2_DIRENT_SIZE(1));
 
427
        gfs2_qstr2dirent(&gfs2_qdotdot, dibh->b_size - GFS2_DIRENT_SIZE(1) - sizeof(struct gfs2_dinode), dent);
 
428
        gfs2_inum_out(parent, dent);
 
429
        dent->de_type = cpu_to_be16(DT_DIR);
 
430
        
 
431
}
 
432
 
590
433
/**
591
434
 * init_dinode - Fill in a new dinode structure
592
 
 * @dip: the directory this inode is being created in
 
435
 * @dip: The directory this inode is being created in
593
436
 * @gl: The glock covering the new inode
594
 
 * @inum: the inode number
595
 
 * @mode: the file permissions
596
 
 * @uid:
597
 
 * @gid:
 
437
 * @inum: The inode number
 
438
 * @mode: The file permissions
 
439
 * @uid: The uid of the new inode
 
440
 * @gid: The gid of the new inode
 
441
 * @generation: The generation number of the new inode
 
442
 * @dev: The device number (if a device node)
 
443
 * @symname: The symlink destination (if a symlink)
 
444
 * @size: The inode size (ignored for directories)
 
445
 * @bhp: The buffer head (returned to caller)
598
446
 *
599
447
 */
600
448
 
601
449
static void init_dinode(struct gfs2_inode *dip, struct gfs2_glock *gl,
602
450
                        const struct gfs2_inum_host *inum, unsigned int mode,
603
451
                        unsigned int uid, unsigned int gid,
604
 
                        const u64 *generation, dev_t dev, struct buffer_head **bhp)
 
452
                        const u64 *generation, dev_t dev, const char *symname,
 
453
                        unsigned size, struct buffer_head **bhp)
605
454
{
606
455
        struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
607
456
        struct gfs2_dinode *di;
620
469
        di->di_uid = cpu_to_be32(uid);
621
470
        di->di_gid = cpu_to_be32(gid);
622
471
        di->di_nlink = 0;
623
 
        di->di_size = 0;
 
472
        di->di_size = cpu_to_be64(size);
624
473
        di->di_blocks = cpu_to_be64(1);
625
474
        di->di_atime = di->di_mtime = di->di_ctime = cpu_to_be64(tv.tv_sec);
626
475
        di->di_major = cpu_to_be32(MAJOR(dev));
628
477
        di->di_goal_meta = di->di_goal_data = cpu_to_be64(inum->no_addr);
629
478
        di->di_generation = cpu_to_be64(*generation);
630
479
        di->di_flags = 0;
631
 
 
632
 
        if (S_ISREG(mode)) {
633
 
                if ((dip->i_diskflags & GFS2_DIF_INHERIT_JDATA) ||
634
 
                    gfs2_tune_get(sdp, gt_new_files_jdata))
635
 
                        di->di_flags |= cpu_to_be32(GFS2_DIF_JDATA);
636
 
        } else if (S_ISDIR(mode)) {
637
 
                di->di_flags |= cpu_to_be32(dip->i_diskflags &
638
 
                                            GFS2_DIF_INHERIT_JDATA);
639
 
        }
640
 
 
641
480
        di->__pad1 = 0;
642
481
        di->di_payload_format = cpu_to_be32(S_ISDIR(mode) ? GFS2_FORMAT_DE : 0);
643
482
        di->di_height = 0;
651
490
        di->di_mtime_nsec = cpu_to_be32(tv.tv_nsec);
652
491
        di->di_ctime_nsec = cpu_to_be32(tv.tv_nsec);
653
492
        memset(&di->di_reserved, 0, sizeof(di->di_reserved));
654
 
        
 
493
 
 
494
        switch(mode & S_IFMT) { 
 
495
        case S_IFREG:
 
496
                if ((dip->i_diskflags & GFS2_DIF_INHERIT_JDATA) ||
 
497
                    gfs2_tune_get(sdp, gt_new_files_jdata))
 
498
                        di->di_flags |= cpu_to_be32(GFS2_DIF_JDATA);
 
499
                break;
 
500
        case S_IFDIR:
 
501
                di->di_flags |= cpu_to_be32(dip->i_diskflags &
 
502
                                            GFS2_DIF_INHERIT_JDATA);
 
503
                di->di_flags |= cpu_to_be32(GFS2_DIF_JDATA);
 
504
                di->di_size = cpu_to_be64(sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode));
 
505
                di->di_entries = cpu_to_be32(2);
 
506
                gfs2_init_dir(dibh, dip);
 
507
                break;
 
508
        case S_IFLNK:
 
509
                memcpy(dibh->b_data + sizeof(struct gfs2_dinode), symname, size);
 
510
                break;
 
511
        }
 
512
 
655
513
        set_buffer_uptodate(dibh);
656
514
 
657
515
        *bhp = dibh;
659
517
 
660
518
static int make_dinode(struct gfs2_inode *dip, struct gfs2_glock *gl,
661
519
                       unsigned int mode, const struct gfs2_inum_host *inum,
662
 
                       const u64 *generation, dev_t dev, struct buffer_head **bhp)
 
520
                       const u64 *generation, dev_t dev, const char *symname,
 
521
                       unsigned int size, struct buffer_head **bhp)
663
522
{
664
523
        struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
665
524
        unsigned int uid, gid;
681
540
        if (error)
682
541
                goto out_quota;
683
542
 
684
 
        init_dinode(dip, gl, inum, mode, uid, gid, generation, dev, bhp);
 
543
        init_dinode(dip, gl, inum, mode, uid, gid, generation, dev, symname, size, bhp);
685
544
        gfs2_quota_change(dip, +1, uid, gid);
686
545
        gfs2_trans_end(sdp);
687
546
 
735
594
                        goto fail_quota_locks;
736
595
        }
737
596
 
738
 
        error = gfs2_dir_add(&dip->i_inode, name, ip, IF2DT(ip->i_inode.i_mode));
 
597
        error = gfs2_dir_add(&dip->i_inode, name, ip);
739
598
        if (error)
740
599
                goto fail_end_trans;
741
600
 
742
601
        error = gfs2_meta_inode_buffer(ip, &dibh);
743
602
        if (error)
744
603
                goto fail_end_trans;
745
 
        ip->i_inode.i_nlink = 1;
 
604
        inc_nlink(&ip->i_inode);
 
605
        if (S_ISDIR(ip->i_inode.i_mode))
 
606
                inc_nlink(&ip->i_inode);
746
607
        gfs2_trans_add_bh(ip->i_gl, dibh, 1);
747
608
        gfs2_dinode_out(ip, dibh->b_data);
748
609
        brelse(dibh);
763
624
        return error;
764
625
}
765
626
 
766
 
static int gfs2_security_init(struct gfs2_inode *dip, struct gfs2_inode *ip)
 
627
static int gfs2_security_init(struct gfs2_inode *dip, struct gfs2_inode *ip,
 
628
                              const struct qstr *qstr)
767
629
{
768
630
        int err;
769
631
        size_t len;
770
632
        void *value;
771
633
        char *name;
772
634
 
773
 
        err = security_inode_init_security(&ip->i_inode, &dip->i_inode,
 
635
        err = security_inode_init_security(&ip->i_inode, &dip->i_inode, qstr,
774
636
                                           &name, &value, &len);
775
637
 
776
638
        if (err) {
788
650
}
789
651
 
790
652
/**
791
 
 * gfs2_createi - Create a new inode
792
 
 * @ghs: An array of two holders
793
 
 * @name: The name of the new file
794
 
 * @mode: the permissions on the new inode
795
 
 *
796
 
 * @ghs[0] is an initialized holder for the directory
797
 
 * @ghs[1] is the holder for the inode lock
798
 
 *
799
 
 * If the return value is not NULL, the glocks on both the directory and the new
800
 
 * file are held.  A transaction has been started and an inplace reservation
801
 
 * is held, as well.
802
 
 *
803
 
 * Returns: An inode
 
653
 * gfs2_create_inode - Create a new inode
 
654
 * @dir: The parent directory
 
655
 * @dentry: The new dentry
 
656
 * @mode: The permissions on the new inode
 
657
 * @dev: For device nodes, this is the device number
 
658
 * @symname: For symlinks, this is the link destination
 
659
 * @size: The initial size of the inode (ignored for directories)
 
660
 *
 
661
 * Returns: 0 on success, or error code
804
662
 */
805
663
 
806
 
struct inode *gfs2_createi(struct gfs2_holder *ghs, const struct qstr *name,
807
 
                           unsigned int mode, dev_t dev)
 
664
static int gfs2_create_inode(struct inode *dir, struct dentry *dentry,
 
665
                             unsigned int mode, dev_t dev, const char *symname,
 
666
                             unsigned int size)
808
667
{
 
668
        const struct qstr *name = &dentry->d_name;
 
669
        struct gfs2_holder ghs[2];
809
670
        struct inode *inode = NULL;
810
 
        struct gfs2_inode *dip = ghs->gh_gl->gl_object;
811
 
        struct inode *dir = &dip->i_inode;
 
671
        struct gfs2_inode *dip = GFS2_I(dir);
812
672
        struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
813
673
        struct gfs2_inum_host inum = { .no_addr = 0, .no_formal_ino = 0 };
814
674
        int error;
816
676
        struct buffer_head *bh = NULL;
817
677
 
818
678
        if (!name->len || name->len > GFS2_FNAMESIZE)
819
 
                return ERR_PTR(-ENAMETOOLONG);
 
679
                return -ENAMETOOLONG;
820
680
 
821
 
        gfs2_holder_reinit(LM_ST_EXCLUSIVE, 0, ghs);
822
 
        error = gfs2_glock_nq(ghs);
 
681
        error = gfs2_glock_nq_init(dip->i_gl, LM_ST_EXCLUSIVE, 0, ghs);
823
682
        if (error)
824
683
                goto fail;
825
684
 
837
696
        if (error)
838
697
                goto fail_gunlock;
839
698
 
840
 
        error = make_dinode(dip, ghs[1].gh_gl, mode, &inum, &generation, dev, &bh);
 
699
        error = make_dinode(dip, ghs[1].gh_gl, mode, &inum, &generation, dev, symname, size, &bh);
841
700
        if (error)
842
701
                goto fail_gunlock2;
843
702
 
844
703
        inode = gfs2_inode_lookup(dir->i_sb, IF2DT(mode), inum.no_addr,
845
 
                                  inum.no_formal_ino);
 
704
                                  inum.no_formal_ino, 0);
846
705
        if (IS_ERR(inode))
847
706
                goto fail_gunlock2;
848
707
 
854
713
        if (error)
855
714
                goto fail_gunlock2;
856
715
 
857
 
        error = gfs2_security_init(dip, GFS2_I(inode));
 
716
        error = gfs2_security_init(dip, GFS2_I(inode), name);
858
717
        if (error)
859
718
                goto fail_gunlock2;
860
719
 
864
723
 
865
724
        if (bh)
866
725
                brelse(bh);
867
 
        return inode;
 
726
 
 
727
        gfs2_trans_end(sdp);
 
728
        if (dip->i_alloc->al_rgd)
 
729
                gfs2_inplace_release(dip);
 
730
        gfs2_quota_unlock(dip);
 
731
        gfs2_alloc_put(dip);
 
732
        gfs2_glock_dq_uninit_m(2, ghs);
 
733
        mark_inode_dirty(inode);
 
734
        d_instantiate(dentry, inode);
 
735
        return 0;
868
736
 
869
737
fail_gunlock2:
870
738
        gfs2_glock_dq_uninit(ghs + 1);
871
739
        if (inode && !IS_ERR(inode))
872
740
                iput(inode);
873
741
fail_gunlock:
874
 
        gfs2_glock_dq(ghs);
 
742
        gfs2_glock_dq_uninit(ghs);
875
743
fail:
876
744
        if (bh)
877
745
                brelse(bh);
878
 
        return ERR_PTR(error);
 
746
        return error;
 
747
}
 
748
 
 
749
/**
 
750
 * gfs2_create - Create a file
 
751
 * @dir: The directory in which to create the file
 
752
 * @dentry: The dentry of the new file
 
753
 * @mode: The mode of the new file
 
754
 *
 
755
 * Returns: errno
 
756
 */
 
757
 
 
758
static int gfs2_create(struct inode *dir, struct dentry *dentry,
 
759
                       int mode, struct nameidata *nd)
 
760
{
 
761
        struct inode *inode;
 
762
        int ret;
 
763
 
 
764
        for (;;) {
 
765
                ret = gfs2_create_inode(dir, dentry, S_IFREG | mode, 0, NULL, 0);
 
766
                if (ret != -EEXIST || (nd && (nd->flags & LOOKUP_EXCL)))
 
767
                        return ret;
 
768
 
 
769
                inode = gfs2_lookupi(dir, &dentry->d_name, 0);
 
770
                if (inode) {
 
771
                        if (!IS_ERR(inode))
 
772
                                break;
 
773
                        return PTR_ERR(inode);
 
774
                }
 
775
        }
 
776
 
 
777
        d_instantiate(dentry, inode);
 
778
        return 0;
 
779
}
 
780
 
 
781
/**
 
782
 * gfs2_lookup - Look up a filename in a directory and return its inode
 
783
 * @dir: The directory inode
 
784
 * @dentry: The dentry of the new inode
 
785
 * @nd: passed from Linux VFS, ignored by us
 
786
 *
 
787
 * Called by the VFS layer. Lock dir and call gfs2_lookupi()
 
788
 *
 
789
 * Returns: errno
 
790
 */
 
791
 
 
792
static struct dentry *gfs2_lookup(struct inode *dir, struct dentry *dentry,
 
793
                                  struct nameidata *nd)
 
794
{
 
795
        struct inode *inode = NULL;
 
796
 
 
797
        inode = gfs2_lookupi(dir, &dentry->d_name, 0);
 
798
        if (inode && IS_ERR(inode))
 
799
                return ERR_CAST(inode);
 
800
 
 
801
        if (inode) {
 
802
                struct gfs2_glock *gl = GFS2_I(inode)->i_gl;
 
803
                struct gfs2_holder gh;
 
804
                int error;
 
805
                error = gfs2_glock_nq_init(gl, LM_ST_SHARED, LM_FLAG_ANY, &gh);
 
806
                if (error) {
 
807
                        iput(inode);
 
808
                        return ERR_PTR(error);
 
809
                }
 
810
                gfs2_glock_dq_uninit(&gh);
 
811
                return d_splice_alias(inode, dentry);
 
812
        }
 
813
        d_add(dentry, inode);
 
814
 
 
815
        return NULL;
 
816
}
 
817
 
 
818
/**
 
819
 * gfs2_link - Link to a file
 
820
 * @old_dentry: The inode to link
 
821
 * @dir: Add link to this directory
 
822
 * @dentry: The name of the link
 
823
 *
 
824
 * Link the inode in "old_dentry" into the directory "dir" with the
 
825
 * name in "dentry".
 
826
 *
 
827
 * Returns: errno
 
828
 */
 
829
 
 
830
static int gfs2_link(struct dentry *old_dentry, struct inode *dir,
 
831
                     struct dentry *dentry)
 
832
{
 
833
        struct gfs2_inode *dip = GFS2_I(dir);
 
834
        struct gfs2_sbd *sdp = GFS2_SB(dir);
 
835
        struct inode *inode = old_dentry->d_inode;
 
836
        struct gfs2_inode *ip = GFS2_I(inode);
 
837
        struct gfs2_holder ghs[2];
 
838
        struct buffer_head *dibh;
 
839
        int alloc_required;
 
840
        int error;
 
841
 
 
842
        if (S_ISDIR(inode->i_mode))
 
843
                return -EPERM;
 
844
 
 
845
        gfs2_holder_init(dip->i_gl, LM_ST_EXCLUSIVE, 0, ghs);
 
846
        gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + 1);
 
847
 
 
848
        error = gfs2_glock_nq(ghs); /* parent */
 
849
        if (error)
 
850
                goto out_parent;
 
851
 
 
852
        error = gfs2_glock_nq(ghs + 1); /* child */
 
853
        if (error)
 
854
                goto out_child;
 
855
 
 
856
        error = -ENOENT;
 
857
        if (inode->i_nlink == 0)
 
858
                goto out_gunlock;
 
859
 
 
860
        error = gfs2_permission(dir, MAY_WRITE | MAY_EXEC, 0);
 
861
        if (error)
 
862
                goto out_gunlock;
 
863
 
 
864
        error = gfs2_dir_check(dir, &dentry->d_name, NULL);
 
865
        switch (error) {
 
866
        case -ENOENT:
 
867
                break;
 
868
        case 0:
 
869
                error = -EEXIST;
 
870
        default:
 
871
                goto out_gunlock;
 
872
        }
 
873
 
 
874
        error = -EINVAL;
 
875
        if (!dip->i_inode.i_nlink)
 
876
                goto out_gunlock;
 
877
        error = -EFBIG;
 
878
        if (dip->i_entries == (u32)-1)
 
879
                goto out_gunlock;
 
880
        error = -EPERM;
 
881
        if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
 
882
                goto out_gunlock;
 
883
        error = -EINVAL;
 
884
        if (!ip->i_inode.i_nlink)
 
885
                goto out_gunlock;
 
886
        error = -EMLINK;
 
887
        if (ip->i_inode.i_nlink == (u32)-1)
 
888
                goto out_gunlock;
 
889
 
 
890
        alloc_required = error = gfs2_diradd_alloc_required(dir, &dentry->d_name);
 
891
        if (error < 0)
 
892
                goto out_gunlock;
 
893
        error = 0;
 
894
 
 
895
        if (alloc_required) {
 
896
                struct gfs2_alloc *al = gfs2_alloc_get(dip);
 
897
                if (!al) {
 
898
                        error = -ENOMEM;
 
899
                        goto out_gunlock;
 
900
                }
 
901
 
 
902
                error = gfs2_quota_lock_check(dip);
 
903
                if (error)
 
904
                        goto out_alloc;
 
905
 
 
906
                al->al_requested = sdp->sd_max_dirres;
 
907
 
 
908
                error = gfs2_inplace_reserve(dip);
 
909
                if (error)
 
910
                        goto out_gunlock_q;
 
911
 
 
912
                error = gfs2_trans_begin(sdp, sdp->sd_max_dirres +
 
913
                                         gfs2_rg_blocks(al) +
 
914
                                         2 * RES_DINODE + RES_STATFS +
 
915
                                         RES_QUOTA, 0);
 
916
                if (error)
 
917
                        goto out_ipres;
 
918
        } else {
 
919
                error = gfs2_trans_begin(sdp, 2 * RES_DINODE + RES_LEAF, 0);
 
920
                if (error)
 
921
                        goto out_ipres;
 
922
        }
 
923
 
 
924
        error = gfs2_meta_inode_buffer(ip, &dibh);
 
925
        if (error)
 
926
                goto out_end_trans;
 
927
 
 
928
        error = gfs2_dir_add(dir, &dentry->d_name, ip);
 
929
        if (error)
 
930
                goto out_brelse;
 
931
 
 
932
        gfs2_trans_add_bh(ip->i_gl, dibh, 1);
 
933
        inc_nlink(&ip->i_inode);
 
934
        ip->i_inode.i_ctime = CURRENT_TIME;
 
935
        gfs2_dinode_out(ip, dibh->b_data);
 
936
        mark_inode_dirty(&ip->i_inode);
 
937
 
 
938
out_brelse:
 
939
        brelse(dibh);
 
940
out_end_trans:
 
941
        gfs2_trans_end(sdp);
 
942
out_ipres:
 
943
        if (alloc_required)
 
944
                gfs2_inplace_release(dip);
 
945
out_gunlock_q:
 
946
        if (alloc_required)
 
947
                gfs2_quota_unlock(dip);
 
948
out_alloc:
 
949
        if (alloc_required)
 
950
                gfs2_alloc_put(dip);
 
951
out_gunlock:
 
952
        gfs2_glock_dq(ghs + 1);
 
953
out_child:
 
954
        gfs2_glock_dq(ghs);
 
955
out_parent:
 
956
        gfs2_holder_uninit(ghs);
 
957
        gfs2_holder_uninit(ghs + 1);
 
958
        if (!error) {
 
959
                ihold(inode);
 
960
                d_instantiate(dentry, inode);
 
961
                mark_inode_dirty(inode);
 
962
        }
 
963
        return error;
 
964
}
 
965
 
 
966
/*
 
967
 * gfs2_unlink_ok - check to see that a inode is still in a directory
 
968
 * @dip: the directory
 
969
 * @name: the name of the file
 
970
 * @ip: the inode
 
971
 *
 
972
 * Assumes that the lock on (at least) @dip is held.
 
973
 *
 
974
 * Returns: 0 if the parent/child relationship is correct, errno if it isn't
 
975
 */
 
976
 
 
977
static int gfs2_unlink_ok(struct gfs2_inode *dip, const struct qstr *name,
 
978
                          const struct gfs2_inode *ip)
 
979
{
 
980
        int error;
 
981
 
 
982
        if (IS_IMMUTABLE(&ip->i_inode) || IS_APPEND(&ip->i_inode))
 
983
                return -EPERM;
 
984
 
 
985
        if ((dip->i_inode.i_mode & S_ISVTX) &&
 
986
            dip->i_inode.i_uid != current_fsuid() &&
 
987
            ip->i_inode.i_uid != current_fsuid() && !capable(CAP_FOWNER))
 
988
                return -EPERM;
 
989
 
 
990
        if (IS_APPEND(&dip->i_inode))
 
991
                return -EPERM;
 
992
 
 
993
        error = gfs2_permission(&dip->i_inode, MAY_WRITE | MAY_EXEC, 0);
 
994
        if (error)
 
995
                return error;
 
996
 
 
997
        error = gfs2_dir_check(&dip->i_inode, name, ip);
 
998
        if (error)
 
999
                return error;
 
1000
 
 
1001
        return 0;
 
1002
}
 
1003
 
 
1004
/**
 
1005
 * gfs2_unlink_inode - Removes an inode from its parent dir and unlinks it
 
1006
 * @dip: The parent directory
 
1007
 * @name: The name of the entry in the parent directory
 
1008
 * @bh: The inode buffer for the inode to be removed
 
1009
 * @inode: The inode to be removed
 
1010
 *
 
1011
 * Called with all the locks and in a transaction. This will only be
 
1012
 * called for a directory after it has been checked to ensure it is empty.
 
1013
 *
 
1014
 * Returns: 0 on success, or an error
 
1015
 */
 
1016
 
 
1017
static int gfs2_unlink_inode(struct gfs2_inode *dip,
 
1018
                             const struct dentry *dentry,
 
1019
                             struct buffer_head *bh)
 
1020
{
 
1021
        struct inode *inode = dentry->d_inode;
 
1022
        struct gfs2_inode *ip = GFS2_I(inode);
 
1023
        int error;
 
1024
 
 
1025
        error = gfs2_dir_del(dip, dentry);
 
1026
        if (error)
 
1027
                return error;
 
1028
 
 
1029
        ip->i_entries = 0;
 
1030
        inode->i_ctime = CURRENT_TIME;
 
1031
        if (S_ISDIR(inode->i_mode))
 
1032
                clear_nlink(inode);
 
1033
        else
 
1034
                drop_nlink(inode);
 
1035
        gfs2_trans_add_bh(ip->i_gl, bh, 1);
 
1036
        gfs2_dinode_out(ip, bh->b_data);
 
1037
        mark_inode_dirty(inode);
 
1038
        if (inode->i_nlink == 0)
 
1039
                gfs2_unlink_di(inode);
 
1040
        return 0;
 
1041
}
 
1042
 
 
1043
 
 
1044
/**
 
1045
 * gfs2_unlink - Unlink an inode (this does rmdir as well)
 
1046
 * @dir: The inode of the directory containing the inode to unlink
 
1047
 * @dentry: The file itself
 
1048
 *
 
1049
 * This routine uses the type of the inode as a flag to figure out
 
1050
 * whether this is an unlink or an rmdir.
 
1051
 *
 
1052
 * Returns: errno
 
1053
 */
 
1054
 
 
1055
static int gfs2_unlink(struct inode *dir, struct dentry *dentry)
 
1056
{
 
1057
        struct gfs2_inode *dip = GFS2_I(dir);
 
1058
        struct gfs2_sbd *sdp = GFS2_SB(dir);
 
1059
        struct inode *inode = dentry->d_inode;
 
1060
        struct gfs2_inode *ip = GFS2_I(inode);
 
1061
        struct buffer_head *bh;
 
1062
        struct gfs2_holder ghs[3];
 
1063
        struct gfs2_rgrpd *rgd;
 
1064
        struct gfs2_holder ri_gh;
 
1065
        int error;
 
1066
 
 
1067
        error = gfs2_rindex_hold(sdp, &ri_gh);
 
1068
        if (error)
 
1069
                return error;
 
1070
 
 
1071
        gfs2_holder_init(dip->i_gl, LM_ST_EXCLUSIVE, 0, ghs);
 
1072
        gfs2_holder_init(ip->i_gl,  LM_ST_EXCLUSIVE, 0, ghs + 1);
 
1073
 
 
1074
        rgd = gfs2_blk2rgrpd(sdp, ip->i_no_addr);
 
1075
        gfs2_holder_init(rgd->rd_gl, LM_ST_EXCLUSIVE, 0, ghs + 2);
 
1076
 
 
1077
 
 
1078
        error = gfs2_glock_nq(ghs); /* parent */
 
1079
        if (error)
 
1080
                goto out_parent;
 
1081
 
 
1082
        error = gfs2_glock_nq(ghs + 1); /* child */
 
1083
        if (error)
 
1084
                goto out_child;
 
1085
 
 
1086
        error = -ENOENT;
 
1087
        if (inode->i_nlink == 0)
 
1088
                goto out_rgrp;
 
1089
 
 
1090
        if (S_ISDIR(inode->i_mode)) {
 
1091
                error = -ENOTEMPTY;
 
1092
                if (ip->i_entries > 2 || inode->i_nlink > 2)
 
1093
                        goto out_rgrp;
 
1094
        }
 
1095
 
 
1096
        error = gfs2_glock_nq(ghs + 2); /* rgrp */
 
1097
        if (error)
 
1098
                goto out_rgrp;
 
1099
 
 
1100
        error = gfs2_unlink_ok(dip, &dentry->d_name, ip);
 
1101
        if (error)
 
1102
                goto out_gunlock;
 
1103
 
 
1104
        error = gfs2_trans_begin(sdp, 2*RES_DINODE + 3*RES_LEAF + RES_RG_BIT, 0);
 
1105
        if (error)
 
1106
                goto out_gunlock;
 
1107
 
 
1108
        error = gfs2_meta_inode_buffer(ip, &bh);
 
1109
        if (error)
 
1110
                goto out_end_trans;
 
1111
 
 
1112
        error = gfs2_unlink_inode(dip, dentry, bh);
 
1113
        brelse(bh);
 
1114
 
 
1115
out_end_trans:
 
1116
        gfs2_trans_end(sdp);
 
1117
out_gunlock:
 
1118
        gfs2_glock_dq(ghs + 2);
 
1119
out_rgrp:
 
1120
        gfs2_holder_uninit(ghs + 2);
 
1121
        gfs2_glock_dq(ghs + 1);
 
1122
out_child:
 
1123
        gfs2_holder_uninit(ghs + 1);
 
1124
        gfs2_glock_dq(ghs);
 
1125
out_parent:
 
1126
        gfs2_holder_uninit(ghs);
 
1127
        gfs2_glock_dq_uninit(&ri_gh);
 
1128
        return error;
 
1129
}
 
1130
 
 
1131
/**
 
1132
 * gfs2_symlink - Create a symlink
 
1133
 * @dir: The directory to create the symlink in
 
1134
 * @dentry: The dentry to put the symlink in
 
1135
 * @symname: The thing which the link points to
 
1136
 *
 
1137
 * Returns: errno
 
1138
 */
 
1139
 
 
1140
static int gfs2_symlink(struct inode *dir, struct dentry *dentry,
 
1141
                        const char *symname)
 
1142
{
 
1143
        struct gfs2_sbd *sdp = GFS2_SB(dir);
 
1144
        unsigned int size;
 
1145
 
 
1146
        size = strlen(symname);
 
1147
        if (size > sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode) - 1)
 
1148
                return -ENAMETOOLONG;
 
1149
 
 
1150
        return gfs2_create_inode(dir, dentry, S_IFLNK | S_IRWXUGO, 0, symname, size);
 
1151
}
 
1152
 
 
1153
/**
 
1154
 * gfs2_mkdir - Make a directory
 
1155
 * @dir: The parent directory of the new one
 
1156
 * @dentry: The dentry of the new directory
 
1157
 * @mode: The mode of the new directory
 
1158
 *
 
1159
 * Returns: errno
 
1160
 */
 
1161
 
 
1162
static int gfs2_mkdir(struct inode *dir, struct dentry *dentry, int mode)
 
1163
{
 
1164
        return gfs2_create_inode(dir, dentry, S_IFDIR | mode, 0, NULL, 0);
 
1165
}
 
1166
 
 
1167
/**
 
1168
 * gfs2_mknod - Make a special file
 
1169
 * @dir: The directory in which the special file will reside
 
1170
 * @dentry: The dentry of the special file
 
1171
 * @mode: The mode of the special file
 
1172
 * @dev: The device specification of the special file
 
1173
 *
 
1174
 */
 
1175
 
 
1176
static int gfs2_mknod(struct inode *dir, struct dentry *dentry, int mode,
 
1177
                      dev_t dev)
 
1178
{
 
1179
        return gfs2_create_inode(dir, dentry, mode, dev, NULL, 0);
 
1180
}
 
1181
 
 
1182
/*
 
1183
 * gfs2_ok_to_move - check if it's ok to move a directory to another directory
 
1184
 * @this: move this
 
1185
 * @to: to here
 
1186
 *
 
1187
 * Follow @to back to the root and make sure we don't encounter @this
 
1188
 * Assumes we already hold the rename lock.
 
1189
 *
 
1190
 * Returns: errno
 
1191
 */
 
1192
 
 
1193
static int gfs2_ok_to_move(struct gfs2_inode *this, struct gfs2_inode *to)
 
1194
{
 
1195
        struct inode *dir = &to->i_inode;
 
1196
        struct super_block *sb = dir->i_sb;
 
1197
        struct inode *tmp;
 
1198
        int error = 0;
 
1199
 
 
1200
        igrab(dir);
 
1201
 
 
1202
        for (;;) {
 
1203
                if (dir == &this->i_inode) {
 
1204
                        error = -EINVAL;
 
1205
                        break;
 
1206
                }
 
1207
                if (dir == sb->s_root->d_inode) {
 
1208
                        error = 0;
 
1209
                        break;
 
1210
                }
 
1211
 
 
1212
                tmp = gfs2_lookupi(dir, &gfs2_qdotdot, 1);
 
1213
                if (IS_ERR(tmp)) {
 
1214
                        error = PTR_ERR(tmp);
 
1215
                        break;
 
1216
                }
 
1217
 
 
1218
                iput(dir);
 
1219
                dir = tmp;
 
1220
        }
 
1221
 
 
1222
        iput(dir);
 
1223
 
 
1224
        return error;
 
1225
}
 
1226
 
 
1227
/**
 
1228
 * gfs2_rename - Rename a file
 
1229
 * @odir: Parent directory of old file name
 
1230
 * @odentry: The old dentry of the file
 
1231
 * @ndir: Parent directory of new file name
 
1232
 * @ndentry: The new dentry of the file
 
1233
 *
 
1234
 * Returns: errno
 
1235
 */
 
1236
 
 
1237
static int gfs2_rename(struct inode *odir, struct dentry *odentry,
 
1238
                       struct inode *ndir, struct dentry *ndentry)
 
1239
{
 
1240
        struct gfs2_inode *odip = GFS2_I(odir);
 
1241
        struct gfs2_inode *ndip = GFS2_I(ndir);
 
1242
        struct gfs2_inode *ip = GFS2_I(odentry->d_inode);
 
1243
        struct gfs2_inode *nip = NULL;
 
1244
        struct gfs2_sbd *sdp = GFS2_SB(odir);
 
1245
        struct gfs2_holder ghs[5], r_gh = { .gh_gl = NULL, }, ri_gh;
 
1246
        struct gfs2_rgrpd *nrgd;
 
1247
        unsigned int num_gh;
 
1248
        int dir_rename = 0;
 
1249
        int alloc_required = 0;
 
1250
        unsigned int x;
 
1251
        int error;
 
1252
 
 
1253
        if (ndentry->d_inode) {
 
1254
                nip = GFS2_I(ndentry->d_inode);
 
1255
                if (ip == nip)
 
1256
                        return 0;
 
1257
        }
 
1258
 
 
1259
        error = gfs2_rindex_hold(sdp, &ri_gh);
 
1260
        if (error)
 
1261
                return error;
 
1262
 
 
1263
        if (odip != ndip) {
 
1264
                error = gfs2_glock_nq_init(sdp->sd_rename_gl, LM_ST_EXCLUSIVE,
 
1265
                                           0, &r_gh);
 
1266
                if (error)
 
1267
                        goto out;
 
1268
 
 
1269
                if (S_ISDIR(ip->i_inode.i_mode)) {
 
1270
                        dir_rename = 1;
 
1271
                        /* don't move a dirctory into it's subdir */
 
1272
                        error = gfs2_ok_to_move(ip, ndip);
 
1273
                        if (error)
 
1274
                                goto out_gunlock_r;
 
1275
                }
 
1276
        }
 
1277
 
 
1278
        num_gh = 1;
 
1279
        gfs2_holder_init(odip->i_gl, LM_ST_EXCLUSIVE, 0, ghs);
 
1280
        if (odip != ndip) {
 
1281
                gfs2_holder_init(ndip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + num_gh);
 
1282
                num_gh++;
 
1283
        }
 
1284
        gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + num_gh);
 
1285
        num_gh++;
 
1286
 
 
1287
        if (nip) {
 
1288
                gfs2_holder_init(nip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + num_gh);
 
1289
                num_gh++;
 
1290
                /* grab the resource lock for unlink flag twiddling 
 
1291
                 * this is the case of the target file already existing
 
1292
                 * so we unlink before doing the rename
 
1293
                 */
 
1294
                nrgd = gfs2_blk2rgrpd(sdp, nip->i_no_addr);
 
1295
                if (nrgd)
 
1296
                        gfs2_holder_init(nrgd->rd_gl, LM_ST_EXCLUSIVE, 0, ghs + num_gh++);
 
1297
        }
 
1298
 
 
1299
        for (x = 0; x < num_gh; x++) {
 
1300
                error = gfs2_glock_nq(ghs + x);
 
1301
                if (error)
 
1302
                        goto out_gunlock;
 
1303
        }
 
1304
 
 
1305
        error = -ENOENT;
 
1306
        if (ip->i_inode.i_nlink == 0)
 
1307
                goto out_gunlock;
 
1308
 
 
1309
        /* Check out the old directory */
 
1310
 
 
1311
        error = gfs2_unlink_ok(odip, &odentry->d_name, ip);
 
1312
        if (error)
 
1313
                goto out_gunlock;
 
1314
 
 
1315
        /* Check out the new directory */
 
1316
 
 
1317
        if (nip) {
 
1318
                error = gfs2_unlink_ok(ndip, &ndentry->d_name, nip);
 
1319
                if (error)
 
1320
                        goto out_gunlock;
 
1321
 
 
1322
                if (nip->i_inode.i_nlink == 0) {
 
1323
                        error = -EAGAIN;
 
1324
                        goto out_gunlock;
 
1325
                }
 
1326
 
 
1327
                if (S_ISDIR(nip->i_inode.i_mode)) {
 
1328
                        if (nip->i_entries < 2) {
 
1329
                                gfs2_consist_inode(nip);
 
1330
                                error = -EIO;
 
1331
                                goto out_gunlock;
 
1332
                        }
 
1333
                        if (nip->i_entries > 2) {
 
1334
                                error = -ENOTEMPTY;
 
1335
                                goto out_gunlock;
 
1336
                        }
 
1337
                }
 
1338
        } else {
 
1339
                error = gfs2_permission(ndir, MAY_WRITE | MAY_EXEC, 0);
 
1340
                if (error)
 
1341
                        goto out_gunlock;
 
1342
 
 
1343
                error = gfs2_dir_check(ndir, &ndentry->d_name, NULL);
 
1344
                switch (error) {
 
1345
                case -ENOENT:
 
1346
                        error = 0;
 
1347
                        break;
 
1348
                case 0:
 
1349
                        error = -EEXIST;
 
1350
                default:
 
1351
                        goto out_gunlock;
 
1352
                };
 
1353
 
 
1354
                if (odip != ndip) {
 
1355
                        if (!ndip->i_inode.i_nlink) {
 
1356
                                error = -ENOENT;
 
1357
                                goto out_gunlock;
 
1358
                        }
 
1359
                        if (ndip->i_entries == (u32)-1) {
 
1360
                                error = -EFBIG;
 
1361
                                goto out_gunlock;
 
1362
                        }
 
1363
                        if (S_ISDIR(ip->i_inode.i_mode) &&
 
1364
                            ndip->i_inode.i_nlink == (u32)-1) {
 
1365
                                error = -EMLINK;
 
1366
                                goto out_gunlock;
 
1367
                        }
 
1368
                }
 
1369
        }
 
1370
 
 
1371
        /* Check out the dir to be renamed */
 
1372
 
 
1373
        if (dir_rename) {
 
1374
                error = gfs2_permission(odentry->d_inode, MAY_WRITE, 0);
 
1375
                if (error)
 
1376
                        goto out_gunlock;
 
1377
        }
 
1378
 
 
1379
        if (nip == NULL)
 
1380
                alloc_required = gfs2_diradd_alloc_required(ndir, &ndentry->d_name);
 
1381
        error = alloc_required;
 
1382
        if (error < 0)
 
1383
                goto out_gunlock;
 
1384
        error = 0;
 
1385
 
 
1386
        if (alloc_required) {
 
1387
                struct gfs2_alloc *al = gfs2_alloc_get(ndip);
 
1388
                if (!al) {
 
1389
                        error = -ENOMEM;
 
1390
                        goto out_gunlock;
 
1391
                }
 
1392
 
 
1393
                error = gfs2_quota_lock_check(ndip);
 
1394
                if (error)
 
1395
                        goto out_alloc;
 
1396
 
 
1397
                al->al_requested = sdp->sd_max_dirres;
 
1398
 
 
1399
                error = gfs2_inplace_reserve_ri(ndip);
 
1400
                if (error)
 
1401
                        goto out_gunlock_q;
 
1402
 
 
1403
                error = gfs2_trans_begin(sdp, sdp->sd_max_dirres +
 
1404
                                         gfs2_rg_blocks(al) +
 
1405
                                         4 * RES_DINODE + 4 * RES_LEAF +
 
1406
                                         RES_STATFS + RES_QUOTA + 4, 0);
 
1407
                if (error)
 
1408
                        goto out_ipreserv;
 
1409
        } else {
 
1410
                error = gfs2_trans_begin(sdp, 4 * RES_DINODE +
 
1411
                                         5 * RES_LEAF + 4, 0);
 
1412
                if (error)
 
1413
                        goto out_gunlock;
 
1414
        }
 
1415
 
 
1416
        /* Remove the target file, if it exists */
 
1417
 
 
1418
        if (nip) {
 
1419
                struct buffer_head *bh;
 
1420
                error = gfs2_meta_inode_buffer(nip, &bh);
 
1421
                if (error)
 
1422
                        goto out_end_trans;
 
1423
                error = gfs2_unlink_inode(ndip, ndentry, bh);
 
1424
                brelse(bh);
 
1425
        }
 
1426
 
 
1427
        if (dir_rename) {
 
1428
                error = gfs2_dir_mvino(ip, &gfs2_qdotdot, ndip, DT_DIR);
 
1429
                if (error)
 
1430
                        goto out_end_trans;
 
1431
        } else {
 
1432
                struct buffer_head *dibh;
 
1433
                error = gfs2_meta_inode_buffer(ip, &dibh);
 
1434
                if (error)
 
1435
                        goto out_end_trans;
 
1436
                ip->i_inode.i_ctime = CURRENT_TIME;
 
1437
                gfs2_trans_add_bh(ip->i_gl, dibh, 1);
 
1438
                gfs2_dinode_out(ip, dibh->b_data);
 
1439
                brelse(dibh);
 
1440
        }
 
1441
 
 
1442
        error = gfs2_dir_del(odip, odentry);
 
1443
        if (error)
 
1444
                goto out_end_trans;
 
1445
 
 
1446
        error = gfs2_dir_add(ndir, &ndentry->d_name, ip);
 
1447
        if (error)
 
1448
                goto out_end_trans;
 
1449
 
 
1450
out_end_trans:
 
1451
        gfs2_trans_end(sdp);
 
1452
out_ipreserv:
 
1453
        if (alloc_required)
 
1454
                gfs2_inplace_release(ndip);
 
1455
out_gunlock_q:
 
1456
        if (alloc_required)
 
1457
                gfs2_quota_unlock(ndip);
 
1458
out_alloc:
 
1459
        if (alloc_required)
 
1460
                gfs2_alloc_put(ndip);
 
1461
out_gunlock:
 
1462
        while (x--) {
 
1463
                gfs2_glock_dq(ghs + x);
 
1464
                gfs2_holder_uninit(ghs + x);
 
1465
        }
 
1466
out_gunlock_r:
 
1467
        if (r_gh.gh_gl)
 
1468
                gfs2_glock_dq_uninit(&r_gh);
 
1469
out:
 
1470
        gfs2_glock_dq_uninit(&ri_gh);
 
1471
        return error;
 
1472
}
 
1473
 
 
1474
/**
 
1475
 * gfs2_follow_link - Follow a symbolic link
 
1476
 * @dentry: The dentry of the link
 
1477
 * @nd: Data that we pass to vfs_follow_link()
 
1478
 *
 
1479
 * This can handle symlinks of any size.
 
1480
 *
 
1481
 * Returns: 0 on success or error code
 
1482
 */
 
1483
 
 
1484
static void *gfs2_follow_link(struct dentry *dentry, struct nameidata *nd)
 
1485
{
 
1486
        struct gfs2_inode *ip = GFS2_I(dentry->d_inode);
 
1487
        struct gfs2_holder i_gh;
 
1488
        struct buffer_head *dibh;
 
1489
        unsigned int size;
 
1490
        char *buf;
 
1491
        int error;
 
1492
 
 
1493
        gfs2_holder_init(ip->i_gl, LM_ST_SHARED, 0, &i_gh);
 
1494
        error = gfs2_glock_nq(&i_gh);
 
1495
        if (error) {
 
1496
                gfs2_holder_uninit(&i_gh);
 
1497
                nd_set_link(nd, ERR_PTR(error));
 
1498
                return NULL;
 
1499
        }
 
1500
 
 
1501
        size = (unsigned int)i_size_read(&ip->i_inode);
 
1502
        if (size == 0) {
 
1503
                gfs2_consist_inode(ip);
 
1504
                buf = ERR_PTR(-EIO);
 
1505
                goto out;
 
1506
        }
 
1507
 
 
1508
        error = gfs2_meta_inode_buffer(ip, &dibh);
 
1509
        if (error) {
 
1510
                buf = ERR_PTR(error);
 
1511
                goto out;
 
1512
        }
 
1513
 
 
1514
        buf = kzalloc(size + 1, GFP_NOFS);
 
1515
        if (!buf)
 
1516
                buf = ERR_PTR(-ENOMEM);
 
1517
        else
 
1518
                memcpy(buf, dibh->b_data + sizeof(struct gfs2_dinode), size);
 
1519
        brelse(dibh);
 
1520
out:
 
1521
        gfs2_glock_dq_uninit(&i_gh);
 
1522
        nd_set_link(nd, buf);
 
1523
        return NULL;
 
1524
}
 
1525
 
 
1526
static void gfs2_put_link(struct dentry *dentry, struct nameidata *nd, void *p)
 
1527
{
 
1528
        char *s = nd_get_link(nd);
 
1529
        if (!IS_ERR(s))
 
1530
                kfree(s);
 
1531
}
 
1532
 
 
1533
/**
 
1534
 * gfs2_permission -
 
1535
 * @inode: The inode
 
1536
 * @mask: The mask to be tested
 
1537
 * @flags: Indicates whether this is an RCU path walk or not
 
1538
 *
 
1539
 * This may be called from the VFS directly, or from within GFS2 with the
 
1540
 * inode locked, so we look to see if the glock is already locked and only
 
1541
 * lock the glock if its not already been done.
 
1542
 *
 
1543
 * Returns: errno
 
1544
 */
 
1545
 
 
1546
int gfs2_permission(struct inode *inode, int mask, unsigned int flags)
 
1547
{
 
1548
        struct gfs2_inode *ip;
 
1549
        struct gfs2_holder i_gh;
 
1550
        int error;
 
1551
        int unlock = 0;
 
1552
 
 
1553
 
 
1554
        ip = GFS2_I(inode);
 
1555
        if (gfs2_glock_is_locked_by_me(ip->i_gl) == NULL) {
 
1556
                if (flags & IPERM_FLAG_RCU)
 
1557
                        return -ECHILD;
 
1558
                error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &i_gh);
 
1559
                if (error)
 
1560
                        return error;
 
1561
                unlock = 1;
 
1562
        }
 
1563
 
 
1564
        if ((mask & MAY_WRITE) && IS_IMMUTABLE(inode))
 
1565
                error = -EACCES;
 
1566
        else
 
1567
                error = generic_permission(inode, mask, flags, gfs2_check_acl);
 
1568
        if (unlock)
 
1569
                gfs2_glock_dq_uninit(&i_gh);
 
1570
 
 
1571
        return error;
879
1572
}
880
1573
 
881
1574
static int __gfs2_setattr_simple(struct gfs2_inode *ip, struct iattr *attr)
901
1594
 * @ip:
902
1595
 * @attr:
903
1596
 *
904
 
 * Called with a reference on the vnode.
905
 
 *
906
1597
 * Returns: errno
907
1598
 */
908
1599
 
922
1613
        return error;
923
1614
}
924
1615
 
925
 
void gfs2_dinode_out(const struct gfs2_inode *ip, void *buf)
926
 
{
927
 
        struct gfs2_dinode *str = buf;
928
 
 
929
 
        str->di_header.mh_magic = cpu_to_be32(GFS2_MAGIC);
930
 
        str->di_header.mh_type = cpu_to_be32(GFS2_METATYPE_DI);
931
 
        str->di_header.mh_format = cpu_to_be32(GFS2_FORMAT_DI);
932
 
        str->di_num.no_addr = cpu_to_be64(ip->i_no_addr);
933
 
        str->di_num.no_formal_ino = cpu_to_be64(ip->i_no_formal_ino);
934
 
        str->di_mode = cpu_to_be32(ip->i_inode.i_mode);
935
 
        str->di_uid = cpu_to_be32(ip->i_inode.i_uid);
936
 
        str->di_gid = cpu_to_be32(ip->i_inode.i_gid);
937
 
        str->di_nlink = cpu_to_be32(ip->i_inode.i_nlink);
938
 
        str->di_size = cpu_to_be64(i_size_read(&ip->i_inode));
939
 
        str->di_blocks = cpu_to_be64(gfs2_get_inode_blocks(&ip->i_inode));
940
 
        str->di_atime = cpu_to_be64(ip->i_inode.i_atime.tv_sec);
941
 
        str->di_mtime = cpu_to_be64(ip->i_inode.i_mtime.tv_sec);
942
 
        str->di_ctime = cpu_to_be64(ip->i_inode.i_ctime.tv_sec);
943
 
 
944
 
        str->di_goal_meta = cpu_to_be64(ip->i_goal);
945
 
        str->di_goal_data = cpu_to_be64(ip->i_goal);
946
 
        str->di_generation = cpu_to_be64(ip->i_generation);
947
 
 
948
 
        str->di_flags = cpu_to_be32(ip->i_diskflags);
949
 
        str->di_height = cpu_to_be16(ip->i_height);
950
 
        str->di_payload_format = cpu_to_be32(S_ISDIR(ip->i_inode.i_mode) &&
951
 
                                             !(ip->i_diskflags & GFS2_DIF_EXHASH) ?
952
 
                                             GFS2_FORMAT_DE : 0);
953
 
        str->di_depth = cpu_to_be16(ip->i_depth);
954
 
        str->di_entries = cpu_to_be32(ip->i_entries);
955
 
 
956
 
        str->di_eattr = cpu_to_be64(ip->i_eattr);
957
 
        str->di_atime_nsec = cpu_to_be32(ip->i_inode.i_atime.tv_nsec);
958
 
        str->di_mtime_nsec = cpu_to_be32(ip->i_inode.i_mtime.tv_nsec);
959
 
        str->di_ctime_nsec = cpu_to_be32(ip->i_inode.i_ctime.tv_nsec);
960
 
}
961
 
 
962
 
void gfs2_dinode_print(const struct gfs2_inode *ip)
963
 
{
964
 
        printk(KERN_INFO "  no_formal_ino = %llu\n",
965
 
               (unsigned long long)ip->i_no_formal_ino);
966
 
        printk(KERN_INFO "  no_addr = %llu\n",
967
 
               (unsigned long long)ip->i_no_addr);
968
 
        printk(KERN_INFO "  i_size = %llu\n",
969
 
               (unsigned long long)i_size_read(&ip->i_inode));
970
 
        printk(KERN_INFO "  blocks = %llu\n",
971
 
               (unsigned long long)gfs2_get_inode_blocks(&ip->i_inode));
972
 
        printk(KERN_INFO "  i_goal = %llu\n",
973
 
               (unsigned long long)ip->i_goal);
974
 
        printk(KERN_INFO "  i_diskflags = 0x%.8X\n", ip->i_diskflags);
975
 
        printk(KERN_INFO "  i_height = %u\n", ip->i_height);
976
 
        printk(KERN_INFO "  i_depth = %u\n", ip->i_depth);
977
 
        printk(KERN_INFO "  i_entries = %u\n", ip->i_entries);
978
 
        printk(KERN_INFO "  i_eattr = %llu\n",
979
 
               (unsigned long long)ip->i_eattr);
980
 
}
 
1616
static int setattr_chown(struct inode *inode, struct iattr *attr)
 
1617
{
 
1618
        struct gfs2_inode *ip = GFS2_I(inode);
 
1619
        struct gfs2_sbd *sdp = GFS2_SB(inode);
 
1620
        u32 ouid, ogid, nuid, ngid;
 
1621
        int error;
 
1622
 
 
1623
        ouid = inode->i_uid;
 
1624
        ogid = inode->i_gid;
 
1625
        nuid = attr->ia_uid;
 
1626
        ngid = attr->ia_gid;
 
1627
 
 
1628
        if (!(attr->ia_valid & ATTR_UID) || ouid == nuid)
 
1629
                ouid = nuid = NO_QUOTA_CHANGE;
 
1630
        if (!(attr->ia_valid & ATTR_GID) || ogid == ngid)
 
1631
                ogid = ngid = NO_QUOTA_CHANGE;
 
1632
 
 
1633
        if (!gfs2_alloc_get(ip))
 
1634
                return -ENOMEM;
 
1635
 
 
1636
        error = gfs2_quota_lock(ip, nuid, ngid);
 
1637
        if (error)
 
1638
                goto out_alloc;
 
1639
 
 
1640
        if (ouid != NO_QUOTA_CHANGE || ogid != NO_QUOTA_CHANGE) {
 
1641
                error = gfs2_quota_check(ip, nuid, ngid);
 
1642
                if (error)
 
1643
                        goto out_gunlock_q;
 
1644
        }
 
1645
 
 
1646
        error = gfs2_trans_begin(sdp, RES_DINODE + 2 * RES_QUOTA, 0);
 
1647
        if (error)
 
1648
                goto out_gunlock_q;
 
1649
 
 
1650
        error = gfs2_setattr_simple(ip, attr);
 
1651
        if (error)
 
1652
                goto out_end_trans;
 
1653
 
 
1654
        if (ouid != NO_QUOTA_CHANGE || ogid != NO_QUOTA_CHANGE) {
 
1655
                u64 blocks = gfs2_get_inode_blocks(&ip->i_inode);
 
1656
                gfs2_quota_change(ip, -blocks, ouid, ogid);
 
1657
                gfs2_quota_change(ip, blocks, nuid, ngid);
 
1658
        }
 
1659
 
 
1660
out_end_trans:
 
1661
        gfs2_trans_end(sdp);
 
1662
out_gunlock_q:
 
1663
        gfs2_quota_unlock(ip);
 
1664
out_alloc:
 
1665
        gfs2_alloc_put(ip);
 
1666
        return error;
 
1667
}
 
1668
 
 
1669
/**
 
1670
 * gfs2_setattr - Change attributes on an inode
 
1671
 * @dentry: The dentry which is changing
 
1672
 * @attr: The structure describing the change
 
1673
 *
 
1674
 * The VFS layer wants to change one or more of an inodes attributes.  Write
 
1675
 * that change out to disk.
 
1676
 *
 
1677
 * Returns: errno
 
1678
 */
 
1679
 
 
1680
static int gfs2_setattr(struct dentry *dentry, struct iattr *attr)
 
1681
{
 
1682
        struct inode *inode = dentry->d_inode;
 
1683
        struct gfs2_inode *ip = GFS2_I(inode);
 
1684
        struct gfs2_holder i_gh;
 
1685
        int error;
 
1686
 
 
1687
        error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &i_gh);
 
1688
        if (error)
 
1689
                return error;
 
1690
 
 
1691
        error = -EPERM;
 
1692
        if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
 
1693
                goto out;
 
1694
 
 
1695
        error = inode_change_ok(inode, attr);
 
1696
        if (error)
 
1697
                goto out;
 
1698
 
 
1699
        if (attr->ia_valid & ATTR_SIZE)
 
1700
                error = gfs2_setattr_size(inode, attr->ia_size);
 
1701
        else if (attr->ia_valid & (ATTR_UID | ATTR_GID))
 
1702
                error = setattr_chown(inode, attr);
 
1703
        else if ((attr->ia_valid & ATTR_MODE) && IS_POSIXACL(inode))
 
1704
                error = gfs2_acl_chmod(ip, attr);
 
1705
        else
 
1706
                error = gfs2_setattr_simple(ip, attr);
 
1707
 
 
1708
out:
 
1709
        gfs2_glock_dq_uninit(&i_gh);
 
1710
        if (!error)
 
1711
                mark_inode_dirty(inode);
 
1712
        return error;
 
1713
}
 
1714
 
 
1715
/**
 
1716
 * gfs2_getattr - Read out an inode's attributes
 
1717
 * @mnt: The vfsmount the inode is being accessed from
 
1718
 * @dentry: The dentry to stat
 
1719
 * @stat: The inode's stats
 
1720
 *
 
1721
 * This may be called from the VFS directly, or from within GFS2 with the
 
1722
 * inode locked, so we look to see if the glock is already locked and only
 
1723
 * lock the glock if its not already been done. Note that its the NFS
 
1724
 * readdirplus operation which causes this to be called (from filldir)
 
1725
 * with the glock already held.
 
1726
 *
 
1727
 * Returns: errno
 
1728
 */
 
1729
 
 
1730
static int gfs2_getattr(struct vfsmount *mnt, struct dentry *dentry,
 
1731
                        struct kstat *stat)
 
1732
{
 
1733
        struct inode *inode = dentry->d_inode;
 
1734
        struct gfs2_inode *ip = GFS2_I(inode);
 
1735
        struct gfs2_holder gh;
 
1736
        int error;
 
1737
        int unlock = 0;
 
1738
 
 
1739
        if (gfs2_glock_is_locked_by_me(ip->i_gl) == NULL) {
 
1740
                error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &gh);
 
1741
                if (error)
 
1742
                        return error;
 
1743
                unlock = 1;
 
1744
        }
 
1745
 
 
1746
        generic_fillattr(inode, stat);
 
1747
        if (unlock)
 
1748
                gfs2_glock_dq_uninit(&gh);
 
1749
 
 
1750
        return 0;
 
1751
}
 
1752
 
 
1753
static int gfs2_setxattr(struct dentry *dentry, const char *name,
 
1754
                         const void *data, size_t size, int flags)
 
1755
{
 
1756
        struct inode *inode = dentry->d_inode;
 
1757
        struct gfs2_inode *ip = GFS2_I(inode);
 
1758
        struct gfs2_holder gh;
 
1759
        int ret;
 
1760
 
 
1761
        gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
 
1762
        ret = gfs2_glock_nq(&gh);
 
1763
        if (ret == 0) {
 
1764
                ret = generic_setxattr(dentry, name, data, size, flags);
 
1765
                gfs2_glock_dq(&gh);
 
1766
        }
 
1767
        gfs2_holder_uninit(&gh);
 
1768
        return ret;
 
1769
}
 
1770
 
 
1771
static ssize_t gfs2_getxattr(struct dentry *dentry, const char *name,
 
1772
                             void *data, size_t size)
 
1773
{
 
1774
        struct inode *inode = dentry->d_inode;
 
1775
        struct gfs2_inode *ip = GFS2_I(inode);
 
1776
        struct gfs2_holder gh;
 
1777
        int ret;
 
1778
 
 
1779
        gfs2_holder_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &gh);
 
1780
        ret = gfs2_glock_nq(&gh);
 
1781
        if (ret == 0) {
 
1782
                ret = generic_getxattr(dentry, name, data, size);
 
1783
                gfs2_glock_dq(&gh);
 
1784
        }
 
1785
        gfs2_holder_uninit(&gh);
 
1786
        return ret;
 
1787
}
 
1788
 
 
1789
static int gfs2_removexattr(struct dentry *dentry, const char *name)
 
1790
{
 
1791
        struct inode *inode = dentry->d_inode;
 
1792
        struct gfs2_inode *ip = GFS2_I(inode);
 
1793
        struct gfs2_holder gh;
 
1794
        int ret;
 
1795
 
 
1796
        gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
 
1797
        ret = gfs2_glock_nq(&gh);
 
1798
        if (ret == 0) {
 
1799
                ret = generic_removexattr(dentry, name);
 
1800
                gfs2_glock_dq(&gh);
 
1801
        }
 
1802
        gfs2_holder_uninit(&gh);
 
1803
        return ret;
 
1804
}
 
1805
 
 
1806
static int gfs2_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
 
1807
                       u64 start, u64 len)
 
1808
{
 
1809
        struct gfs2_inode *ip = GFS2_I(inode);
 
1810
        struct gfs2_holder gh;
 
1811
        int ret;
 
1812
 
 
1813
        ret = fiemap_check_flags(fieinfo, FIEMAP_FLAG_SYNC);
 
1814
        if (ret)
 
1815
                return ret;
 
1816
 
 
1817
        mutex_lock(&inode->i_mutex);
 
1818
 
 
1819
        ret = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, 0, &gh);
 
1820
        if (ret)
 
1821
                goto out;
 
1822
 
 
1823
        if (gfs2_is_stuffed(ip)) {
 
1824
                u64 phys = ip->i_no_addr << inode->i_blkbits;
 
1825
                u64 size = i_size_read(inode);
 
1826
                u32 flags = FIEMAP_EXTENT_LAST|FIEMAP_EXTENT_NOT_ALIGNED|
 
1827
                            FIEMAP_EXTENT_DATA_INLINE;
 
1828
                phys += sizeof(struct gfs2_dinode);
 
1829
                phys += start;
 
1830
                if (start + len > size)
 
1831
                        len = size - start;
 
1832
                if (start < size)
 
1833
                        ret = fiemap_fill_next_extent(fieinfo, start, phys,
 
1834
                                                      len, flags);
 
1835
                if (ret == 1)
 
1836
                        ret = 0;
 
1837
        } else {
 
1838
                ret = __generic_block_fiemap(inode, fieinfo, start, len,
 
1839
                                             gfs2_block_map);
 
1840
        }
 
1841
 
 
1842
        gfs2_glock_dq_uninit(&gh);
 
1843
out:
 
1844
        mutex_unlock(&inode->i_mutex);
 
1845
        return ret;
 
1846
}
 
1847
 
 
1848
const struct inode_operations gfs2_file_iops = {
 
1849
        .permission = gfs2_permission,
 
1850
        .setattr = gfs2_setattr,
 
1851
        .getattr = gfs2_getattr,
 
1852
        .setxattr = gfs2_setxattr,
 
1853
        .getxattr = gfs2_getxattr,
 
1854
        .listxattr = gfs2_listxattr,
 
1855
        .removexattr = gfs2_removexattr,
 
1856
        .fiemap = gfs2_fiemap,
 
1857
};
 
1858
 
 
1859
const struct inode_operations gfs2_dir_iops = {
 
1860
        .create = gfs2_create,
 
1861
        .lookup = gfs2_lookup,
 
1862
        .link = gfs2_link,
 
1863
        .unlink = gfs2_unlink,
 
1864
        .symlink = gfs2_symlink,
 
1865
        .mkdir = gfs2_mkdir,
 
1866
        .rmdir = gfs2_unlink,
 
1867
        .mknod = gfs2_mknod,
 
1868
        .rename = gfs2_rename,
 
1869
        .permission = gfs2_permission,
 
1870
        .setattr = gfs2_setattr,
 
1871
        .getattr = gfs2_getattr,
 
1872
        .setxattr = gfs2_setxattr,
 
1873
        .getxattr = gfs2_getxattr,
 
1874
        .listxattr = gfs2_listxattr,
 
1875
        .removexattr = gfs2_removexattr,
 
1876
        .fiemap = gfs2_fiemap,
 
1877
};
 
1878
 
 
1879
const struct inode_operations gfs2_symlink_iops = {
 
1880
        .readlink = generic_readlink,
 
1881
        .follow_link = gfs2_follow_link,
 
1882
        .put_link = gfs2_put_link,
 
1883
        .permission = gfs2_permission,
 
1884
        .setattr = gfs2_setattr,
 
1885
        .getattr = gfs2_getattr,
 
1886
        .setxattr = gfs2_setxattr,
 
1887
        .getxattr = gfs2_getxattr,
 
1888
        .listxattr = gfs2_listxattr,
 
1889
        .removexattr = gfs2_removexattr,
 
1890
        .fiemap = gfs2_fiemap,
 
1891
};
981
1892