3ff32fa793dae4900415094fa616c8a8250c58ca
[linux-2.6.git] / fs / gfs2 / inode.c
1 /*
2  * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
3  * Copyright (C) 2004-2008 Red Hat, Inc.  All rights reserved.
4  *
5  * This copyrighted material is made available to anyone wishing to use,
6  * modify, copy, or redistribute it subject to the terms and conditions
7  * of the GNU General Public License version 2.
8  */
9
10 #include <linux/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 <linux/security.h>
20 #include <linux/time.h>
21
22 #include "gfs2.h"
23 #include "incore.h"
24 #include "acl.h"
25 #include "bmap.h"
26 #include "dir.h"
27 #include "xattr.h"
28 #include "glock.h"
29 #include "glops.h"
30 #include "inode.h"
31 #include "log.h"
32 #include "meta_io.h"
33 #include "quota.h"
34 #include "rgrp.h"
35 #include "trans.h"
36 #include "util.h"
37
38 struct gfs2_inum_range_host {
39         u64 ir_start;
40         u64 ir_length;
41 };
42
43 static int iget_test(struct inode *inode, void *opaque)
44 {
45         struct gfs2_inode *ip = GFS2_I(inode);
46         u64 *no_addr = opaque;
47
48         if (ip->i_no_addr == *no_addr && test_bit(GIF_USER, &ip->i_flags))
49                 return 1;
50
51         return 0;
52 }
53
54 static int iget_set(struct inode *inode, void *opaque)
55 {
56         struct gfs2_inode *ip = GFS2_I(inode);
57         u64 *no_addr = opaque;
58
59         inode->i_ino = (unsigned long)*no_addr;
60         ip->i_no_addr = *no_addr;
61         set_bit(GIF_USER, &ip->i_flags);
62         return 0;
63 }
64
65 struct inode *gfs2_ilookup(struct super_block *sb, u64 no_addr)
66 {
67         unsigned long hash = (unsigned long)no_addr;
68         return ilookup5(sb, hash, iget_test, &no_addr);
69 }
70
71 static struct inode *gfs2_iget(struct super_block *sb, u64 no_addr)
72 {
73         unsigned long hash = (unsigned long)no_addr;
74         return iget5_locked(sb, hash, iget_test, iget_set, &no_addr);
75 }
76
77 struct gfs2_skip_data {
78         u64     no_addr;
79         int     skipped;
80 };
81
82 static int iget_skip_test(struct inode *inode, void *opaque)
83 {
84         struct gfs2_inode *ip = GFS2_I(inode);
85         struct gfs2_skip_data *data = opaque;
86
87         if (ip->i_no_addr == data->no_addr && test_bit(GIF_USER, &ip->i_flags)){
88                 if (inode->i_state & (I_FREEING|I_CLEAR|I_WILL_FREE)){
89                         data->skipped = 1;
90                         return 0;
91                 }
92                 return 1;
93         }
94         return 0;
95 }
96
97 static int iget_skip_set(struct inode *inode, void *opaque)
98 {
99         struct gfs2_inode *ip = GFS2_I(inode);
100         struct gfs2_skip_data *data = opaque;
101
102         if (data->skipped)
103                 return 1;
104         inode->i_ino = (unsigned long)(data->no_addr);
105         ip->i_no_addr = data->no_addr;
106         set_bit(GIF_USER, &ip->i_flags);
107         return 0;
108 }
109
110 static struct inode *gfs2_iget_skip(struct super_block *sb,
111                                     u64 no_addr)
112 {
113         struct gfs2_skip_data data;
114         unsigned long hash = (unsigned long)no_addr;
115
116         data.no_addr = no_addr;
117         data.skipped = 0;
118         return iget5_locked(sb, hash, iget_skip_test, iget_skip_set, &data);
119 }
120
121 /**
122  * GFS2 lookup code fills in vfs inode contents based on info obtained
123  * from directory entry inside gfs2_inode_lookup(). This has caused issues
124  * with NFS code path since its get_dentry routine doesn't have the relevant
125  * directory entry when gfs2_inode_lookup() is invoked. Part of the code
126  * segment inside gfs2_inode_lookup code needs to get moved around.
127  *
128  * Clean up I_LOCK and I_NEW as well.
129  **/
130
131 void gfs2_set_iop(struct inode *inode)
132 {
133         struct gfs2_sbd *sdp = GFS2_SB(inode);
134         umode_t mode = inode->i_mode;
135
136         if (S_ISREG(mode)) {
137                 inode->i_op = &gfs2_file_iops;
138                 if (gfs2_localflocks(sdp))
139                         inode->i_fop = &gfs2_file_fops_nolock;
140                 else
141                         inode->i_fop = &gfs2_file_fops;
142         } else if (S_ISDIR(mode)) {
143                 inode->i_op = &gfs2_dir_iops;
144                 if (gfs2_localflocks(sdp))
145                         inode->i_fop = &gfs2_dir_fops_nolock;
146                 else
147                         inode->i_fop = &gfs2_dir_fops;
148         } else if (S_ISLNK(mode)) {
149                 inode->i_op = &gfs2_symlink_iops;
150         } else {
151                 inode->i_op = &gfs2_file_iops;
152                 init_special_inode(inode, inode->i_mode, inode->i_rdev);
153         }
154
155         unlock_new_inode(inode);
156 }
157
158 /**
159  * gfs2_inode_lookup - Lookup an inode
160  * @sb: The super block
161  * @no_addr: The inode number
162  * @type: The type of the inode
163  * @skip_freeing: set this not return an inode if it is currently being freed.
164  *
165  * Returns: A VFS inode, or an error
166  */
167
168 struct inode *gfs2_inode_lookup(struct super_block *sb,
169                                 unsigned int type,
170                                 u64 no_addr,
171                                 u64 no_formal_ino, int skip_freeing)
172 {
173         struct inode *inode;
174         struct gfs2_inode *ip;
175         struct gfs2_glock *io_gl;
176         int error;
177
178         if (skip_freeing)
179                 inode = gfs2_iget_skip(sb, no_addr);
180         else
181                 inode = gfs2_iget(sb, no_addr);
182         ip = GFS2_I(inode);
183
184         if (!inode)
185                 return ERR_PTR(-ENOBUFS);
186
187         if (inode->i_state & I_NEW) {
188                 struct gfs2_sbd *sdp = GFS2_SB(inode);
189                 ip->i_no_formal_ino = no_formal_ino;
190
191                 error = gfs2_glock_get(sdp, no_addr, &gfs2_inode_glops, CREATE, &ip->i_gl);
192                 if (unlikely(error))
193                         goto fail;
194                 ip->i_gl->gl_object = ip;
195
196                 error = gfs2_glock_get(sdp, no_addr, &gfs2_iopen_glops, CREATE, &io_gl);
197                 if (unlikely(error))
198                         goto fail_put;
199
200                 set_bit(GIF_INVALID, &ip->i_flags);
201                 error = gfs2_glock_nq_init(io_gl, LM_ST_SHARED, GL_EXACT, &ip->i_iopen_gh);
202                 if (unlikely(error))
203                         goto fail_iopen;
204                 ip->i_iopen_gh.gh_gl->gl_object = ip;
205
206                 gfs2_glock_put(io_gl);
207
208                 if ((type == DT_UNKNOWN) && (no_formal_ino == 0))
209                         goto gfs2_nfsbypass;
210
211                 inode->i_mode = DT2IF(type);
212
213                 /*
214                  * We must read the inode in order to work out its type in
215                  * this case. Note that this doesn't happen often as we normally
216                  * know the type beforehand. This code path only occurs during
217                  * unlinked inode recovery (where it is safe to do this glock,
218                  * which is not true in the general case).
219                  */
220                 if (type == DT_UNKNOWN) {
221                         struct gfs2_holder gh;
222                         error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
223                         if (unlikely(error))
224                                 goto fail_glock;
225                         /* Inode is now uptodate */
226                         gfs2_glock_dq_uninit(&gh);
227                 }
228
229                 gfs2_set_iop(inode);
230         }
231
232 gfs2_nfsbypass:
233         return inode;
234 fail_glock:
235         gfs2_glock_dq(&ip->i_iopen_gh);
236 fail_iopen:
237         gfs2_glock_put(io_gl);
238 fail_put:
239         ip->i_gl->gl_object = NULL;
240         gfs2_glock_put(ip->i_gl);
241 fail:
242         iget_failed(inode);
243         return ERR_PTR(error);
244 }
245
246 static int gfs2_dinode_in(struct gfs2_inode *ip, const void *buf)
247 {
248         const struct gfs2_dinode *str = buf;
249         struct timespec atime;
250         u16 height, depth;
251
252         if (unlikely(ip->i_no_addr != be64_to_cpu(str->di_num.no_addr)))
253                 goto corrupt;
254         ip->i_no_formal_ino = be64_to_cpu(str->di_num.no_formal_ino);
255         ip->i_inode.i_mode = be32_to_cpu(str->di_mode);
256         ip->i_inode.i_rdev = 0;
257         switch (ip->i_inode.i_mode & S_IFMT) {
258         case S_IFBLK:
259         case S_IFCHR:
260                 ip->i_inode.i_rdev = MKDEV(be32_to_cpu(str->di_major),
261                                            be32_to_cpu(str->di_minor));
262                 break;
263         };
264
265         ip->i_inode.i_uid = be32_to_cpu(str->di_uid);
266         ip->i_inode.i_gid = be32_to_cpu(str->di_gid);
267         /*
268          * We will need to review setting the nlink count here in the
269          * light of the forthcoming ro bind mount work. This is a reminder
270          * to do that.
271          */
272         ip->i_inode.i_nlink = be32_to_cpu(str->di_nlink);
273         ip->i_disksize = be64_to_cpu(str->di_size);
274         i_size_write(&ip->i_inode, ip->i_disksize);
275         gfs2_set_inode_blocks(&ip->i_inode, be64_to_cpu(str->di_blocks));
276         atime.tv_sec = be64_to_cpu(str->di_atime);
277         atime.tv_nsec = be32_to_cpu(str->di_atime_nsec);
278         if (timespec_compare(&ip->i_inode.i_atime, &atime) < 0)
279                 ip->i_inode.i_atime = atime;
280         ip->i_inode.i_mtime.tv_sec = be64_to_cpu(str->di_mtime);
281         ip->i_inode.i_mtime.tv_nsec = be32_to_cpu(str->di_mtime_nsec);
282         ip->i_inode.i_ctime.tv_sec = be64_to_cpu(str->di_ctime);
283         ip->i_inode.i_ctime.tv_nsec = be32_to_cpu(str->di_ctime_nsec);
284
285         ip->i_goal = be64_to_cpu(str->di_goal_meta);
286         ip->i_generation = be64_to_cpu(str->di_generation);
287
288         ip->i_diskflags = be32_to_cpu(str->di_flags);
289         gfs2_set_inode_flags(&ip->i_inode);
290         height = be16_to_cpu(str->di_height);
291         if (unlikely(height > GFS2_MAX_META_HEIGHT))
292                 goto corrupt;
293         ip->i_height = (u8)height;
294
295         depth = be16_to_cpu(str->di_depth);
296         if (unlikely(depth > GFS2_DIR_MAX_DEPTH))
297                 goto corrupt;
298         ip->i_depth = (u8)depth;
299         ip->i_entries = be32_to_cpu(str->di_entries);
300
301         ip->i_eattr = be64_to_cpu(str->di_eattr);
302         if (S_ISREG(ip->i_inode.i_mode))
303                 gfs2_set_aops(&ip->i_inode);
304
305         return 0;
306 corrupt:
307         if (gfs2_consist_inode(ip))
308                 gfs2_dinode_print(ip);
309         return -EIO;
310 }
311
312 /**
313  * gfs2_inode_refresh - Refresh the incore copy of the dinode
314  * @ip: The GFS2 inode
315  *
316  * Returns: errno
317  */
318
319 int gfs2_inode_refresh(struct gfs2_inode *ip)
320 {
321         struct buffer_head *dibh;
322         int error;
323
324         error = gfs2_meta_inode_buffer(ip, &dibh);
325         if (error)
326                 return error;
327
328         if (gfs2_metatype_check(GFS2_SB(&ip->i_inode), dibh, GFS2_METATYPE_DI)) {
329                 brelse(dibh);
330                 return -EIO;
331         }
332
333         error = gfs2_dinode_in(ip, dibh->b_data);
334         brelse(dibh);
335         clear_bit(GIF_INVALID, &ip->i_flags);
336
337         return error;
338 }
339
340 int gfs2_dinode_dealloc(struct gfs2_inode *ip)
341 {
342         struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
343         struct gfs2_alloc *al;
344         struct gfs2_rgrpd *rgd;
345         int error;
346
347         if (gfs2_get_inode_blocks(&ip->i_inode) != 1) {
348                 if (gfs2_consist_inode(ip))
349                         gfs2_dinode_print(ip);
350                 return -EIO;
351         }
352
353         al = gfs2_alloc_get(ip);
354         if (!al)
355                 return -ENOMEM;
356
357         error = gfs2_quota_hold(ip, NO_QUOTA_CHANGE, NO_QUOTA_CHANGE);
358         if (error)
359                 goto out;
360
361         error = gfs2_rindex_hold(sdp, &al->al_ri_gh);
362         if (error)
363                 goto out_qs;
364
365         rgd = gfs2_blk2rgrpd(sdp, ip->i_no_addr);
366         if (!rgd) {
367                 gfs2_consist_inode(ip);
368                 error = -EIO;
369                 goto out_rindex_relse;
370         }
371
372         error = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_EXCLUSIVE, 0,
373                                    &al->al_rgd_gh);
374         if (error)
375                 goto out_rindex_relse;
376
377         error = gfs2_trans_begin(sdp, RES_RG_BIT + RES_STATFS + RES_QUOTA, 1);
378         if (error)
379                 goto out_rg_gunlock;
380
381         set_bit(GLF_DIRTY, &ip->i_gl->gl_flags);
382         set_bit(GLF_LFLUSH, &ip->i_gl->gl_flags);
383
384         gfs2_free_di(rgd, ip);
385
386         gfs2_trans_end(sdp);
387
388 out_rg_gunlock:
389         gfs2_glock_dq_uninit(&al->al_rgd_gh);
390 out_rindex_relse:
391         gfs2_glock_dq_uninit(&al->al_ri_gh);
392 out_qs:
393         gfs2_quota_unhold(ip);
394 out:
395         gfs2_alloc_put(ip);
396         return error;
397 }
398
399 /**
400  * gfs2_change_nlink - Change nlink count on inode
401  * @ip: The GFS2 inode
402  * @diff: The change in the nlink count required
403  *
404  * Returns: errno
405  */
406 int gfs2_change_nlink(struct gfs2_inode *ip, int diff)
407 {
408         struct buffer_head *dibh;
409         u32 nlink;
410         int error;
411
412         BUG_ON(diff != 1 && diff != -1);
413         nlink = ip->i_inode.i_nlink + diff;
414
415         /* If we are reducing the nlink count, but the new value ends up being
416            bigger than the old one, we must have underflowed. */
417         if (diff < 0 && nlink > ip->i_inode.i_nlink) {
418                 if (gfs2_consist_inode(ip))
419                         gfs2_dinode_print(ip);
420                 return -EIO;
421         }
422
423         error = gfs2_meta_inode_buffer(ip, &dibh);
424         if (error)
425                 return error;
426
427         if (diff > 0)
428                 inc_nlink(&ip->i_inode);
429         else
430                 drop_nlink(&ip->i_inode);
431
432         ip->i_inode.i_ctime = CURRENT_TIME;
433
434         gfs2_trans_add_bh(ip->i_gl, dibh, 1);
435         gfs2_dinode_out(ip, dibh->b_data);
436         brelse(dibh);
437         mark_inode_dirty(&ip->i_inode);
438
439         if (ip->i_inode.i_nlink == 0)
440                 gfs2_unlink_di(&ip->i_inode); /* mark inode unlinked */
441
442         return error;
443 }
444
445 struct inode *gfs2_lookup_simple(struct inode *dip, const char *name)
446 {
447         struct qstr qstr;
448         struct inode *inode;
449         gfs2_str2qstr(&qstr, name);
450         inode = gfs2_lookupi(dip, &qstr, 1);
451         /* gfs2_lookupi has inconsistent callers: vfs
452          * related routines expect NULL for no entry found,
453          * gfs2_lookup_simple callers expect ENOENT
454          * and do not check for NULL.
455          */
456         if (inode == NULL)
457                 return ERR_PTR(-ENOENT);
458         else
459                 return inode;
460 }
461
462
463 /**
464  * gfs2_lookupi - Look up a filename in a directory and return its inode
465  * @d_gh: An initialized holder for the directory glock
466  * @name: The name of the inode to look for
467  * @is_root: If 1, ignore the caller's permissions
468  * @i_gh: An uninitialized holder for the new inode glock
469  *
470  * This can be called via the VFS filldir function when NFS is doing
471  * a readdirplus and the inode which its intending to stat isn't
472  * already in cache. In this case we must not take the directory glock
473  * again, since the readdir call will have already taken that lock.
474  *
475  * Returns: errno
476  */
477
478 struct inode *gfs2_lookupi(struct inode *dir, const struct qstr *name,
479                            int is_root)
480 {
481         struct super_block *sb = dir->i_sb;
482         struct gfs2_inode *dip = GFS2_I(dir);
483         struct gfs2_holder d_gh;
484         int error = 0;
485         struct inode *inode = NULL;
486         int unlock = 0;
487
488         if (!name->len || name->len > GFS2_FNAMESIZE)
489                 return ERR_PTR(-ENAMETOOLONG);
490
491         if ((name->len == 1 && memcmp(name->name, ".", 1) == 0) ||
492             (name->len == 2 && memcmp(name->name, "..", 2) == 0 &&
493              dir == sb->s_root->d_inode)) {
494                 igrab(dir);
495                 return dir;
496         }
497
498         if (gfs2_glock_is_locked_by_me(dip->i_gl) == NULL) {
499                 error = gfs2_glock_nq_init(dip->i_gl, LM_ST_SHARED, 0, &d_gh);
500                 if (error)
501                         return ERR_PTR(error);
502                 unlock = 1;
503         }
504
505         if (!is_root) {
506                 error = gfs2_permission(dir, MAY_EXEC);
507                 if (error)
508                         goto out;
509         }
510
511         inode = gfs2_dir_search(dir, name);
512         if (IS_ERR(inode))
513                 error = PTR_ERR(inode);
514 out:
515         if (unlock)
516                 gfs2_glock_dq_uninit(&d_gh);
517         if (error == -ENOENT)
518                 return NULL;
519         return inode ? inode : ERR_PTR(error);
520 }
521
522 /**
523  * create_ok - OK to create a new on-disk inode here?
524  * @dip:  Directory in which dinode is to be created
525  * @name:  Name of new dinode
526  * @mode:
527  *
528  * Returns: errno
529  */
530
531 static int create_ok(struct gfs2_inode *dip, const struct qstr *name,
532                      unsigned int mode)
533 {
534         int error;
535
536         error = gfs2_permission(&dip->i_inode, MAY_WRITE | MAY_EXEC);
537         if (error)
538                 return error;
539
540         /*  Don't create entries in an unlinked directory  */
541         if (!dip->i_inode.i_nlink)
542                 return -EPERM;
543
544         error = gfs2_dir_check(&dip->i_inode, name, NULL);
545         switch (error) {
546         case -ENOENT:
547                 error = 0;
548                 break;
549         case 0:
550                 return -EEXIST;
551         default:
552                 return error;
553         }
554
555         if (dip->i_entries == (u32)-1)
556                 return -EFBIG;
557         if (S_ISDIR(mode) && dip->i_inode.i_nlink == (u32)-1)
558                 return -EMLINK;
559
560         return 0;
561 }
562
563 static void munge_mode_uid_gid(struct gfs2_inode *dip, unsigned int *mode,
564                                unsigned int *uid, unsigned int *gid)
565 {
566         if (GFS2_SB(&dip->i_inode)->sd_args.ar_suiddir &&
567             (dip->i_inode.i_mode & S_ISUID) && dip->i_inode.i_uid) {
568                 if (S_ISDIR(*mode))
569                         *mode |= S_ISUID;
570                 else if (dip->i_inode.i_uid != current_fsuid())
571                         *mode &= ~07111;
572                 *uid = dip->i_inode.i_uid;
573         } else
574                 *uid = current_fsuid();
575
576         if (dip->i_inode.i_mode & S_ISGID) {
577                 if (S_ISDIR(*mode))
578                         *mode |= S_ISGID;
579                 *gid = dip->i_inode.i_gid;
580         } else
581                 *gid = current_fsgid();
582 }
583
584 static int alloc_dinode(struct gfs2_inode *dip, u64 *no_addr, u64 *generation)
585 {
586         struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
587         int error;
588
589         if (gfs2_alloc_get(dip) == NULL)
590                 return -ENOMEM;
591
592         dip->i_alloc->al_requested = RES_DINODE;
593         error = gfs2_inplace_reserve(dip);
594         if (error)
595                 goto out;
596
597         error = gfs2_trans_begin(sdp, RES_RG_BIT + RES_STATFS, 0);
598         if (error)
599                 goto out_ipreserv;
600
601         error = gfs2_alloc_di(dip, no_addr, generation);
602
603         gfs2_trans_end(sdp);
604
605 out_ipreserv:
606         gfs2_inplace_release(dip);
607 out:
608         gfs2_alloc_put(dip);
609         return error;
610 }
611
612 /**
613  * init_dinode - Fill in a new dinode structure
614  * @dip: the directory this inode is being created in
615  * @gl: The glock covering the new inode
616  * @inum: the inode number
617  * @mode: the file permissions
618  * @uid:
619  * @gid:
620  *
621  */
622
623 static void init_dinode(struct gfs2_inode *dip, struct gfs2_glock *gl,
624                         const struct gfs2_inum_host *inum, unsigned int mode,
625                         unsigned int uid, unsigned int gid,
626                         const u64 *generation, dev_t dev, struct buffer_head **bhp)
627 {
628         struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
629         struct gfs2_dinode *di;
630         struct buffer_head *dibh;
631         struct timespec tv = CURRENT_TIME;
632
633         dibh = gfs2_meta_new(gl, inum->no_addr);
634         gfs2_trans_add_bh(gl, dibh, 1);
635         gfs2_metatype_set(dibh, GFS2_METATYPE_DI, GFS2_FORMAT_DI);
636         gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode));
637         di = (struct gfs2_dinode *)dibh->b_data;
638
639         di->di_num.no_formal_ino = cpu_to_be64(inum->no_formal_ino);
640         di->di_num.no_addr = cpu_to_be64(inum->no_addr);
641         di->di_mode = cpu_to_be32(mode);
642         di->di_uid = cpu_to_be32(uid);
643         di->di_gid = cpu_to_be32(gid);
644         di->di_nlink = 0;
645         di->di_size = 0;
646         di->di_blocks = cpu_to_be64(1);
647         di->di_atime = di->di_mtime = di->di_ctime = cpu_to_be64(tv.tv_sec);
648         di->di_major = cpu_to_be32(MAJOR(dev));
649         di->di_minor = cpu_to_be32(MINOR(dev));
650         di->di_goal_meta = di->di_goal_data = cpu_to_be64(inum->no_addr);
651         di->di_generation = cpu_to_be64(*generation);
652         di->di_flags = 0;
653
654         if (S_ISREG(mode)) {
655                 if ((dip->i_diskflags & GFS2_DIF_INHERIT_JDATA) ||
656                     gfs2_tune_get(sdp, gt_new_files_jdata))
657                         di->di_flags |= cpu_to_be32(GFS2_DIF_JDATA);
658         } else if (S_ISDIR(mode)) {
659                 di->di_flags |= cpu_to_be32(dip->i_diskflags &
660                                             GFS2_DIF_INHERIT_JDATA);
661         }
662
663         di->__pad1 = 0;
664         di->di_payload_format = cpu_to_be32(S_ISDIR(mode) ? GFS2_FORMAT_DE : 0);
665         di->di_height = 0;
666         di->__pad2 = 0;
667         di->__pad3 = 0;
668         di->di_depth = 0;
669         di->di_entries = 0;
670         memset(&di->__pad4, 0, sizeof(di->__pad4));
671         di->di_eattr = 0;
672         di->di_atime_nsec = cpu_to_be32(tv.tv_nsec);
673         di->di_mtime_nsec = cpu_to_be32(tv.tv_nsec);
674         di->di_ctime_nsec = cpu_to_be32(tv.tv_nsec);
675         memset(&di->di_reserved, 0, sizeof(di->di_reserved));
676         
677         set_buffer_uptodate(dibh);
678
679         *bhp = dibh;
680 }
681
682 static int make_dinode(struct gfs2_inode *dip, struct gfs2_glock *gl,
683                        unsigned int mode, const struct gfs2_inum_host *inum,
684                        const u64 *generation, dev_t dev, struct buffer_head **bhp)
685 {
686         struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
687         unsigned int uid, gid;
688         int error;
689
690         munge_mode_uid_gid(dip, &mode, &uid, &gid);
691         if (!gfs2_alloc_get(dip))
692                 return -ENOMEM;
693
694         error = gfs2_quota_lock(dip, uid, gid);
695         if (error)
696                 goto out;
697
698         error = gfs2_quota_check(dip, uid, gid);
699         if (error)
700                 goto out_quota;
701
702         error = gfs2_trans_begin(sdp, RES_DINODE + RES_QUOTA, 0);
703         if (error)
704                 goto out_quota;
705
706         init_dinode(dip, gl, inum, mode, uid, gid, generation, dev, bhp);
707         gfs2_quota_change(dip, +1, uid, gid);
708         gfs2_trans_end(sdp);
709
710 out_quota:
711         gfs2_quota_unlock(dip);
712 out:
713         gfs2_alloc_put(dip);
714         return error;
715 }
716
717 static int link_dinode(struct gfs2_inode *dip, const struct qstr *name,
718                        struct gfs2_inode *ip)
719 {
720         struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
721         struct gfs2_alloc *al;
722         int alloc_required;
723         struct buffer_head *dibh;
724         int error;
725
726         al = gfs2_alloc_get(dip);
727         if (!al)
728                 return -ENOMEM;
729
730         error = gfs2_quota_lock(dip, NO_QUOTA_CHANGE, NO_QUOTA_CHANGE);
731         if (error)
732                 goto fail;
733
734         error = alloc_required = gfs2_diradd_alloc_required(&dip->i_inode, name);
735         if (alloc_required < 0)
736                 goto fail_quota_locks;
737         if (alloc_required) {
738                 error = gfs2_quota_check(dip, dip->i_inode.i_uid, dip->i_inode.i_gid);
739                 if (error)
740                         goto fail_quota_locks;
741
742                 al->al_requested = sdp->sd_max_dirres;
743
744                 error = gfs2_inplace_reserve(dip);
745                 if (error)
746                         goto fail_quota_locks;
747
748                 error = gfs2_trans_begin(sdp, sdp->sd_max_dirres +
749                                          al->al_rgd->rd_length +
750                                          2 * RES_DINODE +
751                                          RES_STATFS + RES_QUOTA, 0);
752                 if (error)
753                         goto fail_ipreserv;
754         } else {
755                 error = gfs2_trans_begin(sdp, RES_LEAF + 2 * RES_DINODE, 0);
756                 if (error)
757                         goto fail_quota_locks;
758         }
759
760         error = gfs2_dir_add(&dip->i_inode, name, ip, IF2DT(ip->i_inode.i_mode));
761         if (error)
762                 goto fail_end_trans;
763
764         error = gfs2_meta_inode_buffer(ip, &dibh);
765         if (error)
766                 goto fail_end_trans;
767         ip->i_inode.i_nlink = 1;
768         gfs2_trans_add_bh(ip->i_gl, dibh, 1);
769         gfs2_dinode_out(ip, dibh->b_data);
770         brelse(dibh);
771         return 0;
772
773 fail_end_trans:
774         gfs2_trans_end(sdp);
775
776 fail_ipreserv:
777         if (dip->i_alloc->al_rgd)
778                 gfs2_inplace_release(dip);
779
780 fail_quota_locks:
781         gfs2_quota_unlock(dip);
782
783 fail:
784         gfs2_alloc_put(dip);
785         return error;
786 }
787
788 static int gfs2_security_init(struct gfs2_inode *dip, struct gfs2_inode *ip)
789 {
790         int err;
791         size_t len;
792         void *value;
793         char *name;
794
795         err = security_inode_init_security(&ip->i_inode, &dip->i_inode,
796                                            &name, &value, &len);
797
798         if (err) {
799                 if (err == -EOPNOTSUPP)
800                         return 0;
801                 return err;
802         }
803
804         err = __gfs2_xattr_set(&ip->i_inode, name, value, len, 0,
805                                GFS2_EATYPE_SECURITY);
806         kfree(value);
807         kfree(name);
808
809         return err;
810 }
811
812 /**
813  * gfs2_createi - Create a new inode
814  * @ghs: An array of two holders
815  * @name: The name of the new file
816  * @mode: the permissions on the new inode
817  *
818  * @ghs[0] is an initialized holder for the directory
819  * @ghs[1] is the holder for the inode lock
820  *
821  * If the return value is not NULL, the glocks on both the directory and the new
822  * file are held.  A transaction has been started and an inplace reservation
823  * is held, as well.
824  *
825  * Returns: An inode
826  */
827
828 struct inode *gfs2_createi(struct gfs2_holder *ghs, const struct qstr *name,
829                            unsigned int mode, dev_t dev)
830 {
831         struct inode *inode = NULL;
832         struct gfs2_inode *dip = ghs->gh_gl->gl_object;
833         struct inode *dir = &dip->i_inode;
834         struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
835         struct gfs2_inum_host inum = { .no_addr = 0, .no_formal_ino = 0 };
836         int error;
837         u64 generation;
838         struct buffer_head *bh = NULL;
839
840         if (!name->len || name->len > GFS2_FNAMESIZE)
841                 return ERR_PTR(-ENAMETOOLONG);
842
843         gfs2_holder_reinit(LM_ST_EXCLUSIVE, 0, ghs);
844         error = gfs2_glock_nq(ghs);
845         if (error)
846                 goto fail;
847
848         error = create_ok(dip, name, mode);
849         if (error)
850                 goto fail_gunlock;
851
852         error = alloc_dinode(dip, &inum.no_addr, &generation);
853         if (error)
854                 goto fail_gunlock;
855         inum.no_formal_ino = generation;
856
857         error = gfs2_glock_nq_num(sdp, inum.no_addr, &gfs2_inode_glops,
858                                   LM_ST_EXCLUSIVE, GL_SKIP, ghs + 1);
859         if (error)
860                 goto fail_gunlock;
861
862         error = make_dinode(dip, ghs[1].gh_gl, mode, &inum, &generation, dev, &bh);
863         if (error)
864                 goto fail_gunlock2;
865
866         inode = gfs2_inode_lookup(dir->i_sb, IF2DT(mode), inum.no_addr,
867                                   inum.no_formal_ino, 0);
868         if (IS_ERR(inode))
869                 goto fail_gunlock2;
870
871         error = gfs2_inode_refresh(GFS2_I(inode));
872         if (error)
873                 goto fail_gunlock2;
874
875         error = gfs2_acl_create(dip, inode);
876         if (error)
877                 goto fail_gunlock2;
878
879         error = gfs2_security_init(dip, GFS2_I(inode));
880         if (error)
881                 goto fail_gunlock2;
882
883         error = link_dinode(dip, name, GFS2_I(inode));
884         if (error)
885                 goto fail_gunlock2;
886
887         if (bh)
888                 brelse(bh);
889         return inode;
890
891 fail_gunlock2:
892         gfs2_glock_dq_uninit(ghs + 1);
893         if (inode && !IS_ERR(inode))
894                 iput(inode);
895 fail_gunlock:
896         gfs2_glock_dq(ghs);
897 fail:
898         if (bh)
899                 brelse(bh);
900         return ERR_PTR(error);
901 }
902
903 static int __gfs2_setattr_simple(struct gfs2_inode *ip, struct iattr *attr)
904 {
905         struct buffer_head *dibh;
906         int error;
907
908         error = gfs2_meta_inode_buffer(ip, &dibh);
909         if (!error) {
910                 error = inode_setattr(&ip->i_inode, attr);
911                 gfs2_assert_warn(GFS2_SB(&ip->i_inode), !error);
912                 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
913                 gfs2_dinode_out(ip, dibh->b_data);
914                 brelse(dibh);
915         }
916         return error;
917 }
918
919 /**
920  * gfs2_setattr_simple -
921  * @ip:
922  * @attr:
923  *
924  * Called with a reference on the vnode.
925  *
926  * Returns: errno
927  */
928
929 int gfs2_setattr_simple(struct gfs2_inode *ip, struct iattr *attr)
930 {
931         int error;
932
933         if (current->journal_info)
934                 return __gfs2_setattr_simple(ip, attr);
935
936         error = gfs2_trans_begin(GFS2_SB(&ip->i_inode), RES_DINODE, 0);
937         if (error)
938                 return error;
939
940         error = __gfs2_setattr_simple(ip, attr);
941         gfs2_trans_end(GFS2_SB(&ip->i_inode));
942         return error;
943 }
944
945 void gfs2_dinode_out(const struct gfs2_inode *ip, void *buf)
946 {
947         struct gfs2_dinode *str = buf;
948
949         str->di_header.mh_magic = cpu_to_be32(GFS2_MAGIC);
950         str->di_header.mh_type = cpu_to_be32(GFS2_METATYPE_DI);
951         str->di_header.mh_format = cpu_to_be32(GFS2_FORMAT_DI);
952         str->di_num.no_addr = cpu_to_be64(ip->i_no_addr);
953         str->di_num.no_formal_ino = cpu_to_be64(ip->i_no_formal_ino);
954         str->di_mode = cpu_to_be32(ip->i_inode.i_mode);
955         str->di_uid = cpu_to_be32(ip->i_inode.i_uid);
956         str->di_gid = cpu_to_be32(ip->i_inode.i_gid);
957         str->di_nlink = cpu_to_be32(ip->i_inode.i_nlink);
958         str->di_size = cpu_to_be64(ip->i_disksize);
959         str->di_blocks = cpu_to_be64(gfs2_get_inode_blocks(&ip->i_inode));
960         str->di_atime = cpu_to_be64(ip->i_inode.i_atime.tv_sec);
961         str->di_mtime = cpu_to_be64(ip->i_inode.i_mtime.tv_sec);
962         str->di_ctime = cpu_to_be64(ip->i_inode.i_ctime.tv_sec);
963
964         str->di_goal_meta = cpu_to_be64(ip->i_goal);
965         str->di_goal_data = cpu_to_be64(ip->i_goal);
966         str->di_generation = cpu_to_be64(ip->i_generation);
967
968         str->di_flags = cpu_to_be32(ip->i_diskflags);
969         str->di_height = cpu_to_be16(ip->i_height);
970         str->di_payload_format = cpu_to_be32(S_ISDIR(ip->i_inode.i_mode) &&
971                                              !(ip->i_diskflags & GFS2_DIF_EXHASH) ?
972                                              GFS2_FORMAT_DE : 0);
973         str->di_depth = cpu_to_be16(ip->i_depth);
974         str->di_entries = cpu_to_be32(ip->i_entries);
975
976         str->di_eattr = cpu_to_be64(ip->i_eattr);
977         str->di_atime_nsec = cpu_to_be32(ip->i_inode.i_atime.tv_nsec);
978         str->di_mtime_nsec = cpu_to_be32(ip->i_inode.i_mtime.tv_nsec);
979         str->di_ctime_nsec = cpu_to_be32(ip->i_inode.i_ctime.tv_nsec);
980 }
981
982 void gfs2_dinode_print(const struct gfs2_inode *ip)
983 {
984         printk(KERN_INFO "  no_formal_ino = %llu\n",
985                (unsigned long long)ip->i_no_formal_ino);
986         printk(KERN_INFO "  no_addr = %llu\n",
987                (unsigned long long)ip->i_no_addr);
988         printk(KERN_INFO "  i_disksize = %llu\n",
989                (unsigned long long)ip->i_disksize);
990         printk(KERN_INFO "  blocks = %llu\n",
991                (unsigned long long)gfs2_get_inode_blocks(&ip->i_inode));
992         printk(KERN_INFO "  i_goal = %llu\n",
993                (unsigned long long)ip->i_goal);
994         printk(KERN_INFO "  i_diskflags = 0x%.8X\n", ip->i_diskflags);
995         printk(KERN_INFO "  i_height = %u\n", ip->i_height);
996         printk(KERN_INFO "  i_depth = %u\n", ip->i_depth);
997         printk(KERN_INFO "  i_entries = %u\n", ip->i_entries);
998         printk(KERN_INFO "  i_eattr = %llu\n",
999                (unsigned long long)ip->i_eattr);
1000 }
1001