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