[PATCH] make O_EXCL in nd->intent.flags visible in nd->flags
[linux-2.6.git] / fs / gfs2 / ops_inode.c
1 /*
2  * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
3  * Copyright (C) 2004-2006 Red Hat, Inc.  All rights reserved.
4  *
5  * This copyrighted material is made available to anyone wishing to use,
6  * modify, copy, or redistribute it subject to the terms and conditions
7  * of the GNU General Public License version 2.
8  */
9
10 #include <linux/slab.h>
11 #include <linux/spinlock.h>
12 #include <linux/completion.h>
13 #include <linux/buffer_head.h>
14 #include <linux/namei.h>
15 #include <linux/utsname.h>
16 #include <linux/mm.h>
17 #include <linux/xattr.h>
18 #include <linux/posix_acl.h>
19 #include <linux/gfs2_ondisk.h>
20 #include <linux/crc32.h>
21 #include <linux/lm_interface.h>
22 #include <asm/uaccess.h>
23
24 #include "gfs2.h"
25 #include "incore.h"
26 #include "acl.h"
27 #include "bmap.h"
28 #include "dir.h"
29 #include "eaops.h"
30 #include "eattr.h"
31 #include "glock.h"
32 #include "inode.h"
33 #include "meta_io.h"
34 #include "ops_dentry.h"
35 #include "ops_inode.h"
36 #include "quota.h"
37 #include "rgrp.h"
38 #include "trans.h"
39 #include "util.h"
40
41 /**
42  * gfs2_create - Create a file
43  * @dir: The directory in which to create the file
44  * @dentry: The dentry of the new file
45  * @mode: The mode of the new file
46  *
47  * Returns: errno
48  */
49
50 static int gfs2_create(struct inode *dir, struct dentry *dentry,
51                        int mode, struct nameidata *nd)
52 {
53         struct gfs2_inode *dip = GFS2_I(dir);
54         struct gfs2_sbd *sdp = GFS2_SB(dir);
55         struct gfs2_holder ghs[2];
56         struct inode *inode;
57
58         gfs2_holder_init(dip->i_gl, 0, 0, ghs);
59
60         for (;;) {
61                 inode = gfs2_createi(ghs, &dentry->d_name, S_IFREG | mode, 0);
62                 if (!IS_ERR(inode)) {
63                         gfs2_trans_end(sdp);
64                         if (dip->i_alloc->al_rgd)
65                                 gfs2_inplace_release(dip);
66                         gfs2_quota_unlock(dip);
67                         gfs2_alloc_put(dip);
68                         gfs2_glock_dq_uninit_m(2, ghs);
69                         mark_inode_dirty(inode);
70                         break;
71                 } else if (PTR_ERR(inode) != -EEXIST ||
72                            (nd && nd->flags & LOOKUP_EXCL)) {
73                         gfs2_holder_uninit(ghs);
74                         return PTR_ERR(inode);
75                 }
76
77                 inode = gfs2_lookupi(dir, &dentry->d_name, 0);
78                 if (inode) {
79                         if (!IS_ERR(inode)) {
80                                 gfs2_holder_uninit(ghs);
81                                 break;
82                         } else {
83                                 gfs2_holder_uninit(ghs);
84                                 return PTR_ERR(inode);
85                         }
86                 }
87         }
88
89         d_instantiate(dentry, inode);
90
91         return 0;
92 }
93
94 /**
95  * gfs2_lookup - Look up a filename in a directory and return its inode
96  * @dir: The directory inode
97  * @dentry: The dentry of the new inode
98  * @nd: passed from Linux VFS, ignored by us
99  *
100  * Called by the VFS layer. Lock dir and call gfs2_lookupi()
101  *
102  * Returns: errno
103  */
104
105 static struct dentry *gfs2_lookup(struct inode *dir, struct dentry *dentry,
106                                   struct nameidata *nd)
107 {
108         struct inode *inode = NULL;
109
110         dentry->d_op = &gfs2_dops;
111
112         inode = gfs2_lookupi(dir, &dentry->d_name, 0);
113         if (inode && IS_ERR(inode))
114                 return ERR_CAST(inode);
115
116         if (inode) {
117                 struct gfs2_glock *gl = GFS2_I(inode)->i_gl;
118                 struct gfs2_holder gh;
119                 int error;
120                 error = gfs2_glock_nq_init(gl, LM_ST_SHARED, LM_FLAG_ANY, &gh);
121                 if (error) {
122                         iput(inode);
123                         return ERR_PTR(error);
124                 }
125                 gfs2_glock_dq_uninit(&gh);
126                 return d_splice_alias(inode, dentry);
127         }
128         d_add(dentry, inode);
129
130         return NULL;
131 }
132
133 /**
134  * gfs2_link - Link to a file
135  * @old_dentry: The inode to link
136  * @dir: Add link to this directory
137  * @dentry: The name of the link
138  *
139  * Link the inode in "old_dentry" into the directory "dir" with the
140  * name in "dentry".
141  *
142  * Returns: errno
143  */
144
145 static int gfs2_link(struct dentry *old_dentry, struct inode *dir,
146                      struct dentry *dentry)
147 {
148         struct gfs2_inode *dip = GFS2_I(dir);
149         struct gfs2_sbd *sdp = GFS2_SB(dir);
150         struct inode *inode = old_dentry->d_inode;
151         struct gfs2_inode *ip = GFS2_I(inode);
152         struct gfs2_holder ghs[2];
153         int alloc_required;
154         int error;
155
156         if (S_ISDIR(inode->i_mode))
157                 return -EPERM;
158
159         gfs2_holder_init(dip->i_gl, LM_ST_EXCLUSIVE, 0, ghs);
160         gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + 1);
161
162         error = gfs2_glock_nq(ghs); /* parent */
163         if (error)
164                 goto out_parent;
165
166         error = gfs2_glock_nq(ghs + 1); /* child */
167         if (error)
168                 goto out_child;
169
170         error = gfs2_permission(dir, MAY_WRITE | MAY_EXEC);
171         if (error)
172                 goto out_gunlock;
173
174         error = gfs2_dir_check(dir, &dentry->d_name, NULL);
175         switch (error) {
176         case -ENOENT:
177                 break;
178         case 0:
179                 error = -EEXIST;
180         default:
181                 goto out_gunlock;
182         }
183
184         error = -EINVAL;
185         if (!dip->i_inode.i_nlink)
186                 goto out_gunlock;
187         error = -EFBIG;
188         if (dip->i_di.di_entries == (u32)-1)
189                 goto out_gunlock;
190         error = -EPERM;
191         if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
192                 goto out_gunlock;
193         error = -EINVAL;
194         if (!ip->i_inode.i_nlink)
195                 goto out_gunlock;
196         error = -EMLINK;
197         if (ip->i_inode.i_nlink == (u32)-1)
198                 goto out_gunlock;
199
200         alloc_required = error = gfs2_diradd_alloc_required(dir, &dentry->d_name);
201         if (error < 0)
202                 goto out_gunlock;
203         error = 0;
204
205         if (alloc_required) {
206                 struct gfs2_alloc *al = gfs2_alloc_get(dip);
207                 if (!al) {
208                         error = -ENOMEM;
209                         goto out_gunlock;
210                 }
211
212                 error = gfs2_quota_lock_check(dip);
213                 if (error)
214                         goto out_alloc;
215
216                 al->al_requested = sdp->sd_max_dirres;
217
218                 error = gfs2_inplace_reserve(dip);
219                 if (error)
220                         goto out_gunlock_q;
221
222                 error = gfs2_trans_begin(sdp, sdp->sd_max_dirres +
223                                          al->al_rgd->rd_length +
224                                          2 * RES_DINODE + RES_STATFS +
225                                          RES_QUOTA, 0);
226                 if (error)
227                         goto out_ipres;
228         } else {
229                 error = gfs2_trans_begin(sdp, 2 * RES_DINODE + RES_LEAF, 0);
230                 if (error)
231                         goto out_ipres;
232         }
233
234         error = gfs2_dir_add(dir, &dentry->d_name, ip, IF2DT(inode->i_mode));
235         if (error)
236                 goto out_end_trans;
237
238         error = gfs2_change_nlink(ip, +1);
239
240 out_end_trans:
241         gfs2_trans_end(sdp);
242 out_ipres:
243         if (alloc_required)
244                 gfs2_inplace_release(dip);
245 out_gunlock_q:
246         if (alloc_required)
247                 gfs2_quota_unlock(dip);
248 out_alloc:
249         if (alloc_required)
250                 gfs2_alloc_put(dip);
251 out_gunlock:
252         gfs2_glock_dq(ghs + 1);
253 out_child:
254         gfs2_glock_dq(ghs);
255 out_parent:
256         gfs2_holder_uninit(ghs);
257         gfs2_holder_uninit(ghs + 1);
258         if (!error) {
259                 atomic_inc(&inode->i_count);
260                 d_instantiate(dentry, inode);
261                 mark_inode_dirty(inode);
262         }
263         return error;
264 }
265
266 /**
267  * gfs2_unlink - Unlink a file
268  * @dir: The inode of the directory containing the file to unlink
269  * @dentry: The file itself
270  *
271  * Unlink a file.  Call gfs2_unlinki()
272  *
273  * Returns: errno
274  */
275
276 static int gfs2_unlink(struct inode *dir, struct dentry *dentry)
277 {
278         struct gfs2_inode *dip = GFS2_I(dir);
279         struct gfs2_sbd *sdp = GFS2_SB(dir);
280         struct gfs2_inode *ip = GFS2_I(dentry->d_inode);
281         struct gfs2_holder ghs[3];
282         struct gfs2_rgrpd *rgd;
283         struct gfs2_holder ri_gh;
284         int error;
285
286         error = gfs2_rindex_hold(sdp, &ri_gh);
287         if (error)
288                 return error;
289
290         gfs2_holder_init(dip->i_gl, LM_ST_EXCLUSIVE, 0, ghs);
291         gfs2_holder_init(ip->i_gl,  LM_ST_EXCLUSIVE, 0, ghs + 1);
292
293         rgd = gfs2_blk2rgrpd(sdp, ip->i_no_addr);
294         gfs2_holder_init(rgd->rd_gl, LM_ST_EXCLUSIVE, 0, ghs + 2);
295
296
297         error = gfs2_glock_nq(ghs); /* parent */
298         if (error)
299                 goto out_parent;
300
301         error = gfs2_glock_nq(ghs + 1); /* child */
302         if (error)
303                 goto out_child;
304
305         error = gfs2_glock_nq(ghs + 2); /* rgrp */
306         if (error)
307                 goto out_rgrp;
308
309         error = gfs2_unlink_ok(dip, &dentry->d_name, ip);
310         if (error)
311                 goto out_gunlock;
312
313         error = gfs2_trans_begin(sdp, 2*RES_DINODE + RES_LEAF + RES_RG_BIT, 0);
314         if (error)
315                 goto out_rgrp;
316
317         error = gfs2_dir_del(dip, &dentry->d_name);
318         if (error)
319                 goto out_end_trans;
320
321         error = gfs2_change_nlink(ip, -1);
322
323 out_end_trans:
324         gfs2_trans_end(sdp);
325 out_gunlock:
326         gfs2_glock_dq(ghs + 2);
327 out_rgrp:
328         gfs2_holder_uninit(ghs + 2);
329         gfs2_glock_dq(ghs + 1);
330 out_child:
331         gfs2_holder_uninit(ghs + 1);
332         gfs2_glock_dq(ghs);
333 out_parent:
334         gfs2_holder_uninit(ghs);
335         gfs2_glock_dq_uninit(&ri_gh);
336         return error;
337 }
338
339 /**
340  * gfs2_symlink - Create a symlink
341  * @dir: The directory to create the symlink in
342  * @dentry: The dentry to put the symlink in
343  * @symname: The thing which the link points to
344  *
345  * Returns: errno
346  */
347
348 static int gfs2_symlink(struct inode *dir, struct dentry *dentry,
349                         const char *symname)
350 {
351         struct gfs2_inode *dip = GFS2_I(dir), *ip;
352         struct gfs2_sbd *sdp = GFS2_SB(dir);
353         struct gfs2_holder ghs[2];
354         struct inode *inode;
355         struct buffer_head *dibh;
356         int size;
357         int error;
358
359         /* Must be stuffed with a null terminator for gfs2_follow_link() */
360         size = strlen(symname);
361         if (size > sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode) - 1)
362                 return -ENAMETOOLONG;
363
364         gfs2_holder_init(dip->i_gl, 0, 0, ghs);
365
366         inode = gfs2_createi(ghs, &dentry->d_name, S_IFLNK | S_IRWXUGO, 0);
367         if (IS_ERR(inode)) {
368                 gfs2_holder_uninit(ghs);
369                 return PTR_ERR(inode);
370         }
371
372         ip = ghs[1].gh_gl->gl_object;
373
374         ip->i_di.di_size = size;
375
376         error = gfs2_meta_inode_buffer(ip, &dibh);
377
378         if (!gfs2_assert_withdraw(sdp, !error)) {
379                 gfs2_dinode_out(ip, dibh->b_data);
380                 memcpy(dibh->b_data + sizeof(struct gfs2_dinode), symname,
381                        size);
382                 brelse(dibh);
383         }
384
385         gfs2_trans_end(sdp);
386         if (dip->i_alloc->al_rgd)
387                 gfs2_inplace_release(dip);
388         gfs2_quota_unlock(dip);
389         gfs2_alloc_put(dip);
390
391         gfs2_glock_dq_uninit_m(2, ghs);
392
393         d_instantiate(dentry, inode);
394         mark_inode_dirty(inode);
395
396         return 0;
397 }
398
399 /**
400  * gfs2_mkdir - Make a directory
401  * @dir: The parent directory of the new one
402  * @dentry: The dentry of the new directory
403  * @mode: The mode of the new directory
404  *
405  * Returns: errno
406  */
407
408 static int gfs2_mkdir(struct inode *dir, struct dentry *dentry, int mode)
409 {
410         struct gfs2_inode *dip = GFS2_I(dir), *ip;
411         struct gfs2_sbd *sdp = GFS2_SB(dir);
412         struct gfs2_holder ghs[2];
413         struct inode *inode;
414         struct buffer_head *dibh;
415         int error;
416
417         gfs2_holder_init(dip->i_gl, 0, 0, ghs);
418
419         inode = gfs2_createi(ghs, &dentry->d_name, S_IFDIR | mode, 0);
420         if (IS_ERR(inode)) {
421                 gfs2_holder_uninit(ghs);
422                 return PTR_ERR(inode);
423         }
424
425         ip = ghs[1].gh_gl->gl_object;
426
427         ip->i_inode.i_nlink = 2;
428         ip->i_di.di_size = sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode);
429         ip->i_di.di_flags |= GFS2_DIF_JDATA;
430         ip->i_di.di_entries = 2;
431
432         error = gfs2_meta_inode_buffer(ip, &dibh);
433
434         if (!gfs2_assert_withdraw(sdp, !error)) {
435                 struct gfs2_dinode *di = (struct gfs2_dinode *)dibh->b_data;
436                 struct gfs2_dirent *dent = (struct gfs2_dirent *)(di+1);
437                 struct qstr str;
438
439                 gfs2_str2qstr(&str, ".");
440                 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
441                 gfs2_qstr2dirent(&str, GFS2_DIRENT_SIZE(str.len), dent);
442                 dent->de_inum = di->di_num; /* already GFS2 endian */
443                 dent->de_type = cpu_to_be16(DT_DIR);
444                 di->di_entries = cpu_to_be32(1);
445
446                 gfs2_str2qstr(&str, "..");
447                 dent = (struct gfs2_dirent *)((char*)dent + GFS2_DIRENT_SIZE(1));
448                 gfs2_qstr2dirent(&str, dibh->b_size - GFS2_DIRENT_SIZE(1) - sizeof(struct gfs2_dinode), dent);
449
450                 gfs2_inum_out(dip, dent);
451                 dent->de_type = cpu_to_be16(DT_DIR);
452
453                 gfs2_dinode_out(ip, di);
454
455                 brelse(dibh);
456         }
457
458         error = gfs2_change_nlink(dip, +1);
459         gfs2_assert_withdraw(sdp, !error); /* dip already pinned */
460
461         gfs2_trans_end(sdp);
462         if (dip->i_alloc->al_rgd)
463                 gfs2_inplace_release(dip);
464         gfs2_quota_unlock(dip);
465         gfs2_alloc_put(dip);
466
467         gfs2_glock_dq_uninit_m(2, ghs);
468
469         d_instantiate(dentry, inode);
470         mark_inode_dirty(inode);
471
472         return 0;
473 }
474
475 /**
476  * gfs2_rmdir - Remove a directory
477  * @dir: The parent directory of the directory to be removed
478  * @dentry: The dentry of the directory to remove
479  *
480  * Remove a directory. Call gfs2_rmdiri()
481  *
482  * Returns: errno
483  */
484
485 static int gfs2_rmdir(struct inode *dir, struct dentry *dentry)
486 {
487         struct gfs2_inode *dip = GFS2_I(dir);
488         struct gfs2_sbd *sdp = GFS2_SB(dir);
489         struct gfs2_inode *ip = GFS2_I(dentry->d_inode);
490         struct gfs2_holder ghs[3];
491         struct gfs2_rgrpd *rgd;
492         struct gfs2_holder ri_gh;
493         int error;
494
495         error = gfs2_rindex_hold(sdp, &ri_gh);
496         if (error)
497                 return error;
498         gfs2_holder_init(dip->i_gl, LM_ST_EXCLUSIVE, 0, ghs);
499         gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + 1);
500
501         rgd = gfs2_blk2rgrpd(sdp, ip->i_no_addr);
502         gfs2_holder_init(rgd->rd_gl, LM_ST_EXCLUSIVE, 0, ghs + 2);
503
504         error = gfs2_glock_nq(ghs); /* parent */
505         if (error)
506                 goto out_parent;
507
508         error = gfs2_glock_nq(ghs + 1); /* child */
509         if (error)
510                 goto out_child;
511
512         error = gfs2_glock_nq(ghs + 2); /* rgrp */
513         if (error)
514                 goto out_rgrp;
515
516         error = gfs2_unlink_ok(dip, &dentry->d_name, ip);
517         if (error)
518                 goto out_gunlock;
519
520         if (ip->i_di.di_entries < 2) {
521                 if (gfs2_consist_inode(ip))
522                         gfs2_dinode_print(ip);
523                 error = -EIO;
524                 goto out_gunlock;
525         }
526         if (ip->i_di.di_entries > 2) {
527                 error = -ENOTEMPTY;
528                 goto out_gunlock;
529         }
530
531         error = gfs2_trans_begin(sdp, 2 * RES_DINODE + 3 * RES_LEAF + RES_RG_BIT, 0);
532         if (error)
533                 goto out_gunlock;
534
535         error = gfs2_rmdiri(dip, &dentry->d_name, ip);
536
537         gfs2_trans_end(sdp);
538
539 out_gunlock:
540         gfs2_glock_dq(ghs + 2);
541 out_rgrp:
542         gfs2_holder_uninit(ghs + 2);
543         gfs2_glock_dq(ghs + 1);
544 out_child:
545         gfs2_holder_uninit(ghs + 1);
546         gfs2_glock_dq(ghs);
547 out_parent:
548         gfs2_holder_uninit(ghs);
549         gfs2_glock_dq_uninit(&ri_gh);
550         return error;
551 }
552
553 /**
554  * gfs2_mknod - Make a special file
555  * @dir: The directory in which the special file will reside
556  * @dentry: The dentry of the special file
557  * @mode: The mode of the special file
558  * @rdev: The device specification of the special file
559  *
560  */
561
562 static int gfs2_mknod(struct inode *dir, struct dentry *dentry, int mode,
563                       dev_t dev)
564 {
565         struct gfs2_inode *dip = GFS2_I(dir);
566         struct gfs2_sbd *sdp = GFS2_SB(dir);
567         struct gfs2_holder ghs[2];
568         struct inode *inode;
569
570         gfs2_holder_init(dip->i_gl, 0, 0, ghs);
571
572         inode = gfs2_createi(ghs, &dentry->d_name, mode, dev);
573         if (IS_ERR(inode)) {
574                 gfs2_holder_uninit(ghs);
575                 return PTR_ERR(inode);
576         }
577
578         gfs2_trans_end(sdp);
579         if (dip->i_alloc->al_rgd)
580                 gfs2_inplace_release(dip);
581         gfs2_quota_unlock(dip);
582         gfs2_alloc_put(dip);
583
584         gfs2_glock_dq_uninit_m(2, ghs);
585
586         d_instantiate(dentry, inode);
587         mark_inode_dirty(inode);
588
589         return 0;
590 }
591
592 /*
593  * gfs2_ok_to_move - check if it's ok to move a directory to another directory
594  * @this: move this
595  * @to: to here
596  *
597  * Follow @to back to the root and make sure we don't encounter @this
598  * Assumes we already hold the rename lock.
599  *
600  * Returns: errno
601  */
602
603 static int gfs2_ok_to_move(struct gfs2_inode *this, struct gfs2_inode *to)
604 {
605         struct inode *dir = &to->i_inode;
606         struct super_block *sb = dir->i_sb;
607         struct inode *tmp;
608         struct qstr dotdot;
609         int error = 0;
610
611         gfs2_str2qstr(&dotdot, "..");
612
613         igrab(dir);
614
615         for (;;) {
616                 if (dir == &this->i_inode) {
617                         error = -EINVAL;
618                         break;
619                 }
620                 if (dir == sb->s_root->d_inode) {
621                         error = 0;
622                         break;
623                 }
624
625                 tmp = gfs2_lookupi(dir, &dotdot, 1);
626                 if (IS_ERR(tmp)) {
627                         error = PTR_ERR(tmp);
628                         break;
629                 }
630
631                 iput(dir);
632                 dir = tmp;
633         }
634
635         iput(dir);
636
637         return error;
638 }
639
640 /**
641  * gfs2_rename - Rename a file
642  * @odir: Parent directory of old file name
643  * @odentry: The old dentry of the file
644  * @ndir: Parent directory of new file name
645  * @ndentry: The new dentry of the file
646  *
647  * Returns: errno
648  */
649
650 static int gfs2_rename(struct inode *odir, struct dentry *odentry,
651                        struct inode *ndir, struct dentry *ndentry)
652 {
653         struct gfs2_inode *odip = GFS2_I(odir);
654         struct gfs2_inode *ndip = GFS2_I(ndir);
655         struct gfs2_inode *ip = GFS2_I(odentry->d_inode);
656         struct gfs2_inode *nip = NULL;
657         struct gfs2_sbd *sdp = GFS2_SB(odir);
658         struct gfs2_holder ghs[5], r_gh = { .gh_gl = NULL, };
659         struct gfs2_rgrpd *nrgd;
660         unsigned int num_gh;
661         int dir_rename = 0;
662         int alloc_required;
663         unsigned int x;
664         int error;
665
666         if (ndentry->d_inode) {
667                 nip = GFS2_I(ndentry->d_inode);
668                 if (ip == nip)
669                         return 0;
670         }
671
672
673         if (odip != ndip) {
674                 error = gfs2_glock_nq_init(sdp->sd_rename_gl, LM_ST_EXCLUSIVE,
675                                            0, &r_gh);
676                 if (error)
677                         goto out;
678
679                 if (S_ISDIR(ip->i_inode.i_mode)) {
680                         dir_rename = 1;
681                         /* don't move a dirctory into it's subdir */
682                         error = gfs2_ok_to_move(ip, ndip);
683                         if (error)
684                                 goto out_gunlock_r;
685                 }
686         }
687
688         num_gh = 1;
689         gfs2_holder_init(odip->i_gl, LM_ST_EXCLUSIVE, 0, ghs);
690         if (odip != ndip) {
691                 gfs2_holder_init(ndip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + num_gh);
692                 num_gh++;
693         }
694         gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + num_gh);
695         num_gh++;
696
697         if (nip) {
698                 gfs2_holder_init(nip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + num_gh);
699                 num_gh++;
700                 /* grab the resource lock for unlink flag twiddling 
701                  * this is the case of the target file already existing
702                  * so we unlink before doing the rename
703                  */
704                 nrgd = gfs2_blk2rgrpd(sdp, nip->i_no_addr);
705                 if (nrgd)
706                         gfs2_holder_init(nrgd->rd_gl, LM_ST_EXCLUSIVE, 0, ghs + num_gh++);
707         }
708
709         for (x = 0; x < num_gh; x++) {
710                 error = gfs2_glock_nq(ghs + x);
711                 if (error)
712                         goto out_gunlock;
713         }
714
715         /* Check out the old directory */
716
717         error = gfs2_unlink_ok(odip, &odentry->d_name, ip);
718         if (error)
719                 goto out_gunlock;
720
721         /* Check out the new directory */
722
723         if (nip) {
724                 error = gfs2_unlink_ok(ndip, &ndentry->d_name, nip);
725                 if (error)
726                         goto out_gunlock;
727
728                 if (S_ISDIR(nip->i_inode.i_mode)) {
729                         if (nip->i_di.di_entries < 2) {
730                                 if (gfs2_consist_inode(nip))
731                                         gfs2_dinode_print(nip);
732                                 error = -EIO;
733                                 goto out_gunlock;
734                         }
735                         if (nip->i_di.di_entries > 2) {
736                                 error = -ENOTEMPTY;
737                                 goto out_gunlock;
738                         }
739                 }
740         } else {
741                 error = gfs2_permission(ndir, MAY_WRITE | MAY_EXEC);
742                 if (error)
743                         goto out_gunlock;
744
745                 error = gfs2_dir_check(ndir, &ndentry->d_name, NULL);
746                 switch (error) {
747                 case -ENOENT:
748                         error = 0;
749                         break;
750                 case 0:
751                         error = -EEXIST;
752                 default:
753                         goto out_gunlock;
754                 };
755
756                 if (odip != ndip) {
757                         if (!ndip->i_inode.i_nlink) {
758                                 error = -EINVAL;
759                                 goto out_gunlock;
760                         }
761                         if (ndip->i_di.di_entries == (u32)-1) {
762                                 error = -EFBIG;
763                                 goto out_gunlock;
764                         }
765                         if (S_ISDIR(ip->i_inode.i_mode) &&
766                             ndip->i_inode.i_nlink == (u32)-1) {
767                                 error = -EMLINK;
768                                 goto out_gunlock;
769                         }
770                 }
771         }
772
773         /* Check out the dir to be renamed */
774
775         if (dir_rename) {
776                 error = gfs2_permission(odentry->d_inode, MAY_WRITE);
777                 if (error)
778                         goto out_gunlock;
779         }
780
781         alloc_required = error = gfs2_diradd_alloc_required(ndir, &ndentry->d_name);
782         if (error < 0)
783                 goto out_gunlock;
784         error = 0;
785
786         if (alloc_required) {
787                 struct gfs2_alloc *al = gfs2_alloc_get(ndip);
788                 if (!al) {
789                         error = -ENOMEM;
790                         goto out_gunlock;
791                 }
792
793                 error = gfs2_quota_lock_check(ndip);
794                 if (error)
795                         goto out_alloc;
796
797                 al->al_requested = sdp->sd_max_dirres;
798
799                 error = gfs2_inplace_reserve(ndip);
800                 if (error)
801                         goto out_gunlock_q;
802
803                 error = gfs2_trans_begin(sdp, sdp->sd_max_dirres +
804                                          al->al_rgd->rd_length +
805                                          4 * RES_DINODE + 4 * RES_LEAF +
806                                          RES_STATFS + RES_QUOTA + 4, 0);
807                 if (error)
808                         goto out_ipreserv;
809         } else {
810                 error = gfs2_trans_begin(sdp, 4 * RES_DINODE +
811                                          5 * RES_LEAF + 4, 0);
812                 if (error)
813                         goto out_gunlock;
814         }
815
816         /* Remove the target file, if it exists */
817
818         if (nip) {
819                 if (S_ISDIR(nip->i_inode.i_mode))
820                         error = gfs2_rmdiri(ndip, &ndentry->d_name, nip);
821                 else {
822                         error = gfs2_dir_del(ndip, &ndentry->d_name);
823                         if (error)
824                                 goto out_end_trans;
825                         error = gfs2_change_nlink(nip, -1);
826                 }
827                 if (error)
828                         goto out_end_trans;
829         }
830
831         if (dir_rename) {
832                 struct qstr name;
833                 gfs2_str2qstr(&name, "..");
834
835                 error = gfs2_change_nlink(ndip, +1);
836                 if (error)
837                         goto out_end_trans;
838                 error = gfs2_change_nlink(odip, -1);
839                 if (error)
840                         goto out_end_trans;
841
842                 error = gfs2_dir_mvino(ip, &name, ndip, DT_DIR);
843                 if (error)
844                         goto out_end_trans;
845         } else {
846                 struct buffer_head *dibh;
847                 error = gfs2_meta_inode_buffer(ip, &dibh);
848                 if (error)
849                         goto out_end_trans;
850                 ip->i_inode.i_ctime = CURRENT_TIME;
851                 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
852                 gfs2_dinode_out(ip, dibh->b_data);
853                 brelse(dibh);
854         }
855
856         error = gfs2_dir_del(odip, &odentry->d_name);
857         if (error)
858                 goto out_end_trans;
859
860         error = gfs2_dir_add(ndir, &ndentry->d_name, ip, IF2DT(ip->i_inode.i_mode));
861         if (error)
862                 goto out_end_trans;
863
864 out_end_trans:
865         gfs2_trans_end(sdp);
866 out_ipreserv:
867         if (alloc_required)
868                 gfs2_inplace_release(ndip);
869 out_gunlock_q:
870         if (alloc_required)
871                 gfs2_quota_unlock(ndip);
872 out_alloc:
873         if (alloc_required)
874                 gfs2_alloc_put(ndip);
875 out_gunlock:
876         while (x--) {
877                 gfs2_glock_dq(ghs + x);
878                 gfs2_holder_uninit(ghs + x);
879         }
880 out_gunlock_r:
881         if (r_gh.gh_gl)
882                 gfs2_glock_dq_uninit(&r_gh);
883 out:
884         return error;
885 }
886
887 /**
888  * gfs2_readlink - Read the value of a symlink
889  * @dentry: the symlink
890  * @buf: the buffer to read the symlink data into
891  * @size: the size of the buffer
892  *
893  * Returns: errno
894  */
895
896 static int gfs2_readlink(struct dentry *dentry, char __user *user_buf,
897                          int user_size)
898 {
899         struct gfs2_inode *ip = GFS2_I(dentry->d_inode);
900         char array[GFS2_FAST_NAME_SIZE], *buf = array;
901         unsigned int len = GFS2_FAST_NAME_SIZE;
902         int error;
903
904         error = gfs2_readlinki(ip, &buf, &len);
905         if (error)
906                 return error;
907
908         if (user_size > len - 1)
909                 user_size = len - 1;
910
911         if (copy_to_user(user_buf, buf, user_size))
912                 error = -EFAULT;
913         else
914                 error = user_size;
915
916         if (buf != array)
917                 kfree(buf);
918
919         return error;
920 }
921
922 /**
923  * gfs2_follow_link - Follow a symbolic link
924  * @dentry: The dentry of the link
925  * @nd: Data that we pass to vfs_follow_link()
926  *
927  * This can handle symlinks of any size. It is optimised for symlinks
928  * under GFS2_FAST_NAME_SIZE.
929  *
930  * Returns: 0 on success or error code
931  */
932
933 static void *gfs2_follow_link(struct dentry *dentry, struct nameidata *nd)
934 {
935         struct gfs2_inode *ip = GFS2_I(dentry->d_inode);
936         char array[GFS2_FAST_NAME_SIZE], *buf = array;
937         unsigned int len = GFS2_FAST_NAME_SIZE;
938         int error;
939
940         error = gfs2_readlinki(ip, &buf, &len);
941         if (!error) {
942                 error = vfs_follow_link(nd, buf);
943                 if (buf != array)
944                         kfree(buf);
945         }
946
947         return ERR_PTR(error);
948 }
949
950 /**
951  * gfs2_permission -
952  * @inode:
953  * @mask:
954  * @nd: passed from Linux VFS, ignored by us
955  *
956  * This may be called from the VFS directly, or from within GFS2 with the
957  * inode locked, so we look to see if the glock is already locked and only
958  * lock the glock if its not already been done.
959  *
960  * Returns: errno
961  */
962
963 int gfs2_permission(struct inode *inode, int mask)
964 {
965         struct gfs2_inode *ip = GFS2_I(inode);
966         struct gfs2_holder i_gh;
967         int error;
968         int unlock = 0;
969
970         if (gfs2_glock_is_locked_by_me(ip->i_gl) == NULL) {
971                 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &i_gh);
972                 if (error)
973                         return error;
974                 unlock = 1;
975         }
976
977         if ((mask & MAY_WRITE) && IS_IMMUTABLE(inode))
978                 error = -EACCES;
979         else
980                 error = generic_permission(inode, mask, gfs2_check_acl);
981         if (unlock)
982                 gfs2_glock_dq_uninit(&i_gh);
983
984         return error;
985 }
986
987 static int setattr_size(struct inode *inode, struct iattr *attr)
988 {
989         struct gfs2_inode *ip = GFS2_I(inode);
990         struct gfs2_sbd *sdp = GFS2_SB(inode);
991         int error;
992
993         if (attr->ia_size != ip->i_di.di_size) {
994                 error = gfs2_trans_begin(sdp, 0, sdp->sd_jdesc->jd_blocks);
995                 if (error)
996                         return error;
997                 error = vmtruncate(inode, attr->ia_size);
998                 gfs2_trans_end(sdp);
999                 if (error) 
1000                         return error;
1001         }
1002
1003         error = gfs2_truncatei(ip, attr->ia_size);
1004         if (error && (inode->i_size != ip->i_di.di_size))
1005                 i_size_write(inode, ip->i_di.di_size);
1006
1007         return error;
1008 }
1009
1010 static int setattr_chown(struct inode *inode, struct iattr *attr)
1011 {
1012         struct gfs2_inode *ip = GFS2_I(inode);
1013         struct gfs2_sbd *sdp = GFS2_SB(inode);
1014         struct buffer_head *dibh;
1015         u32 ouid, ogid, nuid, ngid;
1016         int error;
1017
1018         ouid = inode->i_uid;
1019         ogid = inode->i_gid;
1020         nuid = attr->ia_uid;
1021         ngid = attr->ia_gid;
1022
1023         if (!(attr->ia_valid & ATTR_UID) || ouid == nuid)
1024                 ouid = nuid = NO_QUOTA_CHANGE;
1025         if (!(attr->ia_valid & ATTR_GID) || ogid == ngid)
1026                 ogid = ngid = NO_QUOTA_CHANGE;
1027
1028         if (!gfs2_alloc_get(ip))
1029                 return -ENOMEM;
1030
1031         error = gfs2_quota_lock(ip, nuid, ngid);
1032         if (error)
1033                 goto out_alloc;
1034
1035         if (ouid != NO_QUOTA_CHANGE || ogid != NO_QUOTA_CHANGE) {
1036                 error = gfs2_quota_check(ip, nuid, ngid);
1037                 if (error)
1038                         goto out_gunlock_q;
1039         }
1040
1041         error = gfs2_trans_begin(sdp, RES_DINODE + 2 * RES_QUOTA, 0);
1042         if (error)
1043                 goto out_gunlock_q;
1044
1045         error = gfs2_meta_inode_buffer(ip, &dibh);
1046         if (error)
1047                 goto out_end_trans;
1048
1049         error = inode_setattr(inode, attr);
1050         gfs2_assert_warn(sdp, !error);
1051
1052         gfs2_trans_add_bh(ip->i_gl, dibh, 1);
1053         gfs2_dinode_out(ip, dibh->b_data);
1054         brelse(dibh);
1055
1056         if (ouid != NO_QUOTA_CHANGE || ogid != NO_QUOTA_CHANGE) {
1057                 u64 blocks = gfs2_get_inode_blocks(&ip->i_inode);
1058                 gfs2_quota_change(ip, -blocks, ouid, ogid);
1059                 gfs2_quota_change(ip, blocks, nuid, ngid);
1060         }
1061
1062 out_end_trans:
1063         gfs2_trans_end(sdp);
1064 out_gunlock_q:
1065         gfs2_quota_unlock(ip);
1066 out_alloc:
1067         gfs2_alloc_put(ip);
1068         return error;
1069 }
1070
1071 /**
1072  * gfs2_setattr - Change attributes on an inode
1073  * @dentry: The dentry which is changing
1074  * @attr: The structure describing the change
1075  *
1076  * The VFS layer wants to change one or more of an inodes attributes.  Write
1077  * that change out to disk.
1078  *
1079  * Returns: errno
1080  */
1081
1082 static int gfs2_setattr(struct dentry *dentry, struct iattr *attr)
1083 {
1084         struct inode *inode = dentry->d_inode;
1085         struct gfs2_inode *ip = GFS2_I(inode);
1086         struct gfs2_holder i_gh;
1087         int error;
1088
1089         error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &i_gh);
1090         if (error)
1091                 return error;
1092
1093         error = -EPERM;
1094         if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
1095                 goto out;
1096
1097         error = inode_change_ok(inode, attr);
1098         if (error)
1099                 goto out;
1100
1101         if (attr->ia_valid & ATTR_SIZE)
1102                 error = setattr_size(inode, attr);
1103         else if (attr->ia_valid & (ATTR_UID | ATTR_GID))
1104                 error = setattr_chown(inode, attr);
1105         else if ((attr->ia_valid & ATTR_MODE) && IS_POSIXACL(inode))
1106                 error = gfs2_acl_chmod(ip, attr);
1107         else
1108                 error = gfs2_setattr_simple(ip, attr);
1109
1110 out:
1111         gfs2_glock_dq_uninit(&i_gh);
1112         if (!error)
1113                 mark_inode_dirty(inode);
1114         return error;
1115 }
1116
1117 /**
1118  * gfs2_getattr - Read out an inode's attributes
1119  * @mnt: The vfsmount the inode is being accessed from
1120  * @dentry: The dentry to stat
1121  * @stat: The inode's stats
1122  *
1123  * This may be called from the VFS directly, or from within GFS2 with the
1124  * inode locked, so we look to see if the glock is already locked and only
1125  * lock the glock if its not already been done. Note that its the NFS
1126  * readdirplus operation which causes this to be called (from filldir)
1127  * with the glock already held.
1128  *
1129  * Returns: errno
1130  */
1131
1132 static int gfs2_getattr(struct vfsmount *mnt, struct dentry *dentry,
1133                         struct kstat *stat)
1134 {
1135         struct inode *inode = dentry->d_inode;
1136         struct gfs2_inode *ip = GFS2_I(inode);
1137         struct gfs2_holder gh;
1138         int error;
1139         int unlock = 0;
1140
1141         if (gfs2_glock_is_locked_by_me(ip->i_gl) == NULL) {
1142                 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &gh);
1143                 if (error)
1144                         return error;
1145                 unlock = 1;
1146         }
1147
1148         generic_fillattr(inode, stat);
1149         if (unlock)
1150                 gfs2_glock_dq_uninit(&gh);
1151
1152         return 0;
1153 }
1154
1155 static int gfs2_setxattr(struct dentry *dentry, const char *name,
1156                          const void *data, size_t size, int flags)
1157 {
1158         struct inode *inode = dentry->d_inode;
1159         struct gfs2_ea_request er;
1160
1161         memset(&er, 0, sizeof(struct gfs2_ea_request));
1162         er.er_type = gfs2_ea_name2type(name, &er.er_name);
1163         if (er.er_type == GFS2_EATYPE_UNUSED)
1164                 return -EOPNOTSUPP;
1165         er.er_data = (char *)data;
1166         er.er_name_len = strlen(er.er_name);
1167         er.er_data_len = size;
1168         er.er_flags = flags;
1169
1170         gfs2_assert_warn(GFS2_SB(inode), !(er.er_flags & GFS2_ERF_MODE));
1171
1172         return gfs2_ea_set(GFS2_I(inode), &er);
1173 }
1174
1175 static ssize_t gfs2_getxattr(struct dentry *dentry, const char *name,
1176                              void *data, size_t size)
1177 {
1178         struct gfs2_ea_request er;
1179
1180         memset(&er, 0, sizeof(struct gfs2_ea_request));
1181         er.er_type = gfs2_ea_name2type(name, &er.er_name);
1182         if (er.er_type == GFS2_EATYPE_UNUSED)
1183                 return -EOPNOTSUPP;
1184         er.er_data = data;
1185         er.er_name_len = strlen(er.er_name);
1186         er.er_data_len = size;
1187
1188         return gfs2_ea_get(GFS2_I(dentry->d_inode), &er);
1189 }
1190
1191 static ssize_t gfs2_listxattr(struct dentry *dentry, char *buffer, size_t size)
1192 {
1193         struct gfs2_ea_request er;
1194
1195         memset(&er, 0, sizeof(struct gfs2_ea_request));
1196         er.er_data = (size) ? buffer : NULL;
1197         er.er_data_len = size;
1198
1199         return gfs2_ea_list(GFS2_I(dentry->d_inode), &er);
1200 }
1201
1202 static int gfs2_removexattr(struct dentry *dentry, const char *name)
1203 {
1204         struct gfs2_ea_request er;
1205
1206         memset(&er, 0, sizeof(struct gfs2_ea_request));
1207         er.er_type = gfs2_ea_name2type(name, &er.er_name);
1208         if (er.er_type == GFS2_EATYPE_UNUSED)
1209                 return -EOPNOTSUPP;
1210         er.er_name_len = strlen(er.er_name);
1211
1212         return gfs2_ea_remove(GFS2_I(dentry->d_inode), &er);
1213 }
1214
1215 const struct inode_operations gfs2_file_iops = {
1216         .permission = gfs2_permission,
1217         .setattr = gfs2_setattr,
1218         .getattr = gfs2_getattr,
1219         .setxattr = gfs2_setxattr,
1220         .getxattr = gfs2_getxattr,
1221         .listxattr = gfs2_listxattr,
1222         .removexattr = gfs2_removexattr,
1223 };
1224
1225 const struct inode_operations gfs2_dir_iops = {
1226         .create = gfs2_create,
1227         .lookup = gfs2_lookup,
1228         .link = gfs2_link,
1229         .unlink = gfs2_unlink,
1230         .symlink = gfs2_symlink,
1231         .mkdir = gfs2_mkdir,
1232         .rmdir = gfs2_rmdir,
1233         .mknod = gfs2_mknod,
1234         .rename = gfs2_rename,
1235         .permission = gfs2_permission,
1236         .setattr = gfs2_setattr,
1237         .getattr = gfs2_getattr,
1238         .setxattr = gfs2_setxattr,
1239         .getxattr = gfs2_getxattr,
1240         .listxattr = gfs2_listxattr,
1241         .removexattr = gfs2_removexattr,
1242 };
1243
1244 const struct inode_operations gfs2_symlink_iops = {
1245         .readlink = gfs2_readlink,
1246         .follow_link = gfs2_follow_link,
1247         .permission = gfs2_permission,
1248         .setattr = gfs2_setattr,
1249         .getattr = gfs2_getattr,
1250         .setxattr = gfs2_setxattr,
1251         .getxattr = gfs2_getxattr,
1252         .listxattr = gfs2_listxattr,
1253         .removexattr = gfs2_removexattr,
1254 };
1255