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