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