~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/ubifs/ioctl.c

Version: ~ [ linux-5.16-rc3 ] ~ [ linux-5.15.5 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.82 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.162 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.218 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.256 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.291 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.293 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * This file is part of UBIFS.
  3  *
  4  * Copyright (C) 2006-2008 Nokia Corporation.
  5  * Copyright (C) 2006, 2007 University of Szeged, Hungary
  6  *
  7  * This program is free software; you can redistribute it and/or modify it
  8  * under the terms of the GNU General Public License version 2 as published by
  9  * the Free Software Foundation.
 10  *
 11  * This program is distributed in the hope that it will be useful, but WITHOUT
 12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 14  * more details.
 15  *
 16  * You should have received a copy of the GNU General Public License along with
 17  * this program; if not, write to the Free Software Foundation, Inc., 51
 18  * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 19  *
 20  * Authors: Zoltan Sogor
 21  *          Artem Bityutskiy (Битюцкий Артём)
 22  *          Adrian Hunter
 23  */
 24 
 25 /* This file implements EXT2-compatible extended attribute ioctl() calls */
 26 
 27 #include <linux/compat.h>
 28 #include <linux/mount.h>
 29 #include "ubifs.h"
 30 
 31 /**
 32  * ubifs_set_inode_flags - set VFS inode flags.
 33  * @inode: VFS inode to set flags for
 34  *
 35  * This function propagates flags from UBIFS inode object to VFS inode object.
 36  */
 37 void ubifs_set_inode_flags(struct inode *inode)
 38 {
 39         unsigned int flags = ubifs_inode(inode)->flags;
 40 
 41         inode->i_flags &= ~(S_SYNC | S_APPEND | S_IMMUTABLE | S_DIRSYNC |
 42                             S_ENCRYPTED);
 43         if (flags & UBIFS_SYNC_FL)
 44                 inode->i_flags |= S_SYNC;
 45         if (flags & UBIFS_APPEND_FL)
 46                 inode->i_flags |= S_APPEND;
 47         if (flags & UBIFS_IMMUTABLE_FL)
 48                 inode->i_flags |= S_IMMUTABLE;
 49         if (flags & UBIFS_DIRSYNC_FL)
 50                 inode->i_flags |= S_DIRSYNC;
 51         if (flags & UBIFS_CRYPT_FL)
 52                 inode->i_flags |= S_ENCRYPTED;
 53 }
 54 
 55 /*
 56  * ioctl2ubifs - convert ioctl inode flags to UBIFS inode flags.
 57  * @ioctl_flags: flags to convert
 58  *
 59  * This function converts ioctl flags (@FS_COMPR_FL, etc) to UBIFS inode flags
 60  * (@UBIFS_COMPR_FL, etc).
 61  */
 62 static int ioctl2ubifs(int ioctl_flags)
 63 {
 64         int ubifs_flags = 0;
 65 
 66         if (ioctl_flags & FS_COMPR_FL)
 67                 ubifs_flags |= UBIFS_COMPR_FL;
 68         if (ioctl_flags & FS_SYNC_FL)
 69                 ubifs_flags |= UBIFS_SYNC_FL;
 70         if (ioctl_flags & FS_APPEND_FL)
 71                 ubifs_flags |= UBIFS_APPEND_FL;
 72         if (ioctl_flags & FS_IMMUTABLE_FL)
 73                 ubifs_flags |= UBIFS_IMMUTABLE_FL;
 74         if (ioctl_flags & FS_DIRSYNC_FL)
 75                 ubifs_flags |= UBIFS_DIRSYNC_FL;
 76 
 77         return ubifs_flags;
 78 }
 79 
 80 /*
 81  * ubifs2ioctl - convert UBIFS inode flags to ioctl inode flags.
 82  * @ubifs_flags: flags to convert
 83  *
 84  * This function converts UBIFS inode flags (@UBIFS_COMPR_FL, etc) to ioctl
 85  * flags (@FS_COMPR_FL, etc).
 86  */
 87 static int ubifs2ioctl(int ubifs_flags)
 88 {
 89         int ioctl_flags = 0;
 90 
 91         if (ubifs_flags & UBIFS_COMPR_FL)
 92                 ioctl_flags |= FS_COMPR_FL;
 93         if (ubifs_flags & UBIFS_SYNC_FL)
 94                 ioctl_flags |= FS_SYNC_FL;
 95         if (ubifs_flags & UBIFS_APPEND_FL)
 96                 ioctl_flags |= FS_APPEND_FL;
 97         if (ubifs_flags & UBIFS_IMMUTABLE_FL)
 98                 ioctl_flags |= FS_IMMUTABLE_FL;
 99         if (ubifs_flags & UBIFS_DIRSYNC_FL)
100                 ioctl_flags |= FS_DIRSYNC_FL;
101 
102         return ioctl_flags;
103 }
104 
105 static int setflags(struct inode *inode, int flags)
106 {
107         int oldflags, err, release;
108         struct ubifs_inode *ui = ubifs_inode(inode);
109         struct ubifs_info *c = inode->i_sb->s_fs_info;
110         struct ubifs_budget_req req = { .dirtied_ino = 1,
111                                         .dirtied_ino_d = ui->data_len };
112 
113         err = ubifs_budget_space(c, &req);
114         if (err)
115                 return err;
116 
117         /*
118          * The IMMUTABLE and APPEND_ONLY flags can only be changed by
119          * the relevant capability.
120          */
121         mutex_lock(&ui->ui_mutex);
122         oldflags = ubifs2ioctl(ui->flags);
123         if ((flags ^ oldflags) & (FS_APPEND_FL | FS_IMMUTABLE_FL)) {
124                 if (!capable(CAP_LINUX_IMMUTABLE)) {
125                         err = -EPERM;
126                         goto out_unlock;
127                 }
128         }
129 
130         ui->flags = ioctl2ubifs(flags);
131         ubifs_set_inode_flags(inode);
132         inode->i_ctime = current_time(inode);
133         release = ui->dirty;
134         mark_inode_dirty_sync(inode);
135         mutex_unlock(&ui->ui_mutex);
136 
137         if (release)
138                 ubifs_release_budget(c, &req);
139         if (IS_SYNC(inode))
140                 err = write_inode_now(inode, 1);
141         return err;
142 
143 out_unlock:
144         ubifs_err(c, "can't modify inode %lu attributes", inode->i_ino);
145         mutex_unlock(&ui->ui_mutex);
146         ubifs_release_budget(c, &req);
147         return err;
148 }
149 
150 long ubifs_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
151 {
152         int flags, err;
153         struct inode *inode = file_inode(file);
154 
155         switch (cmd) {
156         case FS_IOC_GETFLAGS:
157                 flags = ubifs2ioctl(ubifs_inode(inode)->flags);
158 
159                 dbg_gen("get flags: %#x, i_flags %#x", flags, inode->i_flags);
160                 return put_user(flags, (int __user *) arg);
161 
162         case FS_IOC_SETFLAGS: {
163                 if (IS_RDONLY(inode))
164                         return -EROFS;
165 
166                 if (!inode_owner_or_capable(inode))
167                         return -EACCES;
168 
169                 if (get_user(flags, (int __user *) arg))
170                         return -EFAULT;
171 
172                 if (!S_ISDIR(inode->i_mode))
173                         flags &= ~FS_DIRSYNC_FL;
174 
175                 /*
176                  * Make sure the file-system is read-write and make sure it
177                  * will not become read-only while we are changing the flags.
178                  */
179                 err = mnt_want_write_file(file);
180                 if (err)
181                         return err;
182                 dbg_gen("set flags: %#x, i_flags %#x", flags, inode->i_flags);
183                 err = setflags(inode, flags);
184                 mnt_drop_write_file(file);
185                 return err;
186         }
187         case FS_IOC_SET_ENCRYPTION_POLICY: {
188 #ifdef CONFIG_UBIFS_FS_ENCRYPTION
189                 struct ubifs_info *c = inode->i_sb->s_fs_info;
190 
191                 err = ubifs_enable_encryption(c);
192                 if (err)
193                         return err;
194 
195                 return fscrypt_ioctl_set_policy(file, (const void __user *)arg);
196 #else
197                 return -EOPNOTSUPP;
198 #endif
199         }
200         case FS_IOC_GET_ENCRYPTION_POLICY: {
201 #ifdef CONFIG_UBIFS_FS_ENCRYPTION
202                 return fscrypt_ioctl_get_policy(file, (void __user *)arg);
203 #else
204                 return -EOPNOTSUPP;
205 #endif
206         }
207 
208         default:
209                 return -ENOTTY;
210         }
211 }
212 
213 #ifdef CONFIG_COMPAT
214 long ubifs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
215 {
216         switch (cmd) {
217         case FS_IOC32_GETFLAGS:
218                 cmd = FS_IOC_GETFLAGS;
219                 break;
220         case FS_IOC32_SETFLAGS:
221                 cmd = FS_IOC_SETFLAGS;
222                 break;
223         case FS_IOC_SET_ENCRYPTION_POLICY:
224         case FS_IOC_GET_ENCRYPTION_POLICY:
225                 break;
226         default:
227                 return -ENOIOCTLCMD;
228         }
229         return ubifs_ioctl(file, cmd, (unsigned long)compat_ptr(arg));
230 }
231 #endif
232 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp