?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge with Linux 2.5.48.
[linux-2.6/linux-mips.git] / fs / xfs / linux / xfs_iops.c
blobb9bb91a68660503ed4517ec969ac07fa162442d0
1 /*
2 * Copyright (c) 2000-2002 Silicon Graphics, Inc. All Rights Reserved.
3 *
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms of version 2 of the GNU General Public License as
6 * published by the Free Software Foundation.
7 *
8 * This program is distributed in the hope that it would be useful, but
9 * WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
11 *
12 * Further, this software is distributed without any warranty that it is
13 * free of the rightful claim of any third person regarding infringement
14 * or the like. Any license provided herein, whether implied or
15 * otherwise, applies only to this software file. Patent licenses, if
16 * any, provided herein do not apply to combinations of this program with
17 * other software, or any other product whatsoever.
18 *
19 * You should have received a copy of the GNU General Public License along
20 * with this program; if not, write the Free Software Foundation, Inc., 59
21 * Temple Place - Suite 330, Boston MA 02111-1307, USA.
22 *
23 * Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
24 * Mountain View, CA 94043, or:
25 *
26 * http://www.sgi.com
27 *
28 * For further information regarding this notice, see:
29 *
30 * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
31 */
32
33 #include <xfs.h>
34 #include <linux/xattr.h>
35
36
37 /*
38 * Pull the link count and size up from the xfs inode to the linux inode
39 */
40 STATIC void
41 validate_fields(
42 struct inode *ip)
43 {
44 vnode_t *vp = LINVFS_GET_VP(ip);
45 vattr_t va;
46 int error;
47
48 va.va_mask = AT_NLINK|AT_SIZE;
49 VOP_GETATTR(vp, &va, ATTR_LAZY, NULL, error);
50 ip->i_nlink = va.va_nlink;
51 ip->i_size = va.va_size;
52 ip->i_blocks = va.va_nblocks;
53 }
54
55 /*
56 * Determine whether a process has a valid fs_struct (kernel daemons
57 * like knfsd don't have an fs_struct).
58 *
59 * XXX(hch): nfsd is broken, better fix it instead.
60 */
61 STATIC int inline
62 has_fs_struct(struct task_struct *task)
63 {
64 return (task->fs != init_task.fs);
65 }
66
67 STATIC int
68 linvfs_mknod(
69 struct inode *dir,
70 struct dentry *dentry,
71 int mode,
72 int rdev)
73 {
74 struct inode *ip;
75 vattr_t va;
76 vnode_t *vp = NULL, *dvp = LINVFS_GET_VP(dir);
77 xattr_exists_t test_default_acl = _ACL_DEFAULT_EXISTS;
78 int have_default_acl = 0;
79 int error = EINVAL;
80
81 if (test_default_acl)
82 have_default_acl = test_default_acl(dvp);
83
84 if (IS_POSIXACL(dir) && !have_default_acl && has_fs_struct(current))
85 mode &= ~current->fs->umask;
86
87 memset(&va, 0, sizeof(va));
88 va.va_mask = AT_TYPE|AT_MODE;
89 va.va_type = IFTOVT(mode);
90 va.va_mode = mode;
91
92 switch (mode & S_IFMT) {
93 case S_IFCHR: case S_IFBLK: case S_IFIFO: case S_IFSOCK:
94 va.va_rdev = XFS_MKDEV(MAJOR(rdev), MINOR(rdev));
95 va.va_mask |= AT_RDEV;
96 /*FALLTHROUGH*/
97 case S_IFREG:
98 VOP_CREATE(dvp, dentry, &va, &vp, NULL, error);
99 break;
100 case S_IFDIR:
101 VOP_MKDIR(dvp, dentry, &va, &vp, NULL, error);
102 break;
103 default:
104 error = EINVAL;
105 break;
106 }
107
108 if (!error) {
109 ASSERT(vp);
110 ip = LINVFS_GET_IP(vp);
111 if (!ip) {
112 VN_RELE(vp);
113 return -ENOMEM;
114 }
115
116 if (S_ISCHR(mode) || S_ISBLK(mode))
117 ip->i_rdev = to_kdev_t(rdev);
118 validate_fields(dir);
119 d_instantiate(dentry, ip);
120 mark_inode_dirty_sync(ip);
121 mark_inode_dirty_sync(dir);
122 }
123
124 if (!error && have_default_acl) {
125 _ACL_DECL (pdacl);
126
127 if (!_ACL_ALLOC(pdacl)) {
128 error = -ENOMEM;
129 } else {
130 if (_ACL_GET_DEFAULT(dvp, pdacl))
131 error = _ACL_INHERIT(vp, &va, pdacl);
132 VMODIFY(vp);
133 _ACL_FREE(pdacl);
134 }
135 }
136 return -error;
137 }
138
139 STATIC int
140 linvfs_create(
141 struct inode *dir,
142 struct dentry *dentry,
143 int mode)
144 {
145 return linvfs_mknod(dir, dentry, mode, 0);
146 }
147
148 STATIC int
149 linvfs_mkdir(
150 struct inode *dir,
151 struct dentry *dentry,
152 int mode)
153 {
154 return linvfs_mknod(dir, dentry, mode|S_IFDIR, 0);
155 }
156
157
158 STATIC struct dentry *
159 linvfs_lookup(
160 struct inode *dir,
161 struct dentry *dentry)
162 {
163 int error;
164 vnode_t *vp, *cvp;
165 struct inode *ip = NULL;
166
167 if (dentry->d_name.len >= MAXNAMELEN)
168 return ERR_PTR(-ENAMETOOLONG);
169
170 cvp = NULL;
171 vp = LINVFS_GET_VP(dir);
172 VOP_LOOKUP(vp, dentry, &cvp, 0, NULL, NULL, error);
173 if (!error) {
174 ASSERT(cvp);
175 ip = LINVFS_GET_IP(cvp);
176 if (!ip) {
177 VN_RELE(cvp);
178 return ERR_PTR(-EACCES);
179 }
180 }
181 if (error && (error != ENOENT))
182 return ERR_PTR(-error);
183 return d_splice_alias(ip, dentry);
184 }
185
186 STATIC int
187 linvfs_link(
188 struct dentry *old_dentry,
189 struct inode *dir,
190 struct dentry *dentry)
191 {
192 int error;
193 vnode_t *tdvp; /* Target directory for new name/link */
194 vnode_t *vp; /* vp of name being linked */
195 struct inode *ip; /* inode of guy being linked to */
196
197 ip = old_dentry->d_inode; /* inode being linked to */
198 if (S_ISDIR(ip->i_mode))
199 return -EPERM;
200
201 tdvp = LINVFS_GET_VP(dir);
202 vp = LINVFS_GET_VP(ip);
203
204 error = 0;
205 VOP_LINK(tdvp, vp, dentry, NULL, error);
206 if (!error) {
207 VMODIFY(tdvp);
208 VN_HOLD(vp);
209 validate_fields(ip);
210 d_instantiate(dentry, ip);
211 mark_inode_dirty_sync(ip);
212 }
213 return -error;
214 }
215
216 STATIC int
217 linvfs_unlink(
218 struct inode *dir,
219 struct dentry *dentry)
220 {
221 int error = 0;
222 struct inode *inode;
223 vnode_t *dvp; /* directory containing name to remove */
224
225 inode = dentry->d_inode;
226
227 dvp = LINVFS_GET_VP(dir);
228
229 VOP_REMOVE(dvp, dentry, NULL, error);
230
231 if (!error) {
232 validate_fields(dir); /* For size only */
233 validate_fields(inode);
234 mark_inode_dirty_sync(inode);
235 mark_inode_dirty_sync(dir);
236 }
237
238 return -error;
239 }
240
241 STATIC int
242 linvfs_symlink(
243 struct inode *dir,
244 struct dentry *dentry,
245 const char *symname)
246 {
247 int error;
248 vnode_t *dvp; /* directory containing name to remove */
249 vnode_t *cvp; /* used to lookup symlink to put in dentry */
250 vattr_t va;
251 struct inode *ip = NULL;
252
253 dvp = LINVFS_GET_VP(dir);
254
255 memset(&va, 0, sizeof(va));
256 va.va_type = VLNK;
257 va.va_mode = irix_symlink_mode ? 0777 & ~current->fs->umask : S_IRWXUGO;
258 va.va_mask = AT_TYPE|AT_MODE;
259
260 error = 0;
261 VOP_SYMLINK(dvp, dentry, &va, (char *)symname, &cvp, NULL, error);
262 if (!error) {
263 ASSERT(cvp);
264 ASSERT(cvp->v_type == VLNK);
265 ip = LINVFS_GET_IP(cvp);
266 if (!ip) {
267 error = ENOMEM;
268 VN_RELE(cvp);
269 } else {
270 d_instantiate(dentry, ip);
271 validate_fields(dir);
272 validate_fields(ip); /* size needs update */
273 mark_inode_dirty_sync(ip);
274 mark_inode_dirty_sync(dir);
275 }
276 }
277 return -error;
278 }
279
280 STATIC int
281 linvfs_rmdir(
282 struct inode *dir,
283 struct dentry *dentry)
284 {
285 struct inode *inode = dentry->d_inode;
286 vnode_t *dvp = LINVFS_GET_VP(dir);
287 int error;
288
289 VOP_RMDIR(dvp, dentry, NULL, error);
290 if (!error) {
291 validate_fields(inode);
292 validate_fields(dir);
293 mark_inode_dirty_sync(inode);
294 mark_inode_dirty_sync(dir);
295 }
296 return -error;
297 }
298
299 STATIC int
300 linvfs_rename(
301 struct inode *odir,
302 struct dentry *odentry,
303 struct inode *ndir,
304 struct dentry *ndentry)
305 {
306 int error;
307 vnode_t *fvp; /* from directory */
308 vnode_t *tvp; /* target directory */
309 struct inode *new_inode = NULL;
310
311 fvp = LINVFS_GET_VP(odir);
312 tvp = LINVFS_GET_VP(ndir);
313
314 new_inode = ndentry->d_inode;
315
316 VOP_RENAME(fvp, odentry, tvp, ndentry, NULL, error);
317 if (error)
318 return -error;
319
320 if (new_inode) {
321 validate_fields(new_inode);
322 }
323
324 validate_fields(odir);
325 if (ndir != odir)
326 validate_fields(ndir);
327 mark_inode_dirty(ndir);
328 return 0;
329 }
330
331 STATIC int
332 linvfs_readlink(
333 struct dentry *dentry,
334 char *buf,
335 int size)
336 {
337 vnode_t *vp;
338 uio_t uio;
339 iovec_t iov;
340 int error;
341
342 vp = LINVFS_GET_VP(dentry->d_inode);
343
344 iov.iov_base = buf;
345 iov.iov_len = size;
346
347 uio.uio_iov = &iov;
348 uio.uio_offset = 0;
349 uio.uio_segflg = UIO_USERSPACE;
350 uio.uio_resid = size;
351
352 VOP_READLINK(vp, &uio, NULL, error);
353 if (error)
354 return -error;
355
356 return (size - uio.uio_resid);
357 }
358
359 /*
360 * careful here - this function can get called recursively, so
361 * we need to be very careful about how much stack we use.
362 * uio is kmalloced for this reason...
363 */
364 STATIC int
365 linvfs_follow_link(
366 struct dentry *dentry,
367 struct nameidata *nd)
368 {
369 vnode_t *vp;
370 uio_t *uio;
371 iovec_t iov;
372 int error;
373 char *link;
374
375 ASSERT(dentry);
376 ASSERT(nd);
377
378 link = (char *)kmalloc(MAXNAMELEN+1, GFP_KERNEL);
379 if (!link)
380 return -ENOMEM;
381
382 uio = (uio_t *)kmalloc(sizeof(uio_t), GFP_KERNEL);
383 if (!uio) {
384 kfree(link);
385 return -ENOMEM;
386 }
387
388 vp = LINVFS_GET_VP(dentry->d_inode);
389
390 iov.iov_base = link;
391 iov.iov_len = MAXNAMELEN;
392
393 uio->uio_iov = &iov;
394 uio->uio_offset = 0;
395 uio->uio_segflg = UIO_SYSSPACE;
396 uio->uio_resid = MAXNAMELEN;
397 uio->uio_fmode = 0;
398
399 VOP_READLINK(vp, uio, NULL, error);
400 if (error) {
401 kfree(uio);
402 kfree(link);
403 return -error;
404 }
405
406 link[MAXNAMELEN - uio->uio_resid] = '\0';
407 kfree(uio);
408
409 /* vfs_follow_link returns (-) errors */
410 error = vfs_follow_link(nd, link);
411 kfree(link);
412 return error;
413 }
414
415 STATIC int
416 linvfs_permission(
417 struct inode *inode,
418 int mode)
419 {
420 vnode_t *vp = LINVFS_GET_VP(inode);
421 int error;
422
423 mode <<= 6; /* convert from linux to vnode access bits */
424 VOP_ACCESS(vp, mode, NULL, error);
425 return -error;
426 }
427
428 /* Brute force approach for now - copy data into linux inode
429 * from the results of a getattr. This gets called out of things
430 * like stat.
431 */
432
433 STATIC int
434 linvfs_getattr(
435 struct vfsmount *mnt,
436 struct dentry *dentry,
437 struct kstat *stat)
438 {
439 struct inode *inode = dentry->d_inode;
440 vnode_t *vp = LINVFS_GET_VP(inode);
441 int error = 0;
442
443 if (unlikely(vp->v_flag & VMODIFIED)) {
444 error = vn_revalidate(vp);
445 }
446 if (!error)
447 generic_fillattr(inode, stat);
448 return 0;
449 }
450
451 STATIC int
452 linvfs_setattr(
453 struct dentry *dentry,
454 struct iattr *attr)
455 {
456 struct inode *inode = dentry->d_inode;
457 vnode_t *vp = LINVFS_GET_VP(inode);
458 vattr_t vattr;
459 unsigned int ia_valid = attr->ia_valid;
460 int error;
461 int flags = 0;
462
463 memset(&vattr, 0, sizeof(vattr_t));
464 if (ia_valid & ATTR_UID) {
465 vattr.va_mask |= AT_UID;
466 vattr.va_uid = attr->ia_uid;
467 }
468 if (ia_valid & ATTR_GID) {
469 vattr.va_mask |= AT_GID;
470 vattr.va_gid = attr->ia_gid;
471 }
472 if (ia_valid & ATTR_SIZE) {
473 vattr.va_mask |= AT_SIZE;
474 vattr.va_size = attr->ia_size;
475 }
476 if (ia_valid & ATTR_ATIME) {
477 vattr.va_mask |= AT_ATIME;
478 vattr.va_atime = attr->ia_atime;
479 }
480 if (ia_valid & ATTR_MTIME) {
481 vattr.va_mask |= AT_MTIME;
482 vattr.va_mtime = attr->ia_mtime;
483 }
484 if (ia_valid & ATTR_CTIME) {
485 vattr.va_mask |= AT_CTIME;
486 vattr.va_ctime = attr->ia_ctime;
487 }
488 if (ia_valid & ATTR_MODE) {
489 vattr.va_mask |= AT_MODE;
490 vattr.va_mode = attr->ia_mode;
491 if (!in_group_p(inode->i_gid) && !capable(CAP_FSETID))
492 inode->i_mode &= ~S_ISGID;
493 }
494
495 if (ia_valid & (ATTR_MTIME_SET | ATTR_ATIME_SET))
496 flags = ATTR_UTIME;
497
498 VOP_SETATTR(vp, &vattr, flags, NULL, error);
499 if (error)
500 return(-error); /* Positive error up from XFS */
501 if (ia_valid & ATTR_SIZE) {
502 error = vmtruncate(inode, attr->ia_size);
503 }
504
505 if (!error) {
506 vn_revalidate(vp);
507 mark_inode_dirty_sync(inode);
508 }
509 return error;
510 }
511
512 STATIC void
513 linvfs_truncate(
514 struct inode *inode)
515 {
516 block_truncate_page(inode->i_mapping, inode->i_size, linvfs_get_block);
517 }
518
519
520
521 /*
522 * Extended attributes interfaces
523 */
524
525 #define SYSTEM_NAME "system." /* VFS shared names/values */
526 #define ROOT_NAME "xfsroot." /* XFS ondisk names/values */
527 #define USER_NAME "user." /* user's own names/values */
528 STATIC xattr_namespace_t xfs_namespace_array[] = {
529 { .name= SYSTEM_NAME, .namelen= sizeof(SYSTEM_NAME)-1,.exists= NULL },
530 { .name= ROOT_NAME, .namelen= sizeof(ROOT_NAME)-1, .exists= NULL },
531 { .name= USER_NAME, .namelen= sizeof(USER_NAME)-1, .exists= NULL },
532 { .name= NULL }
533 };
534 xattr_namespace_t *xfs_namespaces = &xfs_namespace_array[0];
535
536 #define POSIXACL_ACCESS "posix_acl_access"
537 #define POSIXACL_ACCESS_SIZE (sizeof(POSIXACL_ACCESS)-1)
538 #define POSIXACL_DEFAULT "posix_acl_default"
539 #define POSIXACL_DEFAULT_SIZE (sizeof(POSIXACL_DEFAULT)-1)
540 #define POSIXCAP "posix_capabilities"
541 #define POSIXCAP_SIZE (sizeof(POSIXCAP)-1)
542 #define POSIXMAC "posix_mac"
543 #define POSIXMAC_SIZE (sizeof(POSIXMAC)-1)
544 STATIC xattr_namespace_t sys_namespace_array[] = {
545 { .name= POSIXACL_ACCESS,
546 .namelen= POSIXACL_ACCESS_SIZE, .exists= _ACL_ACCESS_EXISTS },
547 { .name= POSIXACL_DEFAULT,
548 .namelen= POSIXACL_DEFAULT_SIZE, .exists= _ACL_DEFAULT_EXISTS },
549 { .name= POSIXCAP,
550 .namelen= POSIXCAP_SIZE, .exists= _CAP_EXISTS },
551 { .name= POSIXMAC,
552 .namelen= POSIXMAC_SIZE, .exists= _MAC_EXISTS },
553 { .name= NULL }
554 };
555
556 /*
557 * Some checks to prevent people abusing EAs to get over quota:
558 * - Don't allow modifying user EAs on devices/symlinks;
559 * - Don't allow modifying user EAs if sticky bit set;
560 */
561 STATIC int
562 capable_user_xattr(
563 struct inode *inode)
564 {
565 if (!S_ISREG(inode->i_mode) && !S_ISDIR(inode->i_mode) &&
566 !capable(CAP_SYS_ADMIN))
567 return 0;
568 if (S_ISDIR(inode->i_mode) && (inode->i_mode & S_ISVTX) &&
569 (current->fsuid != inode->i_uid) && !capable(CAP_FOWNER))
570 return 0;
571 return 1;
572 }
573
574 STATIC int
575 linvfs_setxattr(
576 struct dentry *dentry,
577 const char *name,
578 void *data,
579 size_t size,
580 int flags)
581 {
582 int error;
583 int xflags = 0;
584 char *p = (char *)name;
585 struct inode *inode = dentry->d_inode;
586 vnode_t *vp = LINVFS_GET_VP(inode);
587
588 if (strncmp(name, xfs_namespaces[SYSTEM_NAMES].name,
589 xfs_namespaces[SYSTEM_NAMES].namelen) == 0) {
590 error = -EINVAL;
591 if (flags & XATTR_CREATE)
592 return error;
593 error = -ENOATTR;
594 p += xfs_namespaces[SYSTEM_NAMES].namelen;
595 if (strcmp(p, POSIXACL_ACCESS) == 0) {
596 error = xfs_acl_vset(vp, data, size, _ACL_TYPE_ACCESS);
597 }
598 else if (strcmp(p, POSIXACL_DEFAULT) == 0) {
599 error = xfs_acl_vset(vp, data, size, _ACL_TYPE_DEFAULT);
600 }
601 else if (strcmp(p, POSIXCAP) == 0) {
602 error = xfs_cap_vset(vp, data, size);
603 }
604 if (!error) {
605 error = vn_revalidate(vp);
606 }
607 return error;
608 }
609
610 /* Convert Linux syscall to XFS internal ATTR flags */
611 if (flags & XATTR_CREATE)
612 xflags |= ATTR_CREATE;
613 if (flags & XATTR_REPLACE)
614 xflags |= ATTR_REPLACE;
615
616 if (strncmp(name, xfs_namespaces[ROOT_NAMES].name,
617 xfs_namespaces[ROOT_NAMES].namelen) == 0) {
618 if (!capable(CAP_SYS_ADMIN))
619 return -EPERM;
620 xflags |= ATTR_ROOT;
621 p += xfs_namespaces[ROOT_NAMES].namelen;
622 VOP_ATTR_SET(vp, p, data, size, xflags, NULL, error);
623 return -error;
624 }
625 if (strncmp(name, xfs_namespaces[USER_NAMES].name,
626 xfs_namespaces[USER_NAMES].namelen) == 0) {
627 if (!capable_user_xattr(inode))
628 return -EPERM;
629 p += xfs_namespaces[USER_NAMES].namelen;
630 VOP_ATTR_SET(vp, p, data, size, xflags, NULL, error);
631 return -error;
632 }
633 return -ENOATTR;
634 }
635
636 STATIC ssize_t
637 linvfs_getxattr(
638 struct dentry *dentry,
639 const char *name,
640 void *data,
641 size_t size)
642 {
643 ssize_t error;
644 int xflags = 0;
645 char *p = (char *)name;
646 struct inode *inode = dentry->d_inode;
647 vnode_t *vp = LINVFS_GET_VP(inode);
648
649 if (strncmp(name, xfs_namespaces[SYSTEM_NAMES].name,
650 xfs_namespaces[SYSTEM_NAMES].namelen) == 0) {
651 error = -ENOATTR;
652 p += xfs_namespaces[SYSTEM_NAMES].namelen;
653 if (strcmp(p, POSIXACL_ACCESS) == 0) {
654 error = xfs_acl_vget(vp, data, size, _ACL_TYPE_ACCESS);
655 }
656 else if (strcmp(p, POSIXACL_DEFAULT) == 0) {
657 error = xfs_acl_vget(vp, data, size, _ACL_TYPE_DEFAULT);
658 }
659 else if (strcmp(p, POSIXCAP) == 0) {
660 error = xfs_cap_vget(vp, data, size);
661 }
662 return error;
663 }
664
665 /* Convert Linux syscall to XFS internal ATTR flags */
666 if (!size)
667 xflags |= ATTR_KERNOVAL;
668
669 if (strncmp(name, xfs_namespaces[ROOT_NAMES].name,
670 xfs_namespaces[ROOT_NAMES].namelen) == 0) {
671 if (!capable(CAP_SYS_ADMIN))
672 return -EPERM;
673 xflags |= ATTR_ROOT;
674 p += xfs_namespaces[ROOT_NAMES].namelen;
675 VOP_ATTR_GET(vp, p, data, (int *)&size, xflags, NULL, error);
676 if (!error)
677 error = -size;
678 return -error;
679 }
680 if (strncmp(name, xfs_namespaces[USER_NAMES].name,
681 xfs_namespaces[USER_NAMES].namelen) == 0) {
682 p += xfs_namespaces[USER_NAMES].namelen;
683 if (!capable_user_xattr(inode))
684 return -EPERM;
685 VOP_ATTR_GET(vp, p, data, (int *)&size, xflags, NULL, error);
686 if (!error)
687 error = -size;
688 return -error;
689 }
690 return -ENOATTR;
691 }
692
693
694 STATIC ssize_t
695 linvfs_listxattr(
696 struct dentry *dentry,
697 char *data,
698 size_t size)
699 {
700 ssize_t error;
701 int result = 0;
702 int xflags = ATTR_KERNAMELS;
703 char *k = data;
704 attrlist_cursor_kern_t cursor;
705 xattr_namespace_t *sys;
706 vnode_t *vp;
707
708 vp = LINVFS_GET_VP(dentry->d_inode);
709
710 if (!size)
711 xflags |= ATTR_KERNOVAL;
712 if (capable(CAP_SYS_ADMIN))
713 xflags |= ATTR_KERNFULLS;
714
715 memset(&cursor, 0, sizeof(cursor));
716 VOP_ATTR_LIST(vp, data, size, xflags, &cursor, NULL, error);
717 if (error > 0)
718 return -error;
719 result += -error;
720
721 k += result; /* advance start of our buffer */
722 for (sys = &sys_namespace_array[0]; sys->name != NULL; sys++) {
723 if (sys->exists == NULL || !sys->exists(vp))
724 continue;
725 result += xfs_namespaces[SYSTEM_NAMES].namelen;
726 result += sys->namelen + 1;
727 if (size) {
728 if (result > size)
729 return -ERANGE;
730 strcpy(k, xfs_namespaces[SYSTEM_NAMES].name);
731 k += xfs_namespaces[SYSTEM_NAMES].namelen;
732 strcpy(k, sys->name);
733 k += sys->namelen + 1;
734 }
735 }
736 return result;
737 }
738
739 STATIC int
740 linvfs_removexattr(
741 struct dentry *dentry,
742 const char *name)
743 {
744 int error;
745 int xflags = 0;
746 char *p = (char *)name;
747 struct inode *inode = dentry->d_inode;
748 vnode_t *vp = LINVFS_GET_VP(inode);
749
750 if (strncmp(name, xfs_namespaces[SYSTEM_NAMES].name,
751 xfs_namespaces[SYSTEM_NAMES].namelen) == 0) {
752 error = -ENOATTR;
753 p += xfs_namespaces[SYSTEM_NAMES].namelen;
754 if (strcmp(p, POSIXACL_ACCESS) == 0)
755 error = xfs_acl_vremove(vp, _ACL_TYPE_ACCESS);
756 else if (strcmp(p, POSIXACL_DEFAULT) == 0)
757 error = xfs_acl_vremove(vp, _ACL_TYPE_DEFAULT);
758 else if (strcmp(p, POSIXCAP) == 0)
759 error = xfs_cap_vremove(vp);
760 return error;
761 }
762
763 if (strncmp(name, xfs_namespaces[ROOT_NAMES].name,
764 xfs_namespaces[ROOT_NAMES].namelen) == 0) {
765 if (!capable(CAP_SYS_ADMIN))
766 return -EPERM;
767 xflags |= ATTR_ROOT;
768 p += xfs_namespaces[ROOT_NAMES].namelen;
769 VOP_ATTR_REMOVE(vp, p, xflags, NULL, error);
770 return -error;
771 }
772 if (strncmp(name, xfs_namespaces[USER_NAMES].name,
773 xfs_namespaces[USER_NAMES].namelen) == 0) {
774 p += xfs_namespaces[USER_NAMES].namelen;
775 if (!capable_user_xattr(inode))
776 return -EPERM;
777 VOP_ATTR_REMOVE(vp, p, xflags, NULL, error);
778 return -error;
779 }
780 return -ENOATTR;
781 }
782
783
784 struct inode_operations linvfs_file_inode_operations =
785 {
786 .permission = linvfs_permission,
787 .getattr = linvfs_getattr,
788 .truncate = linvfs_truncate,
789 .setattr = linvfs_setattr,
790 .setxattr = linvfs_setxattr,
791 .getxattr = linvfs_getxattr,
792 .listxattr = linvfs_listxattr,
793 .removexattr = linvfs_removexattr,
794 };
795
796 struct inode_operations linvfs_dir_inode_operations =
797 {
798 .create = linvfs_create,
799 .lookup = linvfs_lookup,
800 .link = linvfs_link,
801 .unlink = linvfs_unlink,
802 .symlink = linvfs_symlink,
803 .mkdir = linvfs_mkdir,
804 .rmdir = linvfs_rmdir,
805 .mknod = linvfs_mknod,
806 .rename = linvfs_rename,
807 .permission = linvfs_permission,
808 .getattr = linvfs_getattr,
809 .setattr = linvfs_setattr,
810 .setxattr = linvfs_setxattr,
811 .getxattr = linvfs_getxattr,
812 .listxattr = linvfs_listxattr,
813 .removexattr = linvfs_removexattr,
814 };
815
816 struct inode_operations linvfs_symlink_inode_operations =
817 {
818 .readlink = linvfs_readlink,
819 .follow_link = linvfs_follow_link,
820 .permission = linvfs_permission,
821 .getattr = linvfs_getattr,
822 .setattr = linvfs_setattr,
823 .setxattr = linvfs_setxattr,
824 .getxattr = linvfs_getxattr,
825 .listxattr = linvfs_listxattr,
826 .removexattr = linvfs_removexattr,
827 };
Mirror of the linux-mips.org kernel tree