blob: 81a92116594133e8a0613fb9425955a1657f37e5 [file] [log] [blame]
David Teiglandb3b94fa2006-01-16 16:50:04 +00001/*
2 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
Steven Whitehouse3a8a9a12006-05-18 15:09:15 -04003 * Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved.
David Teiglandb3b94fa2006-01-16 16:50:04 +00004 *
5 * This copyrighted material is made available to anyone wishing to use,
6 * modify, copy, or redistribute it subject to the terms and conditions
Steven Whitehousee9fc2aa2006-09-01 11:05:15 -04007 * of the GNU General Public License version 2.
David Teiglandb3b94fa2006-01-16 16:50:04 +00008 */
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>
Steven Whitehouse5c676f62006-02-27 17:23:27 -050017#include <linux/gfs2_ondisk.h>
Steven Whitehouse71b86f52006-03-28 14:14:04 -050018#include <linux/crc32.h>
Fabio Massimo Di Nitto7d308592006-09-19 07:56:29 +020019#include <linux/lm_interface.h>
David Teiglandb3b94fa2006-01-16 16:50:04 +000020
21#include "gfs2.h"
Steven Whitehouse5c676f62006-02-27 17:23:27 -050022#include "incore.h"
David Teiglandb3b94fa2006-01-16 16:50:04 +000023#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"
Steven Whitehouse5c676f62006-02-27 17:23:27 -050038#include "util.h"
David Teiglandb3b94fa2006-01-16 16:50:04 +000039
40/**
Steven Whitehouse4340fe62006-07-11 09:46:33 -040041 * gfs2_inode_attr_in - Copy attributes from the dinode into the VFS inode
David Teiglandb3b94fa2006-01-16 16:50:04 +000042 * @ip: The GFS2 inode (with embedded disk inode data)
43 * @inode: The Linux VFS inode
44 *
45 */
46
Steven Whitehouse4340fe62006-07-11 09:46:33 -040047void gfs2_inode_attr_in(struct gfs2_inode *ip)
David Teiglandb3b94fa2006-01-16 16:50:04 +000048{
Steven Whitehouse4340fe62006-07-11 09:46:33 -040049 struct inode *inode = &ip->i_inode;
Steven Whitehousec2668712006-09-04 13:55:48 -040050 struct gfs2_dinode *di = &ip->i_di;
Steven Whitehouse4340fe62006-07-11 09:46:33 -040051
52 inode->i_ino = ip->i_num.no_addr;
David Teiglandb3b94fa2006-01-16 16:50:04 +000053
Steven Whitehousec2668712006-09-04 13:55:48 -040054 switch (di->di_mode & S_IFMT) {
David Teiglandb3b94fa2006-01-16 16:50:04 +000055 case S_IFBLK:
56 case S_IFCHR:
Steven Whitehousec2668712006-09-04 13:55:48 -040057 inode->i_rdev = MKDEV(di->di_major, di->di_minor);
David Teiglandb3b94fa2006-01-16 16:50:04 +000058 break;
59 default:
60 inode->i_rdev = 0;
61 break;
62 };
63
Steven Whitehousec2668712006-09-04 13:55:48 -040064 inode->i_mode = di->di_mode;
65 inode->i_nlink = di->di_nlink;
66 inode->i_uid = di->di_uid;
67 inode->i_gid = di->di_gid;
68 i_size_write(inode, di->di_size);
69 inode->i_atime.tv_sec = di->di_atime;
70 inode->i_mtime.tv_sec = di->di_mtime;
71 inode->i_ctime.tv_sec = di->di_ctime;
David Teiglandb3b94fa2006-01-16 16:50:04 +000072 inode->i_atime.tv_nsec = 0;
73 inode->i_mtime.tv_nsec = 0;
74 inode->i_ctime.tv_nsec = 0;
Steven Whitehousec2668712006-09-04 13:55:48 -040075 inode->i_blocks = di->di_blocks <<
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -040076 (GFS2_SB(inode)->sd_sb.sb_bsize_shift - GFS2_BASIC_BLOCK_SHIFT);
David Teiglandb3b94fa2006-01-16 16:50:04 +000077
Steven Whitehousec2668712006-09-04 13:55:48 -040078 if (di->di_flags & GFS2_DIF_IMMUTABLE)
David Teiglandb3b94fa2006-01-16 16:50:04 +000079 inode->i_flags |= S_IMMUTABLE;
80 else
81 inode->i_flags &= ~S_IMMUTABLE;
82
Steven Whitehousec2668712006-09-04 13:55:48 -040083 if (di->di_flags & GFS2_DIF_APPENDONLY)
David Teiglandb3b94fa2006-01-16 16:50:04 +000084 inode->i_flags |= S_APPEND;
85 else
86 inode->i_flags &= ~S_APPEND;
87}
88
89/**
David Teiglandb3b94fa2006-01-16 16:50:04 +000090 * gfs2_inode_attr_out - Copy attributes from VFS inode into the dinode
91 * @ip: The GFS2 inode
92 *
93 * Only copy out the attributes that we want the VFS layer
94 * to be able to modify.
95 */
96
97void gfs2_inode_attr_out(struct gfs2_inode *ip)
98{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -040099 struct inode *inode = &ip->i_inode;
Steven Whitehouse75d3b812006-09-04 11:41:31 -0400100 struct gfs2_dinode *di = &ip->i_di;
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400101 gfs2_assert_withdraw(GFS2_SB(inode),
Steven Whitehouse75d3b812006-09-04 11:41:31 -0400102 (di->di_mode & S_IFMT) == (inode->i_mode & S_IFMT));
103 di->di_mode = inode->i_mode;
104 di->di_uid = inode->i_uid;
105 di->di_gid = inode->i_gid;
106 di->di_atime = inode->i_atime.tv_sec;
107 di->di_mtime = inode->i_mtime.tv_sec;
108 di->di_ctime = inode->i_ctime.tv_sec;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000109}
110
David Teiglandb3b94fa2006-01-16 16:50:04 +0000111static int iget_test(struct inode *inode, void *opaque)
112{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400113 struct gfs2_inode *ip = GFS2_I(inode);
114 struct gfs2_inum *inum = opaque;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000115
116 if (ip && ip->i_num.no_addr == inum->no_addr)
117 return 1;
118
119 return 0;
120}
121
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400122static int iget_set(struct inode *inode, void *opaque)
123{
124 struct gfs2_inode *ip = GFS2_I(inode);
125 struct gfs2_inum *inum = opaque;
126
127 ip->i_num = *inum;
128 return 0;
129}
130
131struct inode *gfs2_ilookup(struct super_block *sb, struct gfs2_inum *inum)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000132{
133 return ilookup5(sb, (unsigned long)inum->no_formal_ino,
134 iget_test, inum);
135}
136
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400137static struct inode *gfs2_iget(struct super_block *sb, struct gfs2_inum *inum)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000138{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400139 return iget5_locked(sb, (unsigned long)inum->no_formal_ino,
140 iget_test, iget_set, inum);
141}
142
143/**
144 * gfs2_inode_lookup - Lookup an inode
145 * @sb: The super block
146 * @inum: The inode number
147 * @type: The type of the inode
148 *
149 * Returns: A VFS inode, or an error
150 */
151
152struct inode *gfs2_inode_lookup(struct super_block *sb, struct gfs2_inum *inum, unsigned int type)
153{
154 struct inode *inode = gfs2_iget(sb, inum);
155 struct gfs2_inode *ip = GFS2_I(inode);
156 struct gfs2_glock *io_gl;
157 int error;
158
159 if (inode->i_state & I_NEW) {
160 struct gfs2_sbd *sdp = GFS2_SB(inode);
161 umode_t mode = DT2IF(type);
Theodore Ts'obba9dfd2006-09-27 01:50:31 -0700162 inode->i_private = ip;
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400163 inode->i_mode = mode;
164
165 if (S_ISREG(mode)) {
166 inode->i_op = &gfs2_file_iops;
167 inode->i_fop = &gfs2_file_fops;
168 inode->i_mapping->a_ops = &gfs2_file_aops;
169 } else if (S_ISDIR(mode)) {
170 inode->i_op = &gfs2_dir_iops;
171 inode->i_fop = &gfs2_dir_fops;
172 } else if (S_ISLNK(mode)) {
173 inode->i_op = &gfs2_symlink_iops;
174 } else {
175 inode->i_op = &gfs2_dev_iops;
176 }
177
178 error = gfs2_glock_get(sdp, inum->no_addr, &gfs2_inode_glops, CREATE, &ip->i_gl);
179 if (unlikely(error))
180 goto fail;
181 ip->i_gl->gl_object = ip;
182
183 error = gfs2_glock_get(sdp, inum->no_addr, &gfs2_iopen_glops, CREATE, &io_gl);
184 if (unlikely(error))
185 goto fail_put;
186
187 ip->i_vn = ip->i_gl->gl_vn - 1;
188 error = gfs2_glock_nq_init(io_gl, LM_ST_SHARED, GL_EXACT, &ip->i_iopen_gh);
189 if (unlikely(error))
190 goto fail_iopen;
191
192 gfs2_glock_put(io_gl);
193 unlock_new_inode(inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000194 }
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400195
196 return inode;
197fail_iopen:
198 gfs2_glock_put(io_gl);
199fail_put:
200 ip->i_gl->gl_object = NULL;
201 gfs2_glock_put(ip->i_gl);
202fail:
203 iput(inode);
204 return ERR_PTR(error);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000205}
206
207/**
208 * gfs2_inode_refresh - Refresh the incore copy of the dinode
209 * @ip: The GFS2 inode
210 *
211 * Returns: errno
212 */
213
214int gfs2_inode_refresh(struct gfs2_inode *ip)
215{
216 struct buffer_head *dibh;
217 int error;
218
219 error = gfs2_meta_inode_buffer(ip, &dibh);
220 if (error)
221 return error;
222
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400223 if (gfs2_metatype_check(GFS2_SB(&ip->i_inode), dibh, GFS2_METATYPE_DI)) {
David Teiglandb3b94fa2006-01-16 16:50:04 +0000224 brelse(dibh);
225 return -EIO;
226 }
227
David Teiglandb3b94fa2006-01-16 16:50:04 +0000228 gfs2_dinode_in(&ip->i_di, dibh->b_data);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000229
230 brelse(dibh);
231
232 if (ip->i_num.no_addr != ip->i_di.di_num.no_addr) {
233 if (gfs2_consist_inode(ip))
234 gfs2_dinode_print(&ip->i_di);
235 return -EIO;
236 }
237 if (ip->i_num.no_formal_ino != ip->i_di.di_num.no_formal_ino)
238 return -ESTALE;
239
240 ip->i_vn = ip->i_gl->gl_vn;
241
242 return 0;
243}
244
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400245int gfs2_dinode_dealloc(struct gfs2_inode *ip)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000246{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400247 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000248 struct gfs2_alloc *al;
249 struct gfs2_rgrpd *rgd;
250 int error;
251
252 if (ip->i_di.di_blocks != 1) {
253 if (gfs2_consist_inode(ip))
254 gfs2_dinode_print(&ip->i_di);
255 return -EIO;
256 }
257
258 al = gfs2_alloc_get(ip);
259
260 error = gfs2_quota_hold(ip, NO_QUOTA_CHANGE, NO_QUOTA_CHANGE);
261 if (error)
262 goto out;
263
264 error = gfs2_rindex_hold(sdp, &al->al_ri_gh);
265 if (error)
266 goto out_qs;
267
268 rgd = gfs2_blk2rgrpd(sdp, ip->i_num.no_addr);
269 if (!rgd) {
270 gfs2_consist_inode(ip);
271 error = -EIO;
272 goto out_rindex_relse;
273 }
274
275 error = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_EXCLUSIVE, 0,
276 &al->al_rgd_gh);
277 if (error)
278 goto out_rindex_relse;
279
Steven Whitehouse420b9e52006-07-31 15:42:17 -0400280 error = gfs2_trans_begin(sdp, RES_RG_BIT + RES_STATFS + RES_QUOTA, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000281 if (error)
282 goto out_rg_gunlock;
283
284 gfs2_trans_add_gl(ip->i_gl);
285
286 gfs2_free_di(rgd, ip);
287
David Teiglandb3b94fa2006-01-16 16:50:04 +0000288 gfs2_trans_end(sdp);
289 clear_bit(GLF_STICKY, &ip->i_gl->gl_flags);
290
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400291out_rg_gunlock:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000292 gfs2_glock_dq_uninit(&al->al_rgd_gh);
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400293out_rindex_relse:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000294 gfs2_glock_dq_uninit(&al->al_ri_gh);
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400295out_qs:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000296 gfs2_quota_unhold(ip);
Steven Whitehouse36327522006-04-28 10:46:21 -0400297out:
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400298 gfs2_alloc_put(ip);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000299 return error;
300}
301
302/**
David Teiglandb3b94fa2006-01-16 16:50:04 +0000303 * gfs2_change_nlink - Change nlink count on inode
304 * @ip: The GFS2 inode
305 * @diff: The change in the nlink count required
306 *
307 * Returns: errno
308 */
309
310int gfs2_change_nlink(struct gfs2_inode *ip, int diff)
311{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400312 struct gfs2_sbd *sdp = ip->i_inode.i_sb->s_fs_info;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000313 struct buffer_head *dibh;
Steven Whitehousecd915492006-09-04 12:49:07 -0400314 u32 nlink;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000315 int error;
316
Steven Whitehouse29937ac2006-07-06 17:58:03 -0400317 BUG_ON(ip->i_di.di_nlink != ip->i_inode.i_nlink);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000318 nlink = ip->i_di.di_nlink + diff;
319
320 /* If we are reducing the nlink count, but the new value ends up being
321 bigger than the old one, we must have underflowed. */
322 if (diff < 0 && nlink > ip->i_di.di_nlink) {
323 if (gfs2_consist_inode(ip))
324 gfs2_dinode_print(&ip->i_di);
325 return -EIO;
326 }
327
328 error = gfs2_meta_inode_buffer(ip, &dibh);
329 if (error)
330 return error;
331
332 ip->i_di.di_nlink = nlink;
333 ip->i_di.di_ctime = get_seconds();
Steven Whitehouse29937ac2006-07-06 17:58:03 -0400334 ip->i_inode.i_nlink = nlink;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000335
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +0000336 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000337 gfs2_dinode_out(&ip->i_di, dibh->b_data);
338 brelse(dibh);
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400339 mark_inode_dirty(&ip->i_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000340
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400341 if (ip->i_di.di_nlink == 0) {
342 struct gfs2_rgrpd *rgd;
343 struct gfs2_holder ri_gh, rg_gh;
344
345 error = gfs2_rindex_hold(sdp, &ri_gh);
346 if (error)
347 goto out;
348 error = -EIO;
349 rgd = gfs2_blk2rgrpd(sdp, ip->i_num.no_addr);
350 if (!rgd)
351 goto out_norgrp;
352 error = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_EXCLUSIVE, 0, &rg_gh);
353 if (error)
354 goto out_norgrp;
355
Steven Whitehousef92a0b62006-10-02 16:01:53 -0400356 clear_nlink(&ip->i_inode);
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400357 gfs2_unlink_di(&ip->i_inode); /* mark inode unlinked */
358 gfs2_glock_dq_uninit(&rg_gh);
359out_norgrp:
360 gfs2_glock_dq_uninit(&ri_gh);
361 }
362out:
363 return error;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000364}
365
Steven Whitehousec7526662006-03-20 12:30:04 -0500366struct inode *gfs2_lookup_simple(struct inode *dip, const char *name)
367{
368 struct qstr qstr;
Steven Whitehouse71b86f52006-03-28 14:14:04 -0500369 gfs2_str2qstr(&qstr, name);
Steven Whitehousec7526662006-03-20 12:30:04 -0500370 return gfs2_lookupi(dip, &qstr, 1, NULL);
371}
372
373
David Teiglandb3b94fa2006-01-16 16:50:04 +0000374/**
375 * gfs2_lookupi - Look up a filename in a directory and return its inode
376 * @d_gh: An initialized holder for the directory glock
377 * @name: The name of the inode to look for
378 * @is_root: If 1, ignore the caller's permissions
379 * @i_gh: An uninitialized holder for the new inode glock
380 *
381 * There will always be a vnode (Linux VFS inode) for the d_gh inode unless
382 * @is_root is true.
383 *
384 * Returns: errno
385 */
386
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400387struct inode *gfs2_lookupi(struct inode *dir, const struct qstr *name,
388 int is_root, struct nameidata *nd)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000389{
Steven Whitehousec9fd4302006-03-01 15:31:02 -0500390 struct super_block *sb = dir->i_sb;
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400391 struct gfs2_inode *dip = GFS2_I(dir);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000392 struct gfs2_holder d_gh;
393 struct gfs2_inum inum;
394 unsigned int type;
Steven Whitehouse7359a192006-02-13 12:27:43 +0000395 int error = 0;
Steven Whitehousec7526662006-03-20 12:30:04 -0500396 struct inode *inode = NULL;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000397
398 if (!name->len || name->len > GFS2_FNAMESIZE)
Steven Whitehousec7526662006-03-20 12:30:04 -0500399 return ERR_PTR(-ENAMETOOLONG);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000400
Steven Whitehousec7526662006-03-20 12:30:04 -0500401 if ((name->len == 1 && memcmp(name->name, ".", 1) == 0) ||
402 (name->len == 2 && memcmp(name->name, "..", 2) == 0 &&
403 dir == sb->s_root->d_inode)) {
Steven Whitehouse320dd102006-05-18 16:25:27 -0400404 igrab(dir);
405 return dir;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000406 }
407
408 error = gfs2_glock_nq_init(dip->i_gl, LM_ST_SHARED, 0, &d_gh);
409 if (error)
Steven Whitehousec7526662006-03-20 12:30:04 -0500410 return ERR_PTR(error);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000411
412 if (!is_root) {
Steven Whitehousefaf450e2006-06-22 10:59:10 -0400413 error = permission(dir, MAY_EXEC, NULL);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000414 if (error)
415 goto out;
416 }
417
Steven Whitehousec7526662006-03-20 12:30:04 -0500418 error = gfs2_dir_search(dir, name, &inum, &type);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000419 if (error)
420 goto out;
421
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400422 inode = gfs2_inode_lookup(sb, &inum, type);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000423
Steven Whitehouse7359a192006-02-13 12:27:43 +0000424out:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000425 gfs2_glock_dq_uninit(&d_gh);
Steven Whitehousec7526662006-03-20 12:30:04 -0500426 if (error == -ENOENT)
427 return NULL;
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400428 return inode;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000429}
430
Steven Whitehousecd915492006-09-04 12:49:07 -0400431static int pick_formal_ino_1(struct gfs2_sbd *sdp, u64 *formal_ino)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000432{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400433 struct gfs2_inode *ip = GFS2_I(sdp->sd_ir_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000434 struct buffer_head *bh;
435 struct gfs2_inum_range ir;
436 int error;
437
438 error = gfs2_trans_begin(sdp, RES_DINODE, 0);
439 if (error)
440 return error;
Steven Whitehousef55ab262006-02-21 12:51:39 +0000441 mutex_lock(&sdp->sd_inum_mutex);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000442
443 error = gfs2_meta_inode_buffer(ip, &bh);
444 if (error) {
Steven Whitehousef55ab262006-02-21 12:51:39 +0000445 mutex_unlock(&sdp->sd_inum_mutex);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000446 gfs2_trans_end(sdp);
447 return error;
448 }
449
450 gfs2_inum_range_in(&ir, bh->b_data + sizeof(struct gfs2_dinode));
451
452 if (ir.ir_length) {
453 *formal_ino = ir.ir_start++;
454 ir.ir_length--;
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +0000455 gfs2_trans_add_bh(ip->i_gl, bh, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000456 gfs2_inum_range_out(&ir,
457 bh->b_data + sizeof(struct gfs2_dinode));
458 brelse(bh);
Steven Whitehousef55ab262006-02-21 12:51:39 +0000459 mutex_unlock(&sdp->sd_inum_mutex);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000460 gfs2_trans_end(sdp);
461 return 0;
462 }
463
464 brelse(bh);
465
Steven Whitehousef55ab262006-02-21 12:51:39 +0000466 mutex_unlock(&sdp->sd_inum_mutex);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000467 gfs2_trans_end(sdp);
468
469 return 1;
470}
471
Steven Whitehousecd915492006-09-04 12:49:07 -0400472static int pick_formal_ino_2(struct gfs2_sbd *sdp, u64 *formal_ino)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000473{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400474 struct gfs2_inode *ip = GFS2_I(sdp->sd_ir_inode);
475 struct gfs2_inode *m_ip = GFS2_I(sdp->sd_inum_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000476 struct gfs2_holder gh;
477 struct buffer_head *bh;
478 struct gfs2_inum_range ir;
479 int error;
480
481 error = gfs2_glock_nq_init(m_ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
482 if (error)
483 return error;
484
485 error = gfs2_trans_begin(sdp, 2 * RES_DINODE, 0);
486 if (error)
487 goto out;
Steven Whitehousef55ab262006-02-21 12:51:39 +0000488 mutex_lock(&sdp->sd_inum_mutex);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000489
490 error = gfs2_meta_inode_buffer(ip, &bh);
491 if (error)
492 goto out_end_trans;
Steven Whitehouse907b9bc2006-09-25 09:26:04 -0400493
David Teiglandb3b94fa2006-01-16 16:50:04 +0000494 gfs2_inum_range_in(&ir, bh->b_data + sizeof(struct gfs2_dinode));
495
496 if (!ir.ir_length) {
497 struct buffer_head *m_bh;
Steven Whitehousecd915492006-09-04 12:49:07 -0400498 u64 x, y;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000499
500 error = gfs2_meta_inode_buffer(m_ip, &m_bh);
501 if (error)
502 goto out_brelse;
503
Steven Whitehousecd915492006-09-04 12:49:07 -0400504 x = *(u64 *)(m_bh->b_data + sizeof(struct gfs2_dinode));
David Teiglandb3b94fa2006-01-16 16:50:04 +0000505 x = y = be64_to_cpu(x);
506 ir.ir_start = x;
507 ir.ir_length = GFS2_INUM_QUANTUM;
508 x += GFS2_INUM_QUANTUM;
509 if (x < y)
510 gfs2_consist_inode(m_ip);
511 x = cpu_to_be64(x);
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +0000512 gfs2_trans_add_bh(m_ip->i_gl, m_bh, 1);
Steven Whitehousecd915492006-09-04 12:49:07 -0400513 *(u64 *)(m_bh->b_data + sizeof(struct gfs2_dinode)) = x;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000514
515 brelse(m_bh);
516 }
517
518 *formal_ino = ir.ir_start++;
519 ir.ir_length--;
520
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +0000521 gfs2_trans_add_bh(ip->i_gl, bh, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000522 gfs2_inum_range_out(&ir, bh->b_data + sizeof(struct gfs2_dinode));
523
Steven Whitehouse420b9e52006-07-31 15:42:17 -0400524out_brelse:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000525 brelse(bh);
Steven Whitehouse420b9e52006-07-31 15:42:17 -0400526out_end_trans:
Steven Whitehousef55ab262006-02-21 12:51:39 +0000527 mutex_unlock(&sdp->sd_inum_mutex);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000528 gfs2_trans_end(sdp);
Steven Whitehouse420b9e52006-07-31 15:42:17 -0400529out:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000530 gfs2_glock_dq_uninit(&gh);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000531 return error;
532}
533
Steven Whitehousecd915492006-09-04 12:49:07 -0400534static int pick_formal_ino(struct gfs2_sbd *sdp, u64 *inum)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000535{
536 int error;
537
538 error = pick_formal_ino_1(sdp, inum);
539 if (error <= 0)
540 return error;
541
542 error = pick_formal_ino_2(sdp, inum);
543
544 return error;
545}
546
547/**
548 * create_ok - OK to create a new on-disk inode here?
549 * @dip: Directory in which dinode is to be created
550 * @name: Name of new dinode
551 * @mode:
552 *
553 * Returns: errno
554 */
555
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400556static int create_ok(struct gfs2_inode *dip, const struct qstr *name,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000557 unsigned int mode)
558{
559 int error;
560
Steven Whitehousefaf450e2006-06-22 10:59:10 -0400561 error = permission(&dip->i_inode, MAY_WRITE | MAY_EXEC, NULL);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000562 if (error)
563 return error;
564
565 /* Don't create entries in an unlinked directory */
566 if (!dip->i_di.di_nlink)
567 return -EPERM;
568
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400569 error = gfs2_dir_search(&dip->i_inode, name, NULL, NULL);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000570 switch (error) {
571 case -ENOENT:
572 error = 0;
573 break;
574 case 0:
575 return -EEXIST;
576 default:
577 return error;
578 }
579
Steven Whitehousecd915492006-09-04 12:49:07 -0400580 if (dip->i_di.di_entries == (u32)-1)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000581 return -EFBIG;
Steven Whitehousecd915492006-09-04 12:49:07 -0400582 if (S_ISDIR(mode) && dip->i_di.di_nlink == (u32)-1)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000583 return -EMLINK;
584
585 return 0;
586}
587
588static void munge_mode_uid_gid(struct gfs2_inode *dip, unsigned int *mode,
589 unsigned int *uid, unsigned int *gid)
590{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400591 if (GFS2_SB(&dip->i_inode)->sd_args.ar_suiddir &&
Steven Whitehouse420b9e52006-07-31 15:42:17 -0400592 (dip->i_di.di_mode & S_ISUID) && dip->i_di.di_uid) {
David Teiglandb3b94fa2006-01-16 16:50:04 +0000593 if (S_ISDIR(*mode))
594 *mode |= S_ISUID;
595 else if (dip->i_di.di_uid != current->fsuid)
596 *mode &= ~07111;
597 *uid = dip->i_di.di_uid;
598 } else
599 *uid = current->fsuid;
600
601 if (dip->i_di.di_mode & S_ISGID) {
602 if (S_ISDIR(*mode))
603 *mode |= S_ISGID;
604 *gid = dip->i_di.di_gid;
605 } else
606 *gid = current->fsgid;
607}
608
Steven Whitehouse4340fe62006-07-11 09:46:33 -0400609static int alloc_dinode(struct gfs2_inode *dip, struct gfs2_inum *inum,
610 u64 *generation)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000611{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400612 struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000613 int error;
614
615 gfs2_alloc_get(dip);
616
617 dip->i_alloc.al_requested = RES_DINODE;
618 error = gfs2_inplace_reserve(dip);
619 if (error)
620 goto out;
621
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400622 error = gfs2_trans_begin(sdp, RES_RG_BIT + RES_STATFS, 0);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000623 if (error)
624 goto out_ipreserv;
625
Steven Whitehouse4340fe62006-07-11 09:46:33 -0400626 inum->no_addr = gfs2_alloc_di(dip, generation);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000627
628 gfs2_trans_end(sdp);
629
Steven Whitehouse4340fe62006-07-11 09:46:33 -0400630out_ipreserv:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000631 gfs2_inplace_release(dip);
Steven Whitehouse4340fe62006-07-11 09:46:33 -0400632out:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000633 gfs2_alloc_put(dip);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000634 return error;
635}
636
637/**
638 * init_dinode - Fill in a new dinode structure
639 * @dip: the directory this inode is being created in
640 * @gl: The glock covering the new inode
641 * @inum: the inode number
642 * @mode: the file permissions
643 * @uid:
644 * @gid:
645 *
646 */
647
648static void init_dinode(struct gfs2_inode *dip, struct gfs2_glock *gl,
Steven Whitehouse4340fe62006-07-11 09:46:33 -0400649 const struct gfs2_inum *inum, unsigned int mode,
650 unsigned int uid, unsigned int gid,
651 const u64 *generation)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000652{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400653 struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
Steven Whitehouseb96ca4f2006-01-18 10:57:10 +0000654 struct gfs2_dinode *di;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000655 struct buffer_head *dibh;
656
657 dibh = gfs2_meta_new(gl, inum->no_addr);
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +0000658 gfs2_trans_add_bh(gl, dibh, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000659 gfs2_metatype_set(dibh, GFS2_METATYPE_DI, GFS2_FORMAT_DI);
660 gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode));
Steven Whitehouseb96ca4f2006-01-18 10:57:10 +0000661 di = (struct gfs2_dinode *)dibh->b_data;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000662
Steven Whitehouse2442a092006-01-30 11:49:32 +0000663 di->di_num.no_formal_ino = cpu_to_be64(inum->no_formal_ino);
664 di->di_num.no_addr = cpu_to_be64(inum->no_addr);
Steven Whitehouseb96ca4f2006-01-18 10:57:10 +0000665 di->di_mode = cpu_to_be32(mode);
666 di->di_uid = cpu_to_be32(uid);
667 di->di_gid = cpu_to_be32(gid);
668 di->di_nlink = cpu_to_be32(0);
669 di->di_size = cpu_to_be64(0);
670 di->di_blocks = cpu_to_be64(1);
671 di->di_atime = di->di_mtime = di->di_ctime = cpu_to_be64(get_seconds());
672 di->di_major = di->di_minor = cpu_to_be32(0);
673 di->di_goal_meta = di->di_goal_data = cpu_to_be64(inum->no_addr);
Steven Whitehouse4340fe62006-07-11 09:46:33 -0400674 di->di_generation = cpu_to_be64(*generation);
Steven Whitehouseb96ca4f2006-01-18 10:57:10 +0000675 di->di_flags = cpu_to_be32(0);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000676
677 if (S_ISREG(mode)) {
678 if ((dip->i_di.di_flags & GFS2_DIF_INHERIT_JDATA) ||
679 gfs2_tune_get(sdp, gt_new_files_jdata))
Steven Whitehouseb96ca4f2006-01-18 10:57:10 +0000680 di->di_flags |= cpu_to_be32(GFS2_DIF_JDATA);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000681 if ((dip->i_di.di_flags & GFS2_DIF_INHERIT_DIRECTIO) ||
682 gfs2_tune_get(sdp, gt_new_files_directio))
Steven Whitehouseb96ca4f2006-01-18 10:57:10 +0000683 di->di_flags |= cpu_to_be32(GFS2_DIF_DIRECTIO);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000684 } else if (S_ISDIR(mode)) {
Steven Whitehouse568f4c92006-02-27 12:00:42 -0500685 di->di_flags |= cpu_to_be32(dip->i_di.di_flags &
686 GFS2_DIF_INHERIT_DIRECTIO);
687 di->di_flags |= cpu_to_be32(dip->i_di.di_flags &
688 GFS2_DIF_INHERIT_JDATA);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000689 }
690
Steven Whitehouseb96ca4f2006-01-18 10:57:10 +0000691 di->__pad1 = 0;
Abhijith Dasb2a580d2006-07-10 12:36:12 -0500692 di->di_payload_format = cpu_to_be32(0);
Steven Whitehouseb96ca4f2006-01-18 10:57:10 +0000693 di->di_height = cpu_to_be32(0);
694 di->__pad2 = 0;
695 di->__pad3 = 0;
696 di->di_depth = cpu_to_be16(0);
697 di->di_entries = cpu_to_be32(0);
698 memset(&di->__pad4, 0, sizeof(di->__pad4));
699 di->di_eattr = cpu_to_be64(0);
700 memset(&di->di_reserved, 0, sizeof(di->di_reserved));
701
David Teiglandb3b94fa2006-01-16 16:50:04 +0000702 brelse(dibh);
703}
704
705static int make_dinode(struct gfs2_inode *dip, struct gfs2_glock *gl,
Steven Whitehouse4340fe62006-07-11 09:46:33 -0400706 unsigned int mode, const struct gfs2_inum *inum,
707 const u64 *generation)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000708{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400709 struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000710 unsigned int uid, gid;
711 int error;
712
713 munge_mode_uid_gid(dip, &mode, &uid, &gid);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000714 gfs2_alloc_get(dip);
715
716 error = gfs2_quota_lock(dip, uid, gid);
717 if (error)
718 goto out;
719
720 error = gfs2_quota_check(dip, uid, gid);
721 if (error)
722 goto out_quota;
723
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400724 error = gfs2_trans_begin(sdp, RES_DINODE + RES_QUOTA, 0);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000725 if (error)
726 goto out_quota;
727
Steven Whitehouse4340fe62006-07-11 09:46:33 -0400728 init_dinode(dip, gl, inum, mode, uid, gid, generation);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000729 gfs2_quota_change(dip, +1, uid, gid);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000730 gfs2_trans_end(sdp);
731
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400732out_quota:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000733 gfs2_quota_unlock(dip);
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400734out:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000735 gfs2_alloc_put(dip);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000736 return error;
737}
738
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400739static int link_dinode(struct gfs2_inode *dip, const struct qstr *name,
740 struct gfs2_inode *ip)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000741{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400742 struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000743 struct gfs2_alloc *al;
744 int alloc_required;
745 struct buffer_head *dibh;
746 int error;
747
748 al = gfs2_alloc_get(dip);
749
750 error = gfs2_quota_lock(dip, NO_QUOTA_CHANGE, NO_QUOTA_CHANGE);
751 if (error)
752 goto fail;
753
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400754 error = alloc_required = gfs2_diradd_alloc_required(&dip->i_inode, name);
Steven Whitehousec7526662006-03-20 12:30:04 -0500755 if (alloc_required < 0)
756 goto fail;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000757 if (alloc_required) {
758 error = gfs2_quota_check(dip, dip->i_di.di_uid,
759 dip->i_di.di_gid);
760 if (error)
761 goto fail_quota_locks;
762
763 al->al_requested = sdp->sd_max_dirres;
764
765 error = gfs2_inplace_reserve(dip);
766 if (error)
767 goto fail_quota_locks;
768
Steven Whitehouse320dd102006-05-18 16:25:27 -0400769 error = gfs2_trans_begin(sdp, sdp->sd_max_dirres +
David Teiglandb3b94fa2006-01-16 16:50:04 +0000770 al->al_rgd->rd_ri.ri_length +
Steven Whitehouse907b9bc2006-09-25 09:26:04 -0400771 2 * RES_DINODE +
David Teiglandb3b94fa2006-01-16 16:50:04 +0000772 RES_STATFS + RES_QUOTA, 0);
773 if (error)
774 goto fail_ipreserv;
775 } else {
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400776 error = gfs2_trans_begin(sdp, RES_LEAF + 2 * RES_DINODE, 0);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000777 if (error)
778 goto fail_quota_locks;
779 }
780
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400781 error = gfs2_dir_add(&dip->i_inode, name, &ip->i_num, IF2DT(ip->i_di.di_mode));
David Teiglandb3b94fa2006-01-16 16:50:04 +0000782 if (error)
783 goto fail_end_trans;
784
785 error = gfs2_meta_inode_buffer(ip, &dibh);
786 if (error)
787 goto fail_end_trans;
788 ip->i_di.di_nlink = 1;
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +0000789 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000790 gfs2_dinode_out(&ip->i_di, dibh->b_data);
791 brelse(dibh);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000792 return 0;
793
Steven Whitehouse320dd102006-05-18 16:25:27 -0400794fail_end_trans:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000795 gfs2_trans_end(sdp);
796
Steven Whitehouse320dd102006-05-18 16:25:27 -0400797fail_ipreserv:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000798 if (dip->i_alloc.al_rgd)
799 gfs2_inplace_release(dip);
800
Steven Whitehouse320dd102006-05-18 16:25:27 -0400801fail_quota_locks:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000802 gfs2_quota_unlock(dip);
803
Steven Whitehouse320dd102006-05-18 16:25:27 -0400804fail:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000805 gfs2_alloc_put(dip);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000806 return error;
807}
808
809/**
810 * gfs2_createi - Create a new inode
811 * @ghs: An array of two holders
812 * @name: The name of the new file
813 * @mode: the permissions on the new inode
814 *
815 * @ghs[0] is an initialized holder for the directory
816 * @ghs[1] is the holder for the inode lock
817 *
Steven Whitehouse7359a192006-02-13 12:27:43 +0000818 * If the return value is not NULL, the glocks on both the directory and the new
David Teiglandb3b94fa2006-01-16 16:50:04 +0000819 * file are held. A transaction has been started and an inplace reservation
820 * is held, as well.
821 *
Steven Whitehouse7359a192006-02-13 12:27:43 +0000822 * Returns: An inode
David Teiglandb3b94fa2006-01-16 16:50:04 +0000823 */
824
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400825struct inode *gfs2_createi(struct gfs2_holder *ghs, const struct qstr *name,
Steven Whitehouse568f4c92006-02-27 12:00:42 -0500826 unsigned int mode)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000827{
Steven Whitehouse7359a192006-02-13 12:27:43 +0000828 struct inode *inode;
Steven Whitehouse5c676f62006-02-27 17:23:27 -0500829 struct gfs2_inode *dip = ghs->gh_gl->gl_object;
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400830 struct inode *dir = &dip->i_inode;
831 struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
832 struct gfs2_inum inum;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000833 int error;
Steven Whitehouse4340fe62006-07-11 09:46:33 -0400834 u64 generation;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000835
836 if (!name->len || name->len > GFS2_FNAMESIZE)
Steven Whitehouse7359a192006-02-13 12:27:43 +0000837 return ERR_PTR(-ENAMETOOLONG);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000838
David Teiglandb3b94fa2006-01-16 16:50:04 +0000839 gfs2_holder_reinit(LM_ST_EXCLUSIVE, 0, ghs);
840 error = gfs2_glock_nq(ghs);
841 if (error)
842 goto fail;
843
844 error = create_ok(dip, name, mode);
845 if (error)
846 goto fail_gunlock;
847
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400848 error = pick_formal_ino(sdp, &inum.no_formal_ino);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000849 if (error)
850 goto fail_gunlock;
851
Steven Whitehouse4340fe62006-07-11 09:46:33 -0400852 error = alloc_dinode(dip, &inum, &generation);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000853 if (error)
854 goto fail_gunlock;
855
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400856 if (inum.no_addr < dip->i_num.no_addr) {
David Teiglandb3b94fa2006-01-16 16:50:04 +0000857 gfs2_glock_dq(ghs);
858
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400859 error = gfs2_glock_nq_num(sdp, inum.no_addr,
Steven Whitehouse320dd102006-05-18 16:25:27 -0400860 &gfs2_inode_glops, LM_ST_EXCLUSIVE,
861 GL_SKIP, ghs + 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000862 if (error) {
Steven Whitehouse7359a192006-02-13 12:27:43 +0000863 return ERR_PTR(error);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000864 }
865
866 gfs2_holder_reinit(LM_ST_EXCLUSIVE, 0, ghs);
867 error = gfs2_glock_nq(ghs);
868 if (error) {
869 gfs2_glock_dq_uninit(ghs + 1);
Steven Whitehouse7359a192006-02-13 12:27:43 +0000870 return ERR_PTR(error);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000871 }
872
873 error = create_ok(dip, name, mode);
874 if (error)
875 goto fail_gunlock2;
876 } else {
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400877 error = gfs2_glock_nq_num(sdp, inum.no_addr,
Steven Whitehouse320dd102006-05-18 16:25:27 -0400878 &gfs2_inode_glops, LM_ST_EXCLUSIVE,
879 GL_SKIP, ghs + 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000880 if (error)
881 goto fail_gunlock;
882 }
883
Steven Whitehouse4340fe62006-07-11 09:46:33 -0400884 error = make_dinode(dip, ghs[1].gh_gl, mode, &inum, &generation);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000885 if (error)
886 goto fail_gunlock2;
887
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400888 inode = gfs2_inode_lookup(dir->i_sb, &inum, IF2DT(mode));
889 if (IS_ERR(inode))
David Teiglandb3b94fa2006-01-16 16:50:04 +0000890 goto fail_gunlock2;
891
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400892 error = gfs2_inode_refresh(GFS2_I(inode));
David Teiglandb3b94fa2006-01-16 16:50:04 +0000893 if (error)
894 goto fail_iput;
895
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400896 error = gfs2_acl_create(dip, GFS2_I(inode));
David Teiglandb3b94fa2006-01-16 16:50:04 +0000897 if (error)
898 goto fail_iput;
899
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400900 error = link_dinode(dip, name, GFS2_I(inode));
David Teiglandb3b94fa2006-01-16 16:50:04 +0000901 if (error)
902 goto fail_iput;
903
Steven Whitehouse7359a192006-02-13 12:27:43 +0000904 if (!inode)
905 return ERR_PTR(-ENOMEM);
906 return inode;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000907
Steven Whitehouse320dd102006-05-18 16:25:27 -0400908fail_iput:
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400909 iput(inode);
Steven Whitehouse320dd102006-05-18 16:25:27 -0400910fail_gunlock2:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000911 gfs2_glock_dq_uninit(ghs + 1);
Steven Whitehouse320dd102006-05-18 16:25:27 -0400912fail_gunlock:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000913 gfs2_glock_dq(ghs);
Steven Whitehouse320dd102006-05-18 16:25:27 -0400914fail:
Steven Whitehouse7359a192006-02-13 12:27:43 +0000915 return ERR_PTR(error);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000916}
917
918/**
David Teiglandb3b94fa2006-01-16 16:50:04 +0000919 * gfs2_rmdiri - Remove a directory
920 * @dip: The parent directory of the directory to be removed
921 * @name: The name of the directory to be removed
922 * @ip: The GFS2 inode of the directory to be removed
923 *
924 * Assumes Glocks on dip and ip are held
925 *
926 * Returns: errno
927 */
928
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400929int gfs2_rmdiri(struct gfs2_inode *dip, const struct qstr *name,
930 struct gfs2_inode *ip)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000931{
David Teiglandb3b94fa2006-01-16 16:50:04 +0000932 struct qstr dotname;
933 int error;
934
935 if (ip->i_di.di_entries != 2) {
936 if (gfs2_consist_inode(ip))
937 gfs2_dinode_print(&ip->i_di);
938 return -EIO;
939 }
940
941 error = gfs2_dir_del(dip, name);
942 if (error)
943 return error;
944
945 error = gfs2_change_nlink(dip, -1);
946 if (error)
947 return error;
948
Steven Whitehouse71b86f52006-03-28 14:14:04 -0500949 gfs2_str2qstr(&dotname, ".");
David Teiglandb3b94fa2006-01-16 16:50:04 +0000950 error = gfs2_dir_del(ip, &dotname);
951 if (error)
952 return error;
953
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400954 gfs2_str2qstr(&dotname, "..");
David Teiglandb3b94fa2006-01-16 16:50:04 +0000955 error = gfs2_dir_del(ip, &dotname);
956 if (error)
957 return error;
958
959 error = gfs2_change_nlink(ip, -2);
960 if (error)
961 return error;
962
David Teiglandb3b94fa2006-01-16 16:50:04 +0000963 return error;
964}
965
966/*
967 * gfs2_unlink_ok - check to see that a inode is still in a directory
968 * @dip: the directory
969 * @name: the name of the file
970 * @ip: the inode
971 *
972 * Assumes that the lock on (at least) @dip is held.
973 *
974 * Returns: 0 if the parent/child relationship is correct, errno if it isn't
975 */
976
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400977int gfs2_unlink_ok(struct gfs2_inode *dip, const struct qstr *name,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000978 struct gfs2_inode *ip)
979{
980 struct gfs2_inum inum;
981 unsigned int type;
982 int error;
983
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400984 if (IS_IMMUTABLE(&ip->i_inode) || IS_APPEND(&ip->i_inode))
David Teiglandb3b94fa2006-01-16 16:50:04 +0000985 return -EPERM;
986
987 if ((dip->i_di.di_mode & S_ISVTX) &&
988 dip->i_di.di_uid != current->fsuid &&
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400989 ip->i_di.di_uid != current->fsuid && !capable(CAP_FOWNER))
David Teiglandb3b94fa2006-01-16 16:50:04 +0000990 return -EPERM;
991
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400992 if (IS_APPEND(&dip->i_inode))
David Teiglandb3b94fa2006-01-16 16:50:04 +0000993 return -EPERM;
994
Steven Whitehousefaf450e2006-06-22 10:59:10 -0400995 error = permission(&dip->i_inode, MAY_WRITE | MAY_EXEC, NULL);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000996 if (error)
997 return error;
998
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400999 error = gfs2_dir_search(&dip->i_inode, name, &inum, &type);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001000 if (error)
1001 return error;
1002
1003 if (!gfs2_inum_equal(&inum, &ip->i_num))
1004 return -ENOENT;
1005
1006 if (IF2DT(ip->i_di.di_mode) != type) {
1007 gfs2_consist_inode(dip);
1008 return -EIO;
1009 }
1010
1011 return 0;
1012}
1013
1014/*
1015 * gfs2_ok_to_move - check if it's ok to move a directory to another directory
1016 * @this: move this
1017 * @to: to here
1018 *
1019 * Follow @to back to the root and make sure we don't encounter @this
1020 * Assumes we already hold the rename lock.
1021 *
1022 * Returns: errno
1023 */
1024
1025int gfs2_ok_to_move(struct gfs2_inode *this, struct gfs2_inode *to)
1026{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001027 struct inode *dir = &to->i_inode;
Steven Whitehousec9fd4302006-03-01 15:31:02 -05001028 struct super_block *sb = dir->i_sb;
Steven Whitehouse7359a192006-02-13 12:27:43 +00001029 struct inode *tmp;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001030 struct qstr dotdot;
1031 int error = 0;
1032
Steven Whitehouse71b86f52006-03-28 14:14:04 -05001033 gfs2_str2qstr(&dotdot, "..");
David Teiglandb3b94fa2006-01-16 16:50:04 +00001034
Steven Whitehouse7359a192006-02-13 12:27:43 +00001035 igrab(dir);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001036
1037 for (;;) {
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001038 if (dir == &this->i_inode) {
David Teiglandb3b94fa2006-01-16 16:50:04 +00001039 error = -EINVAL;
1040 break;
1041 }
Steven Whitehousec9fd4302006-03-01 15:31:02 -05001042 if (dir == sb->s_root->d_inode) {
David Teiglandb3b94fa2006-01-16 16:50:04 +00001043 error = 0;
1044 break;
1045 }
1046
Steven Whitehousec7526662006-03-20 12:30:04 -05001047 tmp = gfs2_lookupi(dir, &dotdot, 1, NULL);
1048 if (IS_ERR(tmp)) {
1049 error = PTR_ERR(tmp);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001050 break;
Steven Whitehousec7526662006-03-20 12:30:04 -05001051 }
David Teiglandb3b94fa2006-01-16 16:50:04 +00001052
Steven Whitehouse7359a192006-02-13 12:27:43 +00001053 iput(dir);
1054 dir = tmp;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001055 }
1056
Steven Whitehouse7359a192006-02-13 12:27:43 +00001057 iput(dir);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001058
1059 return error;
1060}
1061
1062/**
1063 * gfs2_readlinki - return the contents of a symlink
1064 * @ip: the symlink's inode
1065 * @buf: a pointer to the buffer to be filled
1066 * @len: a pointer to the length of @buf
1067 *
1068 * If @buf is too small, a piece of memory is kmalloc()ed and needs
1069 * to be freed by the caller.
1070 *
1071 * Returns: errno
1072 */
1073
1074int gfs2_readlinki(struct gfs2_inode *ip, char **buf, unsigned int *len)
1075{
1076 struct gfs2_holder i_gh;
1077 struct buffer_head *dibh;
1078 unsigned int x;
1079 int error;
1080
1081 gfs2_holder_init(ip->i_gl, LM_ST_SHARED, GL_ATIME, &i_gh);
1082 error = gfs2_glock_nq_atime(&i_gh);
1083 if (error) {
1084 gfs2_holder_uninit(&i_gh);
1085 return error;
1086 }
1087
1088 if (!ip->i_di.di_size) {
1089 gfs2_consist_inode(ip);
1090 error = -EIO;
1091 goto out;
1092 }
1093
1094 error = gfs2_meta_inode_buffer(ip, &dibh);
1095 if (error)
1096 goto out;
1097
1098 x = ip->i_di.di_size + 1;
1099 if (x > *len) {
1100 *buf = kmalloc(x, GFP_KERNEL);
1101 if (!*buf) {
1102 error = -ENOMEM;
1103 goto out_brelse;
1104 }
1105 }
1106
1107 memcpy(*buf, dibh->b_data + sizeof(struct gfs2_dinode), x);
1108 *len = x;
1109
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001110out_brelse:
David Teiglandb3b94fa2006-01-16 16:50:04 +00001111 brelse(dibh);
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001112out:
David Teiglandb3b94fa2006-01-16 16:50:04 +00001113 gfs2_glock_dq_uninit(&i_gh);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001114 return error;
1115}
1116
1117/**
1118 * gfs2_glock_nq_atime - Acquire a hold on an inode's glock, and
1119 * conditionally update the inode's atime
1120 * @gh: the holder to acquire
1121 *
1122 * Tests atime (access time) for gfs2_read, gfs2_readdir and gfs2_mmap
1123 * Update if the difference between the current time and the inode's current
1124 * atime is greater than an interval specified at mount.
1125 *
1126 * Returns: errno
1127 */
1128
1129int gfs2_glock_nq_atime(struct gfs2_holder *gh)
1130{
1131 struct gfs2_glock *gl = gh->gh_gl;
1132 struct gfs2_sbd *sdp = gl->gl_sbd;
Steven Whitehouse5c676f62006-02-27 17:23:27 -05001133 struct gfs2_inode *ip = gl->gl_object;
Steven Whitehousecd915492006-09-04 12:49:07 -04001134 s64 curtime, quantum = gfs2_tune_get(sdp, gt_atime_quantum);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001135 unsigned int state;
1136 int flags;
1137 int error;
1138
1139 if (gfs2_assert_warn(sdp, gh->gh_flags & GL_ATIME) ||
1140 gfs2_assert_warn(sdp, !(gh->gh_flags & GL_ASYNC)) ||
1141 gfs2_assert_warn(sdp, gl->gl_ops == &gfs2_inode_glops))
1142 return -EINVAL;
1143
1144 state = gh->gh_state;
1145 flags = gh->gh_flags;
1146
1147 error = gfs2_glock_nq(gh);
1148 if (error)
1149 return error;
1150
1151 if (test_bit(SDF_NOATIME, &sdp->sd_flags) ||
1152 (sdp->sd_vfs->s_flags & MS_RDONLY))
1153 return 0;
1154
1155 curtime = get_seconds();
1156 if (curtime - ip->i_di.di_atime >= quantum) {
1157 gfs2_glock_dq(gh);
Steven Whitehousefd88de562006-05-05 16:59:11 -04001158 gfs2_holder_reinit(LM_ST_EXCLUSIVE, gh->gh_flags & ~LM_FLAG_ANY,
1159 gh);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001160 error = gfs2_glock_nq(gh);
1161 if (error)
1162 return error;
1163
1164 /* Verify that atime hasn't been updated while we were
1165 trying to get exclusive lock. */
1166
1167 curtime = get_seconds();
1168 if (curtime - ip->i_di.di_atime >= quantum) {
1169 struct buffer_head *dibh;
Steven Whitehouse48516ce2006-10-02 12:39:19 -04001170 struct gfs2_dinode *di;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001171
1172 error = gfs2_trans_begin(sdp, RES_DINODE, 0);
1173 if (error == -EROFS)
1174 return 0;
1175 if (error)
1176 goto fail;
1177
1178 error = gfs2_meta_inode_buffer(ip, &dibh);
1179 if (error)
1180 goto fail_end_trans;
1181
1182 ip->i_di.di_atime = curtime;
1183
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +00001184 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
Steven Whitehouse48516ce2006-10-02 12:39:19 -04001185 di = (struct gfs2_dinode *)dibh->b_data;
1186 di->di_atime = cpu_to_be64(ip->i_di.di_atime);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001187 brelse(dibh);
1188
1189 gfs2_trans_end(sdp);
1190 }
1191
1192 /* If someone else has asked for the glock,
1193 unlock and let them have it. Then reacquire
1194 in the original state. */
1195 if (gfs2_glock_is_blocking(gl)) {
1196 gfs2_glock_dq(gh);
1197 gfs2_holder_reinit(state, flags, gh);
1198 return gfs2_glock_nq(gh);
1199 }
1200 }
1201
1202 return 0;
1203
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001204fail_end_trans:
David Teiglandb3b94fa2006-01-16 16:50:04 +00001205 gfs2_trans_end(sdp);
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001206fail:
David Teiglandb3b94fa2006-01-16 16:50:04 +00001207 gfs2_glock_dq(gh);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001208 return error;
1209}
1210
1211/**
1212 * glock_compare_atime - Compare two struct gfs2_glock structures for sort
1213 * @arg_a: the first structure
1214 * @arg_b: the second structure
1215 *
1216 * Returns: 1 if A > B
1217 * -1 if A < B
Steven Whitehouse75d3b812006-09-04 11:41:31 -04001218 * 0 if A == B
David Teiglandb3b94fa2006-01-16 16:50:04 +00001219 */
1220
1221static int glock_compare_atime(const void *arg_a, const void *arg_b)
1222{
Steven Whitehouse75d3b812006-09-04 11:41:31 -04001223 const struct gfs2_holder *gh_a = *(const struct gfs2_holder **)arg_a;
1224 const struct gfs2_holder *gh_b = *(const struct gfs2_holder **)arg_b;
1225 const struct lm_lockname *a = &gh_a->gh_gl->gl_name;
1226 const struct lm_lockname *b = &gh_b->gh_gl->gl_name;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001227
1228 if (a->ln_number > b->ln_number)
Steven Whitehouse75d3b812006-09-04 11:41:31 -04001229 return 1;
1230 if (a->ln_number < b->ln_number)
1231 return -1;
1232 if (gh_a->gh_state == LM_ST_SHARED && gh_b->gh_state == LM_ST_EXCLUSIVE)
1233 return 1;
1234 if (gh_a->gh_state == LM_ST_SHARED && (gh_b->gh_flags & GL_ATIME))
1235 return 1;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001236
Steven Whitehouse75d3b812006-09-04 11:41:31 -04001237 return 0;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001238}
1239
1240/**
1241 * gfs2_glock_nq_m_atime - acquire multiple glocks where one may need an
1242 * atime update
1243 * @num_gh: the number of structures
1244 * @ghs: an array of struct gfs2_holder structures
1245 *
1246 * Returns: 0 on success (all glocks acquired),
1247 * errno on failure (no glocks acquired)
1248 */
1249
1250int gfs2_glock_nq_m_atime(unsigned int num_gh, struct gfs2_holder *ghs)
1251{
1252 struct gfs2_holder **p;
1253 unsigned int x;
1254 int error = 0;
1255
1256 if (!num_gh)
1257 return 0;
1258
1259 if (num_gh == 1) {
1260 ghs->gh_flags &= ~(LM_FLAG_TRY | GL_ASYNC);
1261 if (ghs->gh_flags & GL_ATIME)
1262 error = gfs2_glock_nq_atime(ghs);
1263 else
1264 error = gfs2_glock_nq(ghs);
1265 return error;
1266 }
1267
1268 p = kcalloc(num_gh, sizeof(struct gfs2_holder *), GFP_KERNEL);
1269 if (!p)
1270 return -ENOMEM;
1271
1272 for (x = 0; x < num_gh; x++)
1273 p[x] = &ghs[x];
1274
1275 sort(p, num_gh, sizeof(struct gfs2_holder *), glock_compare_atime,NULL);
1276
1277 for (x = 0; x < num_gh; x++) {
1278 p[x]->gh_flags &= ~(LM_FLAG_TRY | GL_ASYNC);
1279
1280 if (p[x]->gh_flags & GL_ATIME)
1281 error = gfs2_glock_nq_atime(p[x]);
1282 else
1283 error = gfs2_glock_nq(p[x]);
1284
1285 if (error) {
1286 while (x--)
1287 gfs2_glock_dq(p[x]);
1288 break;
1289 }
1290 }
1291
1292 kfree(p);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001293 return error;
1294}
1295
David Teiglandb3b94fa2006-01-16 16:50:04 +00001296
1297static int
1298__gfs2_setattr_simple(struct gfs2_inode *ip, struct iattr *attr)
1299{
1300 struct buffer_head *dibh;
1301 int error;
1302
1303 error = gfs2_meta_inode_buffer(ip, &dibh);
1304 if (!error) {
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001305 error = inode_setattr(&ip->i_inode, attr);
1306 gfs2_assert_warn(GFS2_SB(&ip->i_inode), !error);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001307 gfs2_inode_attr_out(ip);
1308
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +00001309 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001310 gfs2_dinode_out(&ip->i_di, dibh->b_data);
1311 brelse(dibh);
1312 }
1313 return error;
1314}
1315
1316/**
1317 * gfs2_setattr_simple -
1318 * @ip:
1319 * @attr:
1320 *
1321 * Called with a reference on the vnode.
1322 *
1323 * Returns: errno
1324 */
1325
1326int gfs2_setattr_simple(struct gfs2_inode *ip, struct iattr *attr)
1327{
1328 int error;
1329
Steven Whitehouse5c676f62006-02-27 17:23:27 -05001330 if (current->journal_info)
David Teiglandb3b94fa2006-01-16 16:50:04 +00001331 return __gfs2_setattr_simple(ip, attr);
1332
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001333 error = gfs2_trans_begin(GFS2_SB(&ip->i_inode), RES_DINODE, 0);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001334 if (error)
1335 return error;
1336
1337 error = __gfs2_setattr_simple(ip, attr);
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001338 gfs2_trans_end(GFS2_SB(&ip->i_inode));
David Teiglandb3b94fa2006-01-16 16:50:04 +00001339 return error;
1340}
1341