[GFS2] Reordering in deallocation to avoid recursive locking
[linux-2.6] / fs / gfs2 / inode.c
1 /*
2  * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
3  * Copyright (C) 2004-2005 Red Hat, Inc.  All rights reserved.
4  *
5  * This copyrighted material is made available to anyone wishing to use,
6  * modify, copy, or redistribute it subject to the terms and conditions
7  * of the GNU General Public License v.2.
8  */
9
10 #include <linux/sched.h>
11 #include <linux/slab.h>
12 #include <linux/spinlock.h>
13 #include <linux/completion.h>
14 #include <linux/buffer_head.h>
15 #include <linux/posix_acl.h>
16 #include <linux/sort.h>
17 #include <linux/gfs2_ondisk.h>
18 #include <linux/crc32.h>
19 #include <asm/semaphore.h>
20
21 #include "gfs2.h"
22 #include "lm_interface.h"
23 #include "incore.h"
24 #include "acl.h"
25 #include "bmap.h"
26 #include "dir.h"
27 #include "eattr.h"
28 #include "glock.h"
29 #include "glops.h"
30 #include "inode.h"
31 #include "log.h"
32 #include "meta_io.h"
33 #include "ops_address.h"
34 #include "ops_file.h"
35 #include "ops_inode.h"
36 #include "quota.h"
37 #include "rgrp.h"
38 #include "trans.h"
39 #include "unlinked.h"
40 #include "util.h"
41
42 /**
43  * inode_attr_in - Copy attributes from the dinode into the VFS inode
44  * @ip: The GFS2 inode (with embedded disk inode data)
45  * @inode:  The Linux VFS inode
46  *
47  */
48
49 static void inode_attr_in(struct gfs2_inode *ip, struct inode *inode)
50 {
51         inode->i_ino = ip->i_num.no_formal_ino;
52
53         switch (ip->i_di.di_mode & S_IFMT) {
54         case S_IFBLK:
55         case S_IFCHR:
56                 inode->i_rdev = MKDEV(ip->i_di.di_major, ip->i_di.di_minor);
57                 break;
58         default:
59                 inode->i_rdev = 0;
60                 break;
61         };
62
63         inode->i_mode = ip->i_di.di_mode;
64         inode->i_nlink = ip->i_di.di_nlink;
65         inode->i_uid = ip->i_di.di_uid;
66         inode->i_gid = ip->i_di.di_gid;
67         i_size_write(inode, ip->i_di.di_size);
68         inode->i_atime.tv_sec = ip->i_di.di_atime;
69         inode->i_mtime.tv_sec = ip->i_di.di_mtime;
70         inode->i_ctime.tv_sec = ip->i_di.di_ctime;
71         inode->i_atime.tv_nsec = 0;
72         inode->i_mtime.tv_nsec = 0;
73         inode->i_ctime.tv_nsec = 0;
74         inode->i_blksize = PAGE_SIZE;
75         inode->i_blocks = ip->i_di.di_blocks <<
76                 (ip->i_sbd->sd_sb.sb_bsize_shift - GFS2_BASIC_BLOCK_SHIFT);
77
78         if (ip->i_di.di_flags & GFS2_DIF_IMMUTABLE)
79                 inode->i_flags |= S_IMMUTABLE;
80         else
81                 inode->i_flags &= ~S_IMMUTABLE;
82
83         if (ip->i_di.di_flags & GFS2_DIF_APPENDONLY)
84                 inode->i_flags |= S_APPEND;
85         else
86                 inode->i_flags &= ~S_APPEND;
87 }
88
89 /**
90  * gfs2_inode_attr_in - Copy attributes from the dinode into the VFS inode
91  * @ip: The GFS2 inode (with embedded disk inode data)
92  *
93  */
94
95 void gfs2_inode_attr_in(struct gfs2_inode *ip)
96 {
97         struct inode *inode;
98
99         inode = gfs2_ip2v_lookup(ip);
100         if (inode) {
101                 inode_attr_in(ip, inode);
102                 iput(inode);
103         }
104 }
105
106 /**
107  * gfs2_inode_attr_out - Copy attributes from VFS inode into the dinode
108  * @ip: The GFS2 inode
109  *
110  * Only copy out the attributes that we want the VFS layer
111  * to be able to modify.
112  */
113
114 void gfs2_inode_attr_out(struct gfs2_inode *ip)
115 {
116         struct inode *inode = ip->i_vnode;
117
118         gfs2_assert_withdraw(ip->i_sbd,
119                 (ip->i_di.di_mode & S_IFMT) == (inode->i_mode & S_IFMT));
120         ip->i_di.di_mode = inode->i_mode;
121         ip->i_di.di_uid = inode->i_uid;
122         ip->i_di.di_gid = inode->i_gid;
123         ip->i_di.di_atime = inode->i_atime.tv_sec;
124         ip->i_di.di_mtime = inode->i_mtime.tv_sec;
125         ip->i_di.di_ctime = inode->i_ctime.tv_sec;
126 }
127
128 /**
129  * gfs2_ip2v_lookup - Get the struct inode for a struct gfs2_inode
130  * @ip: the struct gfs2_inode to get the struct inode for
131  *
132  * Returns: A VFS inode, or NULL if none
133  */
134
135 struct inode *gfs2_ip2v_lookup(struct gfs2_inode *ip)
136 {
137         struct inode *inode = NULL;
138
139         gfs2_assert_warn(ip->i_sbd, test_bit(GIF_MIN_INIT, &ip->i_flags));
140
141         spin_lock(&ip->i_spin);
142         if (ip->i_vnode)
143                 inode = igrab(ip->i_vnode);
144         spin_unlock(&ip->i_spin);
145
146         return inode;
147 }
148
149 /**
150  * gfs2_ip2v - Get/Create a struct inode for a struct gfs2_inode
151  * @ip: the struct gfs2_inode to get the struct inode for
152  *
153  * Returns: A VFS inode, or NULL if no mem
154  */
155
156 struct inode *gfs2_ip2v(struct gfs2_inode *ip)
157 {
158         struct inode *inode, *tmp;
159
160         inode = gfs2_ip2v_lookup(ip);
161         if (inode)
162                 return inode;
163
164         tmp = new_inode(ip->i_sbd->sd_vfs);
165         if (!tmp)
166                 return NULL;
167
168         inode_attr_in(ip, tmp);
169
170         if (S_ISREG(ip->i_di.di_mode)) {
171                 tmp->i_op = &gfs2_file_iops;
172                 tmp->i_fop = &gfs2_file_fops;
173                 tmp->i_mapping->a_ops = &gfs2_file_aops;
174         } else if (S_ISDIR(ip->i_di.di_mode)) {
175                 tmp->i_op = &gfs2_dir_iops;
176                 tmp->i_fop = &gfs2_dir_fops;
177         } else if (S_ISLNK(ip->i_di.di_mode)) {
178                 tmp->i_op = &gfs2_symlink_iops;
179         } else {
180                 tmp->i_op = &gfs2_dev_iops;
181                 init_special_inode(tmp, tmp->i_mode, tmp->i_rdev);
182         }
183
184         tmp->u.generic_ip = NULL;
185
186         for (;;) {
187                 spin_lock(&ip->i_spin);
188                 if (!ip->i_vnode)
189                         break;
190                 inode = igrab(ip->i_vnode);
191                 spin_unlock(&ip->i_spin);
192
193                 if (inode) {
194                         iput(tmp);
195                         return inode;
196                 }
197                 yield();
198         }
199
200         inode = tmp;
201
202         gfs2_inode_hold(ip);
203         ip->i_vnode = inode;
204         inode->u.generic_ip = ip;
205
206         spin_unlock(&ip->i_spin);
207
208         insert_inode_hash(inode);
209
210         return inode;
211 }
212
213 static int iget_test(struct inode *inode, void *opaque)
214 {
215         struct gfs2_inode *ip = inode->u.generic_ip;
216         struct gfs2_inum *inum = (struct gfs2_inum *)opaque;
217
218         if (ip && ip->i_num.no_addr == inum->no_addr)
219                 return 1;
220
221         return 0;
222 }
223
224 struct inode *gfs2_iget(struct super_block *sb, struct gfs2_inum *inum)
225 {
226         return ilookup5(sb, (unsigned long)inum->no_formal_ino,
227                         iget_test, inum);
228 }
229
230 void gfs2_inode_min_init(struct gfs2_inode *ip, unsigned int type)
231 {
232         if (!test_and_set_bit(GIF_MIN_INIT, &ip->i_flags)) {
233                 ip->i_di.di_nlink = 1;
234                 ip->i_di.di_mode = DT2IF(type);
235         }
236 }
237
238 /**
239  * gfs2_inode_refresh - Refresh the incore copy of the dinode
240  * @ip: The GFS2 inode
241  *
242  * Returns: errno
243  */
244
245 int gfs2_inode_refresh(struct gfs2_inode *ip)
246 {
247         struct buffer_head *dibh;
248         int error;
249
250         error = gfs2_meta_inode_buffer(ip, &dibh);
251         if (error)
252                 return error;
253
254         if (gfs2_metatype_check(ip->i_sbd, dibh, GFS2_METATYPE_DI)) {
255                 brelse(dibh);
256                 return -EIO;
257         }
258
259         gfs2_dinode_in(&ip->i_di, dibh->b_data);
260         set_bit(GIF_MIN_INIT, &ip->i_flags);
261
262         brelse(dibh);
263
264         if (ip->i_num.no_addr != ip->i_di.di_num.no_addr) {
265                 if (gfs2_consist_inode(ip))
266                         gfs2_dinode_print(&ip->i_di);
267                 return -EIO;
268         }
269         if (ip->i_num.no_formal_ino != ip->i_di.di_num.no_formal_ino)
270                 return -ESTALE;
271
272         ip->i_vn = ip->i_gl->gl_vn;
273
274         return 0;
275 }
276
277 /**
278  * inode_create - create a struct gfs2_inode
279  * @i_gl: The glock covering the inode
280  * @inum: The inode number
281  * @io_gl: the iopen glock to acquire/hold (using holder in new gfs2_inode)
282  * @io_state: the state the iopen glock should be acquired in
283  * @ipp: pointer to put the returned inode in
284  *
285  * Returns: errno
286  */
287
288 static int inode_create(struct gfs2_glock *i_gl, const struct gfs2_inum *inum,
289                         struct gfs2_glock *io_gl, unsigned int io_state,
290                         struct gfs2_inode **ipp, int need_lock)
291 {
292         struct gfs2_sbd *sdp = i_gl->gl_sbd;
293         struct gfs2_inode *ip;
294         int error = 0;
295
296         ip = kmem_cache_alloc(gfs2_inode_cachep, GFP_KERNEL);
297         if (!ip)
298                 return -ENOMEM;
299         memset(ip, 0, sizeof(struct gfs2_inode));
300
301         ip->i_num = *inum;
302
303         atomic_set(&ip->i_count, 1);
304
305         ip->i_vn = i_gl->gl_vn - 1;
306
307         ip->i_gl = i_gl;
308         ip->i_sbd = sdp;
309
310         spin_lock_init(&ip->i_spin);
311         init_rwsem(&ip->i_rw_mutex);
312
313         ip->i_greedy = gfs2_tune_get(sdp, gt_greedy_default);
314
315         if (need_lock) {
316                 error = gfs2_glock_nq_init(io_gl,
317                                            io_state, GL_LOCAL_EXCL | GL_EXACT,
318                                            &ip->i_iopen_gh);
319                 if (error)
320                         goto fail;
321         }
322         ip->i_iopen_gh.gh_owner = NULL;
323
324         spin_lock(&io_gl->gl_spin);
325         gfs2_glock_hold(i_gl);
326         io_gl->gl_object = i_gl;
327         spin_unlock(&io_gl->gl_spin);
328
329         gfs2_glock_hold(i_gl);
330         i_gl->gl_object = ip;
331
332         atomic_inc(&sdp->sd_inode_count);
333
334         *ipp = ip;
335
336         return 0;
337
338  fail:
339         gfs2_meta_cache_flush(ip);
340         kmem_cache_free(gfs2_inode_cachep, ip);
341         *ipp = NULL;
342
343         return error;
344 }
345
346 /**
347  * gfs2_inode_get - Create or get a reference on an inode
348  * @i_gl: The glock covering the inode
349  * @inum: The inode number
350  * @create:
351  * @ipp: pointer to put the returned inode in
352  *
353  * Returns: errno
354  */
355
356 int gfs2_inode_get(struct gfs2_glock *i_gl, const struct gfs2_inum *inum,
357                    int create, struct gfs2_inode **ipp)
358 {
359         struct gfs2_sbd *sdp = i_gl->gl_sbd;
360         struct gfs2_glock *io_gl;
361         int error = 0;
362
363         gfs2_glmutex_lock(i_gl);
364
365         *ipp = i_gl->gl_object;
366         if (*ipp) {
367                 error = -ESTALE;
368                 if ((*ipp)->i_num.no_formal_ino != inum->no_formal_ino)
369                         goto out;
370                 atomic_inc(&(*ipp)->i_count);
371                 error = 0;
372                 goto out;
373         }
374
375         if (!create)
376                 goto out;
377
378         error = gfs2_glock_get(sdp, inum->no_addr, &gfs2_iopen_glops,
379                                CREATE, &io_gl);
380         if (!error) {
381                 error = inode_create(i_gl, inum, io_gl, LM_ST_SHARED, ipp, 1);
382                 gfs2_glock_put(io_gl);
383         }
384
385  out:
386         gfs2_glmutex_unlock(i_gl);
387
388         return error;
389 }
390
391 void gfs2_inode_hold(struct gfs2_inode *ip)
392 {
393         gfs2_assert(ip->i_sbd, atomic_read(&ip->i_count) > 0);
394         atomic_inc(&ip->i_count);
395 }
396
397 void gfs2_inode_put(struct gfs2_inode *ip)
398 {
399         gfs2_assert(ip->i_sbd, atomic_read(&ip->i_count) > 0);
400         atomic_dec(&ip->i_count);
401 }
402
403 void gfs2_inode_destroy(struct gfs2_inode *ip, int unlock)
404 {
405         struct gfs2_sbd *sdp = ip->i_sbd;
406         struct gfs2_glock *i_gl = ip->i_gl;
407
408         gfs2_assert_warn(sdp, !atomic_read(&ip->i_count));
409         if (unlock) {
410                 struct gfs2_glock *io_gl = ip->i_iopen_gh.gh_gl;
411                 gfs2_assert(sdp, io_gl->gl_object == i_gl);
412         
413                 spin_lock(&io_gl->gl_spin);
414                 io_gl->gl_object = NULL;
415                 spin_unlock(&io_gl->gl_spin);
416                 gfs2_glock_put(i_gl);
417         
418                 gfs2_glock_dq_uninit(&ip->i_iopen_gh);
419         }
420
421         gfs2_meta_cache_flush(ip);
422         kmem_cache_free(gfs2_inode_cachep, ip);
423
424         i_gl->gl_object = NULL;
425         gfs2_glock_put(i_gl);
426
427         atomic_dec(&sdp->sd_inode_count);
428 }
429
430 static int dinode_dealloc(struct gfs2_inode *ip, struct gfs2_unlinked *ul)
431 {
432         struct gfs2_sbd *sdp = ip->i_sbd;
433         struct gfs2_alloc *al;
434         struct gfs2_rgrpd *rgd;
435         int error;
436
437         if (ip->i_di.di_blocks != 1) {
438                 if (gfs2_consist_inode(ip))
439                         gfs2_dinode_print(&ip->i_di);
440                 return -EIO;
441         }
442
443         al = gfs2_alloc_get(ip);
444
445         error = gfs2_quota_hold(ip, NO_QUOTA_CHANGE, NO_QUOTA_CHANGE);
446         if (error)
447                 goto out;
448
449         error = gfs2_rindex_hold(sdp, &al->al_ri_gh);
450         if (error)
451                 goto out_qs;
452
453         rgd = gfs2_blk2rgrpd(sdp, ip->i_num.no_addr);
454         if (!rgd) {
455                 gfs2_consist_inode(ip);
456                 error = -EIO;
457                 goto out_rindex_relse;
458         }
459
460         error = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_EXCLUSIVE, 0,
461                                    &al->al_rgd_gh);
462         if (error)
463                 goto out_rindex_relse;
464
465         error = gfs2_trans_begin(sdp, RES_RG_BIT + RES_UNLINKED +
466                                  RES_STATFS + RES_QUOTA, 1);
467         if (error)
468                 goto out_rg_gunlock;
469
470         gfs2_trans_add_gl(ip->i_gl);
471
472         gfs2_free_di(rgd, ip);
473
474         error = gfs2_unlinked_ondisk_rm(sdp, ul);
475
476         gfs2_trans_end(sdp);
477         clear_bit(GLF_STICKY, &ip->i_gl->gl_flags);
478
479  out_rg_gunlock:
480         gfs2_glock_dq_uninit(&al->al_rgd_gh);
481
482  out_rindex_relse:
483         gfs2_glock_dq_uninit(&al->al_ri_gh);
484
485  out_qs:
486         gfs2_quota_unhold(ip);
487
488  out:
489         gfs2_alloc_put(ip);
490
491         return error;
492 }
493
494 /**
495  * inode_dealloc - Deallocate all on-disk blocks for an inode (dinode)
496  * @sdp: the filesystem
497  * @inum: the inode number to deallocate
498  * @io_gh: a holder for the iopen glock for this inode
499  *
500  * N.B. When we enter this we already hold the iopen glock and getting
501  * the glock for the inode means that we are grabbing the locks in the
502  * "wrong" order so we must only so a try lock operation and fail if we
503  * don't get the lock. Thats ok, since if we fail it means someone else
504  * is using the inode still and thus we shouldn't be deallocating it
505  * anyway.
506  *
507  * Returns: errno
508  */
509
510 static int inode_dealloc(struct gfs2_sbd *sdp, struct gfs2_unlinked *ul,
511                          struct gfs2_holder *io_gh)
512 {
513         struct gfs2_inode *ip;
514         struct gfs2_holder i_gh;
515         int error;
516
517         error = gfs2_glock_nq_num(sdp, ul->ul_ut.ut_inum.no_addr,
518                                   &gfs2_inode_glops, LM_ST_EXCLUSIVE,
519                                   LM_FLAG_TRY_1CB, &i_gh);
520         switch(error) {
521         case 0:
522                 break;
523         case GLR_TRYFAILED:
524                 return 1; /* or back off and relock in different order? */
525         default:
526                 return error;
527         }
528
529         gfs2_assert_warn(sdp, !i_gh.gh_gl->gl_object);
530         error = inode_create(i_gh.gh_gl, &ul->ul_ut.ut_inum, io_gh->gh_gl,
531                              LM_ST_EXCLUSIVE, &ip, 0);
532
533         if (error)
534                 goto out;
535
536         error = gfs2_inode_refresh(ip);
537         if (error)
538                 goto out_iput;
539
540         if (ip->i_di.di_nlink) {
541                 if (gfs2_consist_inode(ip))
542                         gfs2_dinode_print(&ip->i_di);
543                 error = -EIO;
544                 goto out_iput;
545         }
546
547         if (S_ISDIR(ip->i_di.di_mode) &&
548             (ip->i_di.di_flags & GFS2_DIF_EXHASH)) {
549                 error = gfs2_dir_exhash_dealloc(ip);
550                 if (error)
551                         goto out_iput;
552         }
553
554         if (ip->i_di.di_eattr) {
555                 error = gfs2_ea_dealloc(ip);
556                 if (error)
557                         goto out_iput;
558         }
559
560         if (!gfs2_is_stuffed(ip)) {
561                 error = gfs2_file_dealloc(ip);
562                 if (error)
563                         goto out_iput;
564         }
565
566         error = dinode_dealloc(ip, ul);
567         if (error)
568                 goto out_iput;
569
570 out_iput:
571         gfs2_glmutex_lock(i_gh.gh_gl);
572         gfs2_inode_put(ip);
573         gfs2_inode_destroy(ip, 0);
574         gfs2_glmutex_unlock(i_gh.gh_gl);
575
576 out:
577         gfs2_glock_dq_uninit(&i_gh);
578
579         return error;
580 }
581
582 /**
583  * try_inode_dealloc - Try to deallocate an inode and all its blocks
584  * @sdp: the filesystem
585  *
586  * Returns: 0 on success, -errno on error, 1 on busy (inode open)
587  */
588
589 static int try_inode_dealloc(struct gfs2_sbd *sdp, struct gfs2_unlinked *ul)
590 {
591         int error = 0;
592         struct gfs2_holder iogh;
593
594         gfs2_try_toss_inode(sdp, &ul->ul_ut.ut_inum);
595         error = gfs2_glock_nq_num(sdp, ul->ul_ut.ut_inum.no_addr,
596                                   &gfs2_iopen_glops, LM_ST_EXCLUSIVE,
597                                   LM_FLAG_TRY_1CB, &iogh);
598         switch (error) {
599         case 0:
600                 break;
601         case GLR_TRYFAILED:
602                 return 1;
603         default:
604                 return error;
605         }
606
607         error = inode_dealloc(sdp, ul, &iogh);
608         gfs2_glock_dq_uninit(&iogh);
609
610         return error;
611 }
612
613 static int inode_dealloc_uninit(struct gfs2_sbd *sdp, struct gfs2_unlinked *ul)
614 {
615         struct gfs2_rgrpd *rgd;
616         struct gfs2_holder ri_gh, rgd_gh;
617         int error;
618
619         error = gfs2_rindex_hold(sdp, &ri_gh);
620         if (error)
621                 return error;
622
623         rgd = gfs2_blk2rgrpd(sdp, ul->ul_ut.ut_inum.no_addr);
624         if (!rgd) {
625                 gfs2_consist(sdp);
626                 error = -EIO;
627                 goto out;
628         }
629
630         error = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_EXCLUSIVE, 0, &rgd_gh);
631         if (error)
632                 goto out;
633
634         error = gfs2_trans_begin(sdp, RES_RG_BIT + RES_UNLINKED + RES_STATFS, 0);
635         if (error)
636                 goto out_gunlock;
637
638         gfs2_free_uninit_di(rgd, ul->ul_ut.ut_inum.no_addr);
639         gfs2_unlinked_ondisk_rm(sdp, ul);
640
641         gfs2_trans_end(sdp);
642
643  out_gunlock:
644         gfs2_glock_dq_uninit(&rgd_gh);
645  out:
646         gfs2_glock_dq_uninit(&ri_gh);
647
648         return error;
649 }
650
651 int gfs2_inode_dealloc(struct gfs2_sbd *sdp, struct gfs2_unlinked *ul)
652 {
653         if (ul->ul_ut.ut_flags & GFS2_UTF_UNINIT)
654                 return inode_dealloc_uninit(sdp, ul);
655         else
656                 return try_inode_dealloc(sdp, ul);
657 }
658
659 /**
660  * gfs2_change_nlink - Change nlink count on inode
661  * @ip: The GFS2 inode
662  * @diff: The change in the nlink count required
663  *
664  * Returns: errno
665  */
666
667 int gfs2_change_nlink(struct gfs2_inode *ip, int diff)
668 {
669         struct buffer_head *dibh;
670         uint32_t nlink;
671         int error;
672
673         nlink = ip->i_di.di_nlink + diff;
674
675         /* If we are reducing the nlink count, but the new value ends up being
676            bigger than the old one, we must have underflowed. */
677         if (diff < 0 && nlink > ip->i_di.di_nlink) {
678                 if (gfs2_consist_inode(ip))
679                         gfs2_dinode_print(&ip->i_di);
680                 return -EIO;
681         }
682
683         error = gfs2_meta_inode_buffer(ip, &dibh);
684         if (error)
685                 return error;
686
687         ip->i_di.di_nlink = nlink;
688         ip->i_di.di_ctime = get_seconds();
689
690         gfs2_trans_add_bh(ip->i_gl, dibh, 1);
691         gfs2_dinode_out(&ip->i_di, dibh->b_data);
692         brelse(dibh);
693
694         return 0;
695 }
696
697 struct inode *gfs2_lookup_simple(struct inode *dip, const char *name)
698 {
699         struct qstr qstr;
700         gfs2_str2qstr(&qstr, name);
701         return gfs2_lookupi(dip, &qstr, 1, NULL);
702 }
703
704
705 /**
706  * gfs2_lookupi - Look up a filename in a directory and return its inode
707  * @d_gh: An initialized holder for the directory glock
708  * @name: The name of the inode to look for
709  * @is_root: If 1, ignore the caller's permissions
710  * @i_gh: An uninitialized holder for the new inode glock
711  *
712  * There will always be a vnode (Linux VFS inode) for the d_gh inode unless
713  * @is_root is true.
714  *
715  * Returns: errno
716  */
717
718 struct inode *gfs2_lookupi(struct inode *dir, struct qstr *name, int is_root,
719                            struct nameidata *nd)
720                  
721 {
722         struct super_block *sb = dir->i_sb;
723         struct gfs2_inode *ipp;
724         struct gfs2_inode *dip = dir->u.generic_ip;
725         struct gfs2_sbd *sdp = dip->i_sbd;
726         struct gfs2_holder d_gh;
727         struct gfs2_inum inum;
728         unsigned int type;
729         struct gfs2_glock *gl;
730         int error = 0;
731         struct inode *inode = NULL;
732
733         if (!name->len || name->len > GFS2_FNAMESIZE)
734                 return ERR_PTR(-ENAMETOOLONG);
735
736         if ((name->len == 1 && memcmp(name->name, ".", 1) == 0) ||
737             (name->len == 2 && memcmp(name->name, "..", 2) == 0 &&
738              dir == sb->s_root->d_inode)) {
739                 gfs2_inode_hold(dip);
740                 ipp = dip;
741                 goto done;
742         }
743
744         error = gfs2_glock_nq_init(dip->i_gl, LM_ST_SHARED, 0, &d_gh);
745         if (error)
746                 return ERR_PTR(error);
747
748         if (!is_root) {
749                 error = gfs2_repermission(dip->i_vnode, MAY_EXEC, NULL);
750                 if (error)
751                         goto out;
752         }
753
754         error = gfs2_dir_search(dir, name, &inum, &type);
755         if (error)
756                 goto out;
757
758         error = gfs2_glock_get(sdp, inum.no_addr, &gfs2_inode_glops,
759                                CREATE, &gl);
760         if (error)
761                 goto out;
762
763         error = gfs2_inode_get(gl, &inum, CREATE, &ipp);
764         if (!error)
765                 gfs2_inode_min_init(ipp, type);
766
767         gfs2_glock_put(gl);
768
769 out:
770         gfs2_glock_dq_uninit(&d_gh);
771 done:
772         if (error == -ENOENT)
773                 return NULL;
774         if (error == 0) {
775                 inode = gfs2_ip2v(ipp);
776                 gfs2_inode_put(ipp);
777                 if (!inode)
778                         return ERR_PTR(-ENOMEM);
779                 return inode;
780         }
781         return ERR_PTR(error);
782 }
783
784 static int pick_formal_ino_1(struct gfs2_sbd *sdp, uint64_t *formal_ino)
785 {
786         struct gfs2_inode *ip = sdp->sd_ir_inode->u.generic_ip;
787         struct buffer_head *bh;
788         struct gfs2_inum_range ir;
789         int error;
790
791         error = gfs2_trans_begin(sdp, RES_DINODE, 0);
792         if (error)
793                 return error;
794         mutex_lock(&sdp->sd_inum_mutex);
795
796         error = gfs2_meta_inode_buffer(ip, &bh);
797         if (error) {
798                 mutex_unlock(&sdp->sd_inum_mutex);
799                 gfs2_trans_end(sdp);
800                 return error;
801         }
802
803         gfs2_inum_range_in(&ir, bh->b_data + sizeof(struct gfs2_dinode));
804
805         if (ir.ir_length) {
806                 *formal_ino = ir.ir_start++;
807                 ir.ir_length--;
808                 gfs2_trans_add_bh(ip->i_gl, bh, 1);
809                 gfs2_inum_range_out(&ir,
810                                     bh->b_data + sizeof(struct gfs2_dinode));
811                 brelse(bh);
812                 mutex_unlock(&sdp->sd_inum_mutex);
813                 gfs2_trans_end(sdp);
814                 return 0;
815         }
816
817         brelse(bh);
818
819         mutex_unlock(&sdp->sd_inum_mutex);
820         gfs2_trans_end(sdp);
821
822         return 1;
823 }
824
825 static int pick_formal_ino_2(struct gfs2_sbd *sdp, uint64_t *formal_ino)
826 {
827         struct gfs2_inode *ip = sdp->sd_ir_inode->u.generic_ip;
828         struct gfs2_inode *m_ip = sdp->sd_inum_inode->u.generic_ip;
829         struct gfs2_holder gh;
830         struct buffer_head *bh;
831         struct gfs2_inum_range ir;
832         int error;
833
834         error = gfs2_glock_nq_init(m_ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
835         if (error)
836                 return error;
837
838         error = gfs2_trans_begin(sdp, 2 * RES_DINODE, 0);
839         if (error)
840                 goto out;
841         mutex_lock(&sdp->sd_inum_mutex);
842
843         error = gfs2_meta_inode_buffer(ip, &bh);
844         if (error)
845                 goto out_end_trans;
846         
847         gfs2_inum_range_in(&ir, bh->b_data + sizeof(struct gfs2_dinode));
848
849         if (!ir.ir_length) {
850                 struct buffer_head *m_bh;
851                 uint64_t x, y;
852
853                 error = gfs2_meta_inode_buffer(m_ip, &m_bh);
854                 if (error)
855                         goto out_brelse;
856
857                 x = *(uint64_t *)(m_bh->b_data + sizeof(struct gfs2_dinode));
858                 x = y = be64_to_cpu(x);
859                 ir.ir_start = x;
860                 ir.ir_length = GFS2_INUM_QUANTUM;
861                 x += GFS2_INUM_QUANTUM;
862                 if (x < y)
863                         gfs2_consist_inode(m_ip);
864                 x = cpu_to_be64(x);
865                 gfs2_trans_add_bh(m_ip->i_gl, m_bh, 1);
866                 *(uint64_t *)(m_bh->b_data + sizeof(struct gfs2_dinode)) = x;
867
868                 brelse(m_bh);
869         }
870
871         *formal_ino = ir.ir_start++;
872         ir.ir_length--;
873
874         gfs2_trans_add_bh(ip->i_gl, bh, 1);
875         gfs2_inum_range_out(&ir, bh->b_data + sizeof(struct gfs2_dinode));
876
877  out_brelse:
878         brelse(bh);
879
880  out_end_trans:
881         mutex_unlock(&sdp->sd_inum_mutex);
882         gfs2_trans_end(sdp);
883
884  out:
885         gfs2_glock_dq_uninit(&gh);
886
887         return error;
888 }
889
890 static int pick_formal_ino(struct gfs2_sbd *sdp, uint64_t *inum)
891 {
892         int error;
893
894         error = pick_formal_ino_1(sdp, inum);
895         if (error <= 0)
896                 return error;
897
898         error = pick_formal_ino_2(sdp, inum);
899
900         return error;
901 }
902
903 /**
904  * create_ok - OK to create a new on-disk inode here?
905  * @dip:  Directory in which dinode is to be created
906  * @name:  Name of new dinode
907  * @mode:
908  *
909  * Returns: errno
910  */
911
912 static int create_ok(struct gfs2_inode *dip, struct qstr *name,
913                      unsigned int mode)
914 {
915         int error;
916
917         error = gfs2_repermission(dip->i_vnode, MAY_WRITE | MAY_EXEC, NULL);
918         if (error)
919                 return error;
920
921         /*  Don't create entries in an unlinked directory  */
922         if (!dip->i_di.di_nlink)
923                 return -EPERM;
924
925         error = gfs2_dir_search(dip->i_vnode, name, NULL, NULL);
926         switch (error) {
927         case -ENOENT:
928                 error = 0;
929                 break;
930         case 0:
931                 return -EEXIST;
932         default:
933                 return error;
934         }
935
936         if (dip->i_di.di_entries == (uint32_t)-1)
937                 return -EFBIG;
938         if (S_ISDIR(mode) && dip->i_di.di_nlink == (uint32_t)-1)
939                 return -EMLINK;
940
941         return 0;
942 }
943
944 static void munge_mode_uid_gid(struct gfs2_inode *dip, unsigned int *mode,
945                                unsigned int *uid, unsigned int *gid)
946 {
947         if (dip->i_sbd->sd_args.ar_suiddir &&
948             (dip->i_di.di_mode & S_ISUID) &&
949             dip->i_di.di_uid) {
950                 if (S_ISDIR(*mode))
951                         *mode |= S_ISUID;
952                 else if (dip->i_di.di_uid != current->fsuid)
953                         *mode &= ~07111;
954                 *uid = dip->i_di.di_uid;
955         } else
956                 *uid = current->fsuid;
957
958         if (dip->i_di.di_mode & S_ISGID) {
959                 if (S_ISDIR(*mode))
960                         *mode |= S_ISGID;
961                 *gid = dip->i_di.di_gid;
962         } else
963                 *gid = current->fsgid;
964 }
965
966 static int alloc_dinode(struct gfs2_inode *dip, struct gfs2_unlinked *ul)
967 {
968         struct gfs2_sbd *sdp = dip->i_sbd;
969         int error;
970
971         gfs2_alloc_get(dip);
972
973         dip->i_alloc.al_requested = RES_DINODE;
974         error = gfs2_inplace_reserve(dip);
975         if (error)
976                 goto out;
977
978         error = gfs2_trans_begin(sdp, RES_RG_BIT + RES_UNLINKED +
979                                  RES_STATFS, 0);
980         if (error)
981                 goto out_ipreserv;
982
983         ul->ul_ut.ut_inum.no_addr = gfs2_alloc_di(dip);
984
985         ul->ul_ut.ut_flags = GFS2_UTF_UNINIT;
986         error = gfs2_unlinked_ondisk_add(sdp, ul);
987
988         gfs2_trans_end(sdp);
989
990  out_ipreserv:
991         gfs2_inplace_release(dip);
992
993  out:
994         gfs2_alloc_put(dip);
995
996         return error;
997 }
998
999 /**
1000  * init_dinode - Fill in a new dinode structure
1001  * @dip: the directory this inode is being created in
1002  * @gl: The glock covering the new inode
1003  * @inum: the inode number
1004  * @mode: the file permissions
1005  * @uid:
1006  * @gid:
1007  *
1008  */
1009
1010 static void init_dinode(struct gfs2_inode *dip, struct gfs2_glock *gl,
1011                         struct gfs2_inum *inum, unsigned int mode,
1012                         unsigned int uid, unsigned int gid)
1013 {
1014         struct gfs2_sbd *sdp = dip->i_sbd;
1015         struct gfs2_dinode *di;
1016         struct buffer_head *dibh;
1017
1018         dibh = gfs2_meta_new(gl, inum->no_addr);
1019         gfs2_trans_add_bh(gl, dibh, 1);
1020         gfs2_metatype_set(dibh, GFS2_METATYPE_DI, GFS2_FORMAT_DI);
1021         gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode));
1022         di = (struct gfs2_dinode *)dibh->b_data;
1023
1024         di->di_num.no_formal_ino = cpu_to_be64(inum->no_formal_ino);
1025         di->di_num.no_addr = cpu_to_be64(inum->no_addr);
1026         di->di_mode = cpu_to_be32(mode);
1027         di->di_uid = cpu_to_be32(uid);
1028         di->di_gid = cpu_to_be32(gid);
1029         di->di_nlink = cpu_to_be32(0);
1030         di->di_size = cpu_to_be64(0);
1031         di->di_blocks = cpu_to_be64(1);
1032         di->di_atime = di->di_mtime = di->di_ctime = cpu_to_be64(get_seconds());
1033         di->di_major = di->di_minor = cpu_to_be32(0);
1034         di->di_goal_meta = di->di_goal_data = cpu_to_be64(inum->no_addr);
1035         di->__pad[0] = di->__pad[1] = 0;
1036         di->di_flags = cpu_to_be32(0);
1037
1038         if (S_ISREG(mode)) {
1039                 if ((dip->i_di.di_flags & GFS2_DIF_INHERIT_JDATA) ||
1040                     gfs2_tune_get(sdp, gt_new_files_jdata))
1041                         di->di_flags |= cpu_to_be32(GFS2_DIF_JDATA);
1042                 if ((dip->i_di.di_flags & GFS2_DIF_INHERIT_DIRECTIO) ||
1043                     gfs2_tune_get(sdp, gt_new_files_directio))
1044                         di->di_flags |= cpu_to_be32(GFS2_DIF_DIRECTIO);
1045         } else if (S_ISDIR(mode)) {
1046                 di->di_flags |= cpu_to_be32(dip->i_di.di_flags &
1047                                             GFS2_DIF_INHERIT_DIRECTIO);
1048                 di->di_flags |= cpu_to_be32(dip->i_di.di_flags &
1049                                             GFS2_DIF_INHERIT_JDATA);
1050         }
1051
1052         di->__pad1 = 0;
1053         di->di_height = cpu_to_be32(0);
1054         di->__pad2 = 0;
1055         di->__pad3 = 0;
1056         di->di_depth = cpu_to_be16(0);
1057         di->di_entries = cpu_to_be32(0);
1058         memset(&di->__pad4, 0, sizeof(di->__pad4));
1059         di->di_eattr = cpu_to_be64(0);
1060         memset(&di->di_reserved, 0, sizeof(di->di_reserved));
1061
1062         brelse(dibh);
1063 }
1064
1065 static int make_dinode(struct gfs2_inode *dip, struct gfs2_glock *gl,
1066                        unsigned int mode, struct gfs2_unlinked *ul)
1067 {
1068         struct gfs2_sbd *sdp = dip->i_sbd;
1069         unsigned int uid, gid;
1070         int error;
1071
1072         munge_mode_uid_gid(dip, &mode, &uid, &gid);
1073
1074         gfs2_alloc_get(dip);
1075
1076         error = gfs2_quota_lock(dip, uid, gid);
1077         if (error)
1078                 goto out;
1079
1080         error = gfs2_quota_check(dip, uid, gid);
1081         if (error)
1082                 goto out_quota;
1083
1084         error = gfs2_trans_begin(sdp, RES_DINODE + RES_UNLINKED +
1085                                  RES_QUOTA, 0);
1086         if (error)
1087                 goto out_quota;
1088
1089         ul->ul_ut.ut_flags = 0;
1090         error = gfs2_unlinked_ondisk_munge(sdp, ul);
1091
1092         init_dinode(dip, gl, &ul->ul_ut.ut_inum,
1093                      mode, uid, gid);
1094
1095         gfs2_quota_change(dip, +1, uid, gid);
1096
1097         gfs2_trans_end(sdp);
1098
1099  out_quota:
1100         gfs2_quota_unlock(dip);
1101
1102  out:
1103         gfs2_alloc_put(dip);
1104
1105         return error;
1106 }
1107
1108 static int link_dinode(struct gfs2_inode *dip, struct qstr *name,
1109                        struct gfs2_inode *ip, struct gfs2_unlinked *ul)
1110 {
1111         struct gfs2_sbd *sdp = dip->i_sbd;
1112         struct gfs2_alloc *al;
1113         int alloc_required;
1114         struct buffer_head *dibh;
1115         int error;
1116
1117         al = gfs2_alloc_get(dip);
1118
1119         error = gfs2_quota_lock(dip, NO_QUOTA_CHANGE, NO_QUOTA_CHANGE);
1120         if (error)
1121                 goto fail;
1122
1123         error = alloc_required = gfs2_diradd_alloc_required(dip->i_vnode, name);
1124         if (alloc_required < 0)
1125                 goto fail;
1126         if (alloc_required) {
1127                 error = gfs2_quota_check(dip, dip->i_di.di_uid,
1128                                          dip->i_di.di_gid);
1129                 if (error)
1130                         goto fail_quota_locks;
1131
1132                 al->al_requested = sdp->sd_max_dirres;
1133
1134                 error = gfs2_inplace_reserve(dip);
1135                 if (error)
1136                         goto fail_quota_locks;
1137
1138                 error = gfs2_trans_begin(sdp,
1139                                          sdp->sd_max_dirres +
1140                                          al->al_rgd->rd_ri.ri_length +
1141                                          2 * RES_DINODE + RES_UNLINKED +
1142                                          RES_STATFS + RES_QUOTA, 0);
1143                 if (error)
1144                         goto fail_ipreserv;
1145         } else {
1146                 error = gfs2_trans_begin(sdp,
1147                                          RES_LEAF +
1148                                          2 * RES_DINODE +
1149                                          RES_UNLINKED, 0);
1150                 if (error)
1151                         goto fail_quota_locks;
1152         }
1153
1154         error = gfs2_dir_add(dip->i_vnode, name, &ip->i_num, IF2DT(ip->i_di.di_mode));
1155         if (error)
1156                 goto fail_end_trans;
1157
1158         error = gfs2_meta_inode_buffer(ip, &dibh);
1159         if (error)
1160                 goto fail_end_trans;
1161         ip->i_di.di_nlink = 1;
1162         gfs2_trans_add_bh(ip->i_gl, dibh, 1);
1163         gfs2_dinode_out(&ip->i_di, dibh->b_data);
1164         brelse(dibh);
1165
1166         error = gfs2_unlinked_ondisk_rm(sdp, ul);
1167         if (error)
1168                 goto fail_end_trans;
1169
1170         return 0;
1171
1172  fail_end_trans:
1173         gfs2_trans_end(sdp);
1174
1175  fail_ipreserv:
1176         if (dip->i_alloc.al_rgd)
1177                 gfs2_inplace_release(dip);
1178
1179  fail_quota_locks:
1180         gfs2_quota_unlock(dip);
1181
1182  fail:
1183         gfs2_alloc_put(dip);
1184
1185         return error;
1186 }
1187
1188 /**
1189  * gfs2_createi - Create a new inode
1190  * @ghs: An array of two holders
1191  * @name: The name of the new file
1192  * @mode: the permissions on the new inode
1193  *
1194  * @ghs[0] is an initialized holder for the directory
1195  * @ghs[1] is the holder for the inode lock
1196  *
1197  * If the return value is not NULL, the glocks on both the directory and the new
1198  * file are held.  A transaction has been started and an inplace reservation
1199  * is held, as well.
1200  *
1201  * Returns: An inode
1202  */
1203
1204 struct inode *gfs2_createi(struct gfs2_holder *ghs, struct qstr *name,
1205                            unsigned int mode)
1206 {
1207         struct inode *inode;
1208         struct gfs2_inode *dip = ghs->gh_gl->gl_object;
1209         struct gfs2_sbd *sdp = dip->i_sbd;
1210         struct gfs2_unlinked *ul;
1211         struct gfs2_inode *ip;
1212         int error;
1213
1214         if (!name->len || name->len > GFS2_FNAMESIZE)
1215                 return ERR_PTR(-ENAMETOOLONG);
1216
1217         error = gfs2_unlinked_get(sdp, &ul);
1218         if (error)
1219                 return ERR_PTR(error);
1220
1221         gfs2_holder_reinit(LM_ST_EXCLUSIVE, 0, ghs);
1222         error = gfs2_glock_nq(ghs);
1223         if (error)
1224                 goto fail;
1225
1226         error = create_ok(dip, name, mode);
1227         if (error)
1228                 goto fail_gunlock;
1229
1230         error = pick_formal_ino(sdp, &ul->ul_ut.ut_inum.no_formal_ino);
1231         if (error)
1232                 goto fail_gunlock;
1233
1234         error = alloc_dinode(dip, ul);
1235         if (error)
1236                 goto fail_gunlock;
1237
1238         if (ul->ul_ut.ut_inum.no_addr < dip->i_num.no_addr) {
1239                 gfs2_glock_dq(ghs);
1240
1241                 error = gfs2_glock_nq_num(sdp,
1242                                           ul->ul_ut.ut_inum.no_addr,
1243                                           &gfs2_inode_glops,
1244                                           LM_ST_EXCLUSIVE, GL_SKIP,
1245                                           ghs + 1);
1246                 if (error) {
1247                         gfs2_unlinked_put(sdp, ul);
1248                         return ERR_PTR(error);
1249                 }
1250
1251                 gfs2_holder_reinit(LM_ST_EXCLUSIVE, 0, ghs);
1252                 error = gfs2_glock_nq(ghs);
1253                 if (error) {
1254                         gfs2_glock_dq_uninit(ghs + 1);
1255                         gfs2_unlinked_put(sdp, ul);
1256                         return ERR_PTR(error);
1257                 }
1258
1259                 error = create_ok(dip, name, mode);
1260                 if (error)
1261                         goto fail_gunlock2;
1262         } else {
1263                 error = gfs2_glock_nq_num(sdp,
1264                                           ul->ul_ut.ut_inum.no_addr,
1265                                           &gfs2_inode_glops,
1266                                           LM_ST_EXCLUSIVE, GL_SKIP,
1267                                           ghs + 1);
1268                 if (error)
1269                         goto fail_gunlock;
1270         }
1271
1272         error = make_dinode(dip, ghs[1].gh_gl, mode, ul);
1273         if (error)
1274                 goto fail_gunlock2;
1275
1276         error = gfs2_inode_get(ghs[1].gh_gl, &ul->ul_ut.ut_inum, CREATE, &ip);
1277         if (error)
1278                 goto fail_gunlock2;
1279
1280         error = gfs2_inode_refresh(ip);
1281         if (error)
1282                 goto fail_iput;
1283
1284         error = gfs2_acl_create(dip, ip);
1285         if (error)
1286                 goto fail_iput;
1287
1288         error = link_dinode(dip, name, ip, ul);
1289         if (error)
1290                 goto fail_iput;
1291
1292         gfs2_unlinked_put(sdp, ul);
1293
1294         inode = gfs2_ip2v(ip);
1295         gfs2_inode_put(ip);
1296         if (!inode)
1297                 return ERR_PTR(-ENOMEM);
1298         return inode;
1299
1300  fail_iput:
1301         gfs2_inode_put(ip);
1302
1303  fail_gunlock2:
1304         gfs2_glock_dq_uninit(ghs + 1);
1305
1306  fail_gunlock:
1307         gfs2_glock_dq(ghs);
1308
1309  fail:
1310         gfs2_unlinked_put(sdp, ul);
1311
1312         return ERR_PTR(error);
1313 }
1314
1315 /**
1316  * gfs2_unlinki - Unlink a file
1317  * @dip: The inode of the directory
1318  * @name: The name of the file to be unlinked
1319  * @ip: The inode of the file to be removed
1320  *
1321  * Assumes Glocks on both dip and ip are held.
1322  *
1323  * Returns: errno
1324  */
1325
1326 int gfs2_unlinki(struct gfs2_inode *dip, struct qstr *name,
1327                  struct gfs2_inode *ip, struct gfs2_unlinked *ul)
1328 {
1329         struct gfs2_sbd *sdp = dip->i_sbd;
1330         int error;
1331
1332         error = gfs2_dir_del(dip, name);
1333         if (error)
1334                 return error;
1335
1336         error = gfs2_change_nlink(ip, -1);
1337         if (error)
1338                 return error;
1339
1340         /* If this inode is being unlinked from the directory structure,
1341            we need to mark that in the log so that it isn't lost during
1342            a crash. */
1343
1344         if (!ip->i_di.di_nlink) {
1345                 ul->ul_ut.ut_inum = ip->i_num;
1346                 error = gfs2_unlinked_ondisk_add(sdp, ul);
1347                 if (!error)
1348                         set_bit(GLF_STICKY, &ip->i_gl->gl_flags);
1349         }
1350
1351         return error;
1352 }
1353
1354 /**
1355  * gfs2_rmdiri - Remove a directory
1356  * @dip: The parent directory of the directory to be removed
1357  * @name: The name of the directory to be removed
1358  * @ip: The GFS2 inode of the directory to be removed
1359  *
1360  * Assumes Glocks on dip and ip are held
1361  *
1362  * Returns: errno
1363  */
1364
1365 int gfs2_rmdiri(struct gfs2_inode *dip, struct qstr *name,
1366                 struct gfs2_inode *ip, struct gfs2_unlinked *ul)
1367 {
1368         struct gfs2_sbd *sdp = dip->i_sbd;
1369         struct qstr dotname;
1370         int error;
1371
1372         if (ip->i_di.di_entries != 2) {
1373                 if (gfs2_consist_inode(ip))
1374                         gfs2_dinode_print(&ip->i_di);
1375                 return -EIO;
1376         }
1377
1378         error = gfs2_dir_del(dip, name);
1379         if (error)
1380                 return error;
1381
1382         error = gfs2_change_nlink(dip, -1);
1383         if (error)
1384                 return error;
1385
1386         gfs2_str2qstr(&dotname, ".");
1387         error = gfs2_dir_del(ip, &dotname);
1388         if (error)
1389                 return error;
1390
1391         dotname.len = 2;
1392         dotname.name = "..";
1393         dotname.hash = gfs2_disk_hash(dotname.name, dotname.len);
1394         error = gfs2_dir_del(ip, &dotname);
1395         if (error)
1396                 return error;
1397
1398         error = gfs2_change_nlink(ip, -2);
1399         if (error)
1400                 return error;
1401
1402         /* This inode is being unlinked from the directory structure and
1403            we need to mark that in the log so that it isn't lost during
1404            a crash. */
1405
1406         ul->ul_ut.ut_inum = ip->i_num;
1407         error = gfs2_unlinked_ondisk_add(sdp, ul);
1408         if (!error)
1409                 set_bit(GLF_STICKY, &ip->i_gl->gl_flags);
1410
1411         return error;
1412 }
1413
1414 /*
1415  * gfs2_unlink_ok - check to see that a inode is still in a directory
1416  * @dip: the directory
1417  * @name: the name of the file
1418  * @ip: the inode
1419  *
1420  * Assumes that the lock on (at least) @dip is held.
1421  *
1422  * Returns: 0 if the parent/child relationship is correct, errno if it isn't
1423  */
1424
1425 int gfs2_unlink_ok(struct gfs2_inode *dip, struct qstr *name,
1426                    struct gfs2_inode *ip)
1427 {
1428         struct gfs2_inum inum;
1429         unsigned int type;
1430         int error;
1431
1432         if (IS_IMMUTABLE(ip->i_vnode) || IS_APPEND(ip->i_vnode))
1433                 return -EPERM;
1434
1435         if ((dip->i_di.di_mode & S_ISVTX) &&
1436             dip->i_di.di_uid != current->fsuid &&
1437             ip->i_di.di_uid != current->fsuid &&
1438             !capable(CAP_FOWNER))
1439                 return -EPERM;
1440
1441         if (IS_APPEND(dip->i_vnode))
1442                 return -EPERM;
1443
1444         error = gfs2_repermission(dip->i_vnode, MAY_WRITE | MAY_EXEC, NULL);
1445         if (error)
1446                 return error;
1447
1448         error = gfs2_dir_search(dip->i_vnode, name, &inum, &type);
1449         if (error)
1450                 return error;
1451
1452         if (!gfs2_inum_equal(&inum, &ip->i_num))
1453                 return -ENOENT;
1454
1455         if (IF2DT(ip->i_di.di_mode) != type) {
1456                 gfs2_consist_inode(dip);
1457                 return -EIO;
1458         }
1459
1460         return 0;
1461 }
1462
1463 /*
1464  * gfs2_ok_to_move - check if it's ok to move a directory to another directory
1465  * @this: move this
1466  * @to: to here
1467  *
1468  * Follow @to back to the root and make sure we don't encounter @this
1469  * Assumes we already hold the rename lock.
1470  *
1471  * Returns: errno
1472  */
1473
1474 int gfs2_ok_to_move(struct gfs2_inode *this, struct gfs2_inode *to)
1475 {
1476         struct inode *dir = to->i_vnode;
1477         struct super_block *sb = dir->i_sb;
1478         struct inode *tmp;
1479         struct qstr dotdot;
1480         int error = 0;
1481
1482         gfs2_str2qstr(&dotdot, "..");
1483
1484         igrab(dir);
1485
1486         for (;;) {
1487                 if (dir == this->i_vnode) {
1488                         error = -EINVAL;
1489                         break;
1490                 }
1491                 if (dir == sb->s_root->d_inode) {
1492                         error = 0;
1493                         break;
1494                 }
1495
1496                 tmp = gfs2_lookupi(dir, &dotdot, 1, NULL);
1497                 if (IS_ERR(tmp)) {
1498                         error = PTR_ERR(tmp);
1499                         break;
1500                 }
1501
1502                 iput(dir);
1503                 dir = tmp;
1504         }
1505
1506         iput(dir);
1507
1508         return error;
1509 }
1510
1511 /**
1512  * gfs2_readlinki - return the contents of a symlink
1513  * @ip: the symlink's inode
1514  * @buf: a pointer to the buffer to be filled
1515  * @len: a pointer to the length of @buf
1516  *
1517  * If @buf is too small, a piece of memory is kmalloc()ed and needs
1518  * to be freed by the caller.
1519  *
1520  * Returns: errno
1521  */
1522
1523 int gfs2_readlinki(struct gfs2_inode *ip, char **buf, unsigned int *len)
1524 {
1525         struct gfs2_holder i_gh;
1526         struct buffer_head *dibh;
1527         unsigned int x;
1528         int error;
1529
1530         gfs2_holder_init(ip->i_gl, LM_ST_SHARED, GL_ATIME, &i_gh);
1531         error = gfs2_glock_nq_atime(&i_gh);
1532         if (error) {
1533                 gfs2_holder_uninit(&i_gh);
1534                 return error;
1535         }
1536
1537         if (!ip->i_di.di_size) {
1538                 gfs2_consist_inode(ip);
1539                 error = -EIO;
1540                 goto out;
1541         }
1542
1543         error = gfs2_meta_inode_buffer(ip, &dibh);
1544         if (error)
1545                 goto out;
1546
1547         x = ip->i_di.di_size + 1;
1548         if (x > *len) {
1549                 *buf = kmalloc(x, GFP_KERNEL);
1550                 if (!*buf) {
1551                         error = -ENOMEM;
1552                         goto out_brelse;
1553                 }
1554         }
1555
1556         memcpy(*buf, dibh->b_data + sizeof(struct gfs2_dinode), x);
1557         *len = x;
1558
1559  out_brelse:
1560         brelse(dibh);
1561
1562  out:
1563         gfs2_glock_dq_uninit(&i_gh);
1564
1565         return error;
1566 }
1567
1568 /**
1569  * gfs2_glock_nq_atime - Acquire a hold on an inode's glock, and
1570  *       conditionally update the inode's atime
1571  * @gh: the holder to acquire
1572  *
1573  * Tests atime (access time) for gfs2_read, gfs2_readdir and gfs2_mmap
1574  * Update if the difference between the current time and the inode's current
1575  * atime is greater than an interval specified at mount.
1576  *
1577  * Returns: errno
1578  */
1579
1580 int gfs2_glock_nq_atime(struct gfs2_holder *gh)
1581 {
1582         struct gfs2_glock *gl = gh->gh_gl;
1583         struct gfs2_sbd *sdp = gl->gl_sbd;
1584         struct gfs2_inode *ip = gl->gl_object;
1585         int64_t curtime, quantum = gfs2_tune_get(sdp, gt_atime_quantum);
1586         unsigned int state;
1587         int flags;
1588         int error;
1589
1590         if (gfs2_assert_warn(sdp, gh->gh_flags & GL_ATIME) ||
1591             gfs2_assert_warn(sdp, !(gh->gh_flags & GL_ASYNC)) ||
1592             gfs2_assert_warn(sdp, gl->gl_ops == &gfs2_inode_glops))
1593                 return -EINVAL;
1594
1595         state = gh->gh_state;
1596         flags = gh->gh_flags;
1597
1598         error = gfs2_glock_nq(gh);
1599         if (error)
1600                 return error;
1601
1602         if (test_bit(SDF_NOATIME, &sdp->sd_flags) ||
1603             (sdp->sd_vfs->s_flags & MS_RDONLY))
1604                 return 0;
1605
1606         curtime = get_seconds();
1607         if (curtime - ip->i_di.di_atime >= quantum) {
1608                 gfs2_glock_dq(gh);
1609                 gfs2_holder_reinit(LM_ST_EXCLUSIVE,
1610                                   gh->gh_flags & ~LM_FLAG_ANY,
1611                                   gh);
1612                 error = gfs2_glock_nq(gh);
1613                 if (error)
1614                         return error;
1615
1616                 /* Verify that atime hasn't been updated while we were
1617                    trying to get exclusive lock. */
1618
1619                 curtime = get_seconds();
1620                 if (curtime - ip->i_di.di_atime >= quantum) {
1621                         struct buffer_head *dibh;
1622
1623                         error = gfs2_trans_begin(sdp, RES_DINODE, 0);
1624                         if (error == -EROFS)
1625                                 return 0;
1626                         if (error)
1627                                 goto fail;
1628
1629                         error = gfs2_meta_inode_buffer(ip, &dibh);
1630                         if (error)
1631                                 goto fail_end_trans;
1632
1633                         ip->i_di.di_atime = curtime;
1634
1635                         gfs2_trans_add_bh(ip->i_gl, dibh, 1);
1636                         gfs2_dinode_out(&ip->i_di, dibh->b_data);
1637                         brelse(dibh);
1638
1639                         gfs2_trans_end(sdp);
1640                 }
1641
1642                 /* If someone else has asked for the glock,
1643                    unlock and let them have it. Then reacquire
1644                    in the original state. */
1645                 if (gfs2_glock_is_blocking(gl)) {
1646                         gfs2_glock_dq(gh);
1647                         gfs2_holder_reinit(state, flags, gh);
1648                         return gfs2_glock_nq(gh);
1649                 }
1650         }
1651
1652         return 0;
1653
1654  fail_end_trans:
1655         gfs2_trans_end(sdp);
1656
1657  fail:
1658         gfs2_glock_dq(gh);
1659
1660         return error;
1661 }
1662
1663 /**
1664  * glock_compare_atime - Compare two struct gfs2_glock structures for sort
1665  * @arg_a: the first structure
1666  * @arg_b: the second structure
1667  *
1668  * Returns: 1 if A > B
1669  *         -1 if A < B
1670  *          0 if A = B
1671  */
1672
1673 static int glock_compare_atime(const void *arg_a, const void *arg_b)
1674 {
1675         struct gfs2_holder *gh_a = *(struct gfs2_holder **)arg_a;
1676         struct gfs2_holder *gh_b = *(struct gfs2_holder **)arg_b;
1677         struct lm_lockname *a = &gh_a->gh_gl->gl_name;
1678         struct lm_lockname *b = &gh_b->gh_gl->gl_name;
1679         int ret = 0;
1680
1681         if (a->ln_number > b->ln_number)
1682                 ret = 1;
1683         else if (a->ln_number < b->ln_number)
1684                 ret = -1;
1685         else {
1686                 if (gh_a->gh_state == LM_ST_SHARED &&
1687                     gh_b->gh_state == LM_ST_EXCLUSIVE)
1688                         ret = 1;
1689                 else if (gh_a->gh_state == LM_ST_SHARED &&
1690                          (gh_b->gh_flags & GL_ATIME))
1691                         ret = 1;
1692         }
1693
1694         return ret;
1695 }
1696
1697 /**
1698  * gfs2_glock_nq_m_atime - acquire multiple glocks where one may need an
1699  *      atime update
1700  * @num_gh: the number of structures
1701  * @ghs: an array of struct gfs2_holder structures
1702  *
1703  * Returns: 0 on success (all glocks acquired),
1704  *          errno on failure (no glocks acquired)
1705  */
1706
1707 int gfs2_glock_nq_m_atime(unsigned int num_gh, struct gfs2_holder *ghs)
1708 {
1709         struct gfs2_holder **p;
1710         unsigned int x;
1711         int error = 0;
1712
1713         if (!num_gh)
1714                 return 0;
1715
1716         if (num_gh == 1) {
1717                 ghs->gh_flags &= ~(LM_FLAG_TRY | GL_ASYNC);
1718                 if (ghs->gh_flags & GL_ATIME)
1719                         error = gfs2_glock_nq_atime(ghs);
1720                 else
1721                         error = gfs2_glock_nq(ghs);
1722                 return error;
1723         }
1724
1725         p = kcalloc(num_gh, sizeof(struct gfs2_holder *), GFP_KERNEL);
1726         if (!p)
1727                 return -ENOMEM;
1728
1729         for (x = 0; x < num_gh; x++)
1730                 p[x] = &ghs[x];
1731
1732         sort(p, num_gh, sizeof(struct gfs2_holder *), glock_compare_atime,NULL);
1733
1734         for (x = 0; x < num_gh; x++) {
1735                 p[x]->gh_flags &= ~(LM_FLAG_TRY | GL_ASYNC);
1736
1737                 if (p[x]->gh_flags & GL_ATIME)
1738                         error = gfs2_glock_nq_atime(p[x]);
1739                 else
1740                         error = gfs2_glock_nq(p[x]);
1741
1742                 if (error) {
1743                         while (x--)
1744                                 gfs2_glock_dq(p[x]);
1745                         break;
1746                 }
1747         }
1748
1749         kfree(p);
1750
1751         return error;
1752 }
1753
1754 /**
1755  * gfs2_try_toss_vnode - See if we can toss a vnode from memory
1756  * @ip: the inode
1757  *
1758  * Returns:  1 if the vnode was tossed
1759  */
1760
1761 void gfs2_try_toss_vnode(struct gfs2_inode *ip)
1762 {
1763         struct inode *inode;
1764
1765         inode = gfs2_ip2v_lookup(ip);
1766         if (!inode)
1767                 return;
1768
1769         d_prune_aliases(inode);
1770
1771         if (S_ISDIR(ip->i_di.di_mode)) {
1772                 struct list_head *head = &inode->i_dentry;
1773                 struct dentry *d = NULL;
1774
1775                 spin_lock(&dcache_lock);
1776                 if (list_empty(head))
1777                         spin_unlock(&dcache_lock);
1778                 else {
1779                         d = list_entry(head->next, struct dentry, d_alias);
1780                         dget_locked(d);
1781                         spin_unlock(&dcache_lock);
1782
1783                         if (have_submounts(d))
1784                                 dput(d);
1785                         else {
1786                                 shrink_dcache_parent(d);
1787                                 dput(d);
1788                                 d_prune_aliases(inode);
1789                         }
1790                 }
1791         }
1792
1793         inode->i_nlink = 0;
1794         iput(inode);
1795 }
1796
1797
1798 static int
1799 __gfs2_setattr_simple(struct gfs2_inode *ip, struct iattr *attr)
1800 {
1801         struct buffer_head *dibh;
1802         int error;
1803
1804         error = gfs2_meta_inode_buffer(ip, &dibh);
1805         if (!error) {
1806                 error = inode_setattr(ip->i_vnode, attr);
1807                 gfs2_assert_warn(ip->i_sbd, !error);
1808                 gfs2_inode_attr_out(ip);
1809
1810                 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
1811                 gfs2_dinode_out(&ip->i_di, dibh->b_data);
1812                 brelse(dibh);
1813         }
1814         return error;
1815 }
1816
1817 /**
1818  * gfs2_setattr_simple -
1819  * @ip:
1820  * @attr:
1821  *
1822  * Called with a reference on the vnode.
1823  *
1824  * Returns: errno
1825  */
1826
1827 int gfs2_setattr_simple(struct gfs2_inode *ip, struct iattr *attr)
1828 {
1829         int error;
1830
1831         if (current->journal_info)
1832                 return __gfs2_setattr_simple(ip, attr);
1833
1834         error = gfs2_trans_begin(ip->i_sbd, RES_DINODE, 0);
1835         if (error)
1836                 return error;
1837
1838         error = __gfs2_setattr_simple(ip, attr);
1839
1840         gfs2_trans_end(ip->i_sbd);
1841
1842         return error;
1843 }
1844
1845 int gfs2_repermission(struct inode *inode, int mask, struct nameidata *nd)
1846 {
1847         return permission(inode, mask, nd);
1848 }
1849