OpenCores
URL https://opencores.org/ocsvn/test_project/test_project/trunk

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [fs/] [attr.c] - Blame information for rev 82

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 62 marcus.erl 
/*
2 
 *  linux/fs/attr.c
3 
 *
4 
 *  Copyright (C) 1991, 1992  Linus Torvalds
5 
 *  changes by Thomas Schoebel-Theuer
6 
 */
7 
 
8 
#include <linux/module.h>
9 
#include <linux/time.h>
10 
#include <linux/mm.h>
11 
#include <linux/string.h>
12 
#include <linux/capability.h>
13 
#include <linux/fsnotify.h>
14 
#include <linux/fcntl.h>
15 
#include <linux/quotaops.h>
16 
#include <linux/security.h>
17 
 
18 
/* Taken over from the old code... */
19 
 
20 
/* POSIX UID/GID verification for setting inode attributes. */
21 
int inode_change_ok(struct inode *inode, struct iattr *attr)
22 
{
23 
        int retval = -EPERM;
24 
        unsigned int ia_valid = attr->ia_valid;
25 
 
26 
        /* If force is set do it anyway. */
27 
        if (ia_valid & ATTR_FORCE)
28 
                goto fine;
29 
 
30 
        /* Make sure a caller can chown. */
31 
        if ((ia_valid & ATTR_UID) &&
32 
            (current->fsuid != inode->i_uid ||
33 
             attr->ia_uid != inode->i_uid) && !capable(CAP_CHOWN))
34 
                goto error;
35 
 
36 
        /* Make sure caller can chgrp. */
37 
        if ((ia_valid & ATTR_GID) &&
38 
            (current->fsuid != inode->i_uid ||
39 
            (!in_group_p(attr->ia_gid) && attr->ia_gid != inode->i_gid)) &&
40 
            !capable(CAP_CHOWN))
41 
                goto error;
42 
 
43 
        /* Make sure a caller can chmod. */
44 
        if (ia_valid & ATTR_MODE) {
45 
                if (!is_owner_or_cap(inode))
46 
                        goto error;
47 
                /* Also check the setgid bit! */
48 
                if (!in_group_p((ia_valid & ATTR_GID) ? attr->ia_gid :
49 
                                inode->i_gid) && !capable(CAP_FSETID))
50 
                        attr->ia_mode &= ~S_ISGID;
51 
        }
52 
 
53 
        /* Check for setting the inode time. */
54 
        if (ia_valid & (ATTR_MTIME_SET | ATTR_ATIME_SET)) {
55 
                if (!is_owner_or_cap(inode))
56 
                        goto error;
57 
        }
58 
fine:
59 
        retval = 0;
60 
error:
61 
        return retval;
62 
}
63 
 
64 
EXPORT_SYMBOL(inode_change_ok);
65 
 
66 
int inode_setattr(struct inode * inode, struct iattr * attr)
67 
{
68 
        unsigned int ia_valid = attr->ia_valid;
69 
 
70 
        if (ia_valid & ATTR_SIZE &&
71 
            attr->ia_size != i_size_read(inode)) {
72 
                int error = vmtruncate(inode, attr->ia_size);
73 
                if (error)
74 
                        return error;
75 
        }
76 
 
77 
        if (ia_valid & ATTR_UID)
78 
                inode->i_uid = attr->ia_uid;
79 
        if (ia_valid & ATTR_GID)
80 
                inode->i_gid = attr->ia_gid;
81 
        if (ia_valid & ATTR_ATIME)
82 
                inode->i_atime = timespec_trunc(attr->ia_atime,
83 
                                                inode->i_sb->s_time_gran);
84 
        if (ia_valid & ATTR_MTIME)
85 
                inode->i_mtime = timespec_trunc(attr->ia_mtime,
86 
                                                inode->i_sb->s_time_gran);
87 
        if (ia_valid & ATTR_CTIME)
88 
                inode->i_ctime = timespec_trunc(attr->ia_ctime,
89 
                                                inode->i_sb->s_time_gran);
90 
        if (ia_valid & ATTR_MODE) {
91 
                umode_t mode = attr->ia_mode;
92 
 
93 
                if (!in_group_p(inode->i_gid) && !capable(CAP_FSETID))
94 
                        mode &= ~S_ISGID;
95 
                inode->i_mode = mode;
96 
        }
97 
        mark_inode_dirty(inode);
98 
 
99 
        return 0;
100 
}
101 
EXPORT_SYMBOL(inode_setattr);
102 
 
103 
int notify_change(struct dentry * dentry, struct iattr * attr)
104 
{
105 
        struct inode *inode = dentry->d_inode;
106 
        mode_t mode = inode->i_mode;
107 
        int error;
108 
        struct timespec now;
109 
        unsigned int ia_valid = attr->ia_valid;
110 
 
111 
        now = current_fs_time(inode->i_sb);
112 
 
113 
        attr->ia_ctime = now;
114 
        if (!(ia_valid & ATTR_ATIME_SET))
115 
                attr->ia_atime = now;
116 
        if (!(ia_valid & ATTR_MTIME_SET))
117 
                attr->ia_mtime = now;
118 
        if (ia_valid & ATTR_KILL_PRIV) {
119 
                attr->ia_valid &= ~ATTR_KILL_PRIV;
120 
                ia_valid &= ~ATTR_KILL_PRIV;
121 
                error = security_inode_need_killpriv(dentry);
122 
                if (error > 0)
123 
                        error = security_inode_killpriv(dentry);
124 
                if (error)
125 
                        return error;
126 
        }
127 
 
128 
        /*
129 
         * We now pass ATTR_KILL_S*ID to the lower level setattr function so
130 
         * that the function has the ability to reinterpret a mode change
131 
         * that's due to these bits. This adds an implicit restriction that
132 
         * no function will ever call notify_change with both ATTR_MODE and
133 
         * ATTR_KILL_S*ID set.
134 
         */
135 
        if ((ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID)) &&
136 
            (ia_valid & ATTR_MODE))
137 
                BUG();
138 
 
139 
        if (ia_valid & ATTR_KILL_SUID) {
140 
                if (mode & S_ISUID) {
141 
                        ia_valid = attr->ia_valid |= ATTR_MODE;
142 
                        attr->ia_mode = (inode->i_mode & ~S_ISUID);
143 
                }
144 
        }
145 
        if (ia_valid & ATTR_KILL_SGID) {
146 
                if ((mode & (S_ISGID | S_IXGRP)) == (S_ISGID | S_IXGRP)) {
147 
                        if (!(ia_valid & ATTR_MODE)) {
148 
                                ia_valid = attr->ia_valid |= ATTR_MODE;
149 
                                attr->ia_mode = inode->i_mode;
150 
                        }
151 
                        attr->ia_mode &= ~S_ISGID;
152 
                }
153 
        }
154 
        if (!(attr->ia_valid & ~(ATTR_KILL_SUID | ATTR_KILL_SGID)))
155 
                return 0;
156 
 
157 
        if (ia_valid & ATTR_SIZE)
158 
                down_write(&dentry->d_inode->i_alloc_sem);
159 
 
160 
        if (inode->i_op && inode->i_op->setattr) {
161 
                error = security_inode_setattr(dentry, attr);
162 
                if (!error)
163 
                        error = inode->i_op->setattr(dentry, attr);
164 
        } else {
165 
                error = inode_change_ok(inode, attr);
166 
                if (!error)
167 
                        error = security_inode_setattr(dentry, attr);
168 
                if (!error) {
169 
                        if ((ia_valid & ATTR_UID && attr->ia_uid != inode->i_uid) ||
170 
                            (ia_valid & ATTR_GID && attr->ia_gid != inode->i_gid))
171 
                                error = DQUOT_TRANSFER(inode, attr) ? -EDQUOT : 0;
172 
                        if (!error)
173 
                                error = inode_setattr(inode, attr);
174 
                }
175 
        }
176 
 
177 
        if (ia_valid & ATTR_SIZE)
178 
                up_write(&dentry->d_inode->i_alloc_sem);
179 
 
180 
        if (!error)
181 
                fsnotify_change(dentry, ia_valid);
182 
 
183 
        return error;
184 
}
185 
 
186 
EXPORT_SYMBOL(notify_change);

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.