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