2 * linux/fs/umsdos/ioctl.c
4 * Written 1993 by Jacques Gelinas
6 * Extended MS-DOS ioctl directory handling functions
9 #include <asm/uaccess.h>
10 #include <linux/errno.h>
12 #include <linux/kernel.h>
13 #include <linux/sched.h>
15 #include <linux/msdos_fs.h>
16 #include <linux/umsdos_fs.h>
18 struct UMSDOS_DIR_ONCE
{
24 * Record a single entry the first call.
25 * Return -EINVAL the next one.
27 static int umsdos_ioctl_fill (
35 struct UMSDOS_DIR_ONCE
*d
= (struct UMSDOS_DIR_ONCE
*) buf
;
38 copy_to_user (d
->ent
->d_name
, name
, name_len
);
39 put_user ('\0', d
->ent
->d_name
+ name_len
);
40 put_user (name_len
, &d
->ent
->d_reclen
);
41 put_user (ino
, &d
->ent
->d_ino
);
42 put_user (offset
, &d
->ent
->d_off
);
51 * Perform special function on a directory
53 /* #Specification: ioctl / prototypes
54 * The official prototype for the umsdos ioctl on directory
58 * int fd, // File handle of the directory
60 * struct umsdos_ioctl *data)
62 * The struct and the commands are defined in linux/umsdos_fs.h.
64 * umsdos_progs/umsdosio.c provide an interface in C++ to all
65 * these ioctl. umsdos_progs/udosctl is a small utility showing
68 * These ioctl generally allow one to work on the EMD or the
69 * DOS directory independently. These are essential to implement
72 int UMSDOS_ioctl_dir(struct inode
*dir
, struct file
*filp
, unsigned int cmd
,
73 unsigned long data_ptr
)
75 struct dentry
*dentry
= filp
->f_dentry
;
76 struct umsdos_ioctl
*idata
= (struct umsdos_ioctl
*) data_ptr
;
78 struct umsdos_ioctl data
;
80 Printk(("UMSDOS_ioctl_dir: %s/%s, cmd=%d, data=%08lx\n",
81 dentry
->d_parent
->d_name
.name
, dentry
->d_name
.name
, cmd
, data_ptr
));
83 /* forward non-umsdos ioctls - this hopefully doesn't cause conflicts */
84 if (cmd
!= UMSDOS_GETVERSION
85 && cmd
!= UMSDOS_READDIR_DOS
86 && cmd
!= UMSDOS_READDIR_EMD
87 && cmd
!= UMSDOS_INIT_EMD
88 && cmd
!= UMSDOS_CREAT_EMD
89 && cmd
!= UMSDOS_RENAME_DOS
90 && cmd
!= UMSDOS_UNLINK_EMD
91 && cmd
!= UMSDOS_UNLINK_DOS
92 && cmd
!= UMSDOS_RMDIR_DOS
93 && cmd
!= UMSDOS_STAT_DOS
94 && cmd
!= UMSDOS_DOS_SETUP
)
95 return fat_dir_ioctl (dir
, filp
, cmd
, data_ptr
);
97 /* #Specification: ioctl / acces
98 * Only root (effective id) is allowed to do IOCTL on directory
99 * in UMSDOS. EPERM is returned for other user.
102 * Well, not all cases require write access, but it simplifies
103 * the code, and let's face it, there is only one client (umssync)
106 ret
= verify_area (VERIFY_WRITE
, (void *) data_ptr
,
107 sizeof (struct umsdos_ioctl
));
112 if (current
->euid
!= 0 && cmd
!= UMSDOS_GETVERSION
)
116 if (cmd
== UMSDOS_GETVERSION
) {
117 /* #Specification: ioctl / UMSDOS_GETVERSION
118 * The field version and release of the structure
119 * umsdos_ioctl are filled with the version and release
120 * number of the fs code in the kernel. This will allow
121 * some form of checking. Users won't be able to run
122 * incompatible utility such as the synchroniser (umssync).
123 * umsdos_progs/umsdosio.c enforce this checking.
127 put_user (UMSDOS_VERSION
, &idata
->version
);
128 put_user (UMSDOS_RELEASE
, &idata
->release
);
132 if (cmd
== UMSDOS_READDIR_DOS
) {
133 /* #Specification: ioctl / UMSDOS_READDIR_DOS
134 * One entry is read from the DOS directory at the current
135 * file position. The entry is put as is in the dos_dirent
136 * field of struct umsdos_ioctl.
138 * Return > 0 if success.
140 struct UMSDOS_DIR_ONCE bufk
;
143 bufk
.ent
= &idata
->dos_dirent
;
145 fat_readdir (filp
, &bufk
, umsdos_ioctl_fill
);
147 ret
= bufk
.count
== 1 ? 1 : 0;
150 if (cmd
== UMSDOS_READDIR_EMD
) {
151 /* #Specification: ioctl / UMSDOS_READDIR_EMD
152 * One entry is read from the EMD at the current
153 * file position. The entry is put as is in the umsdos_dirent
154 * field of struct umsdos_ioctl. The corresponding mangled
155 * DOS entry name is put in the dos_dirent field.
157 * All entries are read including hidden links. Blank
158 * entries are skipped.
160 * Return > 0 if success.
163 loff_t pos
= filp
->f_pos
;
165 /* The absence of the EMD is simply seen as an EOF */
166 demd
= umsdos_get_emd_dentry(dentry
);
174 while (pos
< demd
->d_inode
->i_size
) {
176 struct umsdos_dirent entry
;
177 struct umsdos_info info
;
179 ret
= umsdos_emd_dir_readentry (demd
, &pos
, &entry
);
181 if (ret
== -ENAMETOOLONG
) {
182 printk (KERN_INFO
"Fixing EMD entry with invalid size -- zeroing out\n");
183 memset (&info
, 0, sizeof (info
));
185 info
.recsize
= UMSDOS_REC_SIZE
;
186 ret
= umsdos_writeentry (dentry
, &info
, 1);
192 if (entry
.name_len
<= 0)
195 umsdos_parse (entry
.name
, entry
.name_len
, &info
);
197 umsdos_manglename (&info
);
199 if (copy_to_user (&idata
->umsdos_dirent
, &entry
,
202 if (copy_to_user (&idata
->dos_dirent
.d_name
,
206 ret
= entry
.name_len
;
209 /* update the original f_pos */
216 if (cmd
== UMSDOS_INIT_EMD
) {
217 /* #Specification: ioctl / UMSDOS_INIT_EMD
218 * The UMSDOS_INIT_EMD command makes sure the EMD
219 * exists for a directory. If it does not, it is
220 * created. Also, it makes sure the directory function
221 * table (struct inode_operations) is set to the UMSDOS
222 * semantic. This mean that umssync may be applied to
223 * an "opened" msdos directory, and it will change behavior
226 * Return 0 if success.
229 ret
= umsdos_make_emd(dentry
);
230 Printk(("UMSDOS_ioctl_dir: INIT_EMD %s/%s, ret=%d\n",
231 dentry
->d_parent
->d_name
.name
, dentry
->d_name
.name
, ret
));
232 umsdos_setup_dir (dentry
);
237 if (copy_from_user (&data
, idata
, sizeof (data
)))
240 if (cmd
== UMSDOS_CREAT_EMD
) {
241 /* #Specification: ioctl / UMSDOS_CREAT_EMD
242 * The umsdos_dirent field of the struct umsdos_ioctl is used
243 * as is to create a new entry in the EMD of the directory.
244 * The DOS directory is not modified.
245 * No validation is done (yet).
247 * Return 0 if success.
249 struct umsdos_info info
;
251 /* This makes sure info.entry and info in general
252 * is correctly initialised
254 memcpy (&info
.entry
, &data
.umsdos_dirent
,
255 sizeof (data
.umsdos_dirent
));
256 umsdos_parse (data
.umsdos_dirent
.name
257 ,data
.umsdos_dirent
.name_len
, &info
);
258 ret
= umsdos_newentry (dentry
, &info
);
261 else if (cmd
== UMSDOS_RENAME_DOS
) {
262 struct dentry
*old_dentry
, *new_dentry
; /* FIXME */
264 /* #Specification: ioctl / UMSDOS_RENAME_DOS
265 * A file or directory is renamed in a DOS directory
266 * (not moved across directory). The source name
267 * is in the dos_dirent.name field and the destination
268 * is in umsdos_dirent.name field.
270 * This ioctl allows umssync to rename a mangled file
271 * name before syncing it back in the EMD.
273 old_dentry
= umsdos_lookup_dentry (dentry
,
274 data
.dos_dirent
.d_name
,
275 data
.dos_dirent
.d_reclen
,1);
276 ret
= PTR_ERR(old_dentry
);
277 if (IS_ERR(old_dentry
))
279 new_dentry
= umsdos_lookup_dentry (dentry
,
280 data
.umsdos_dirent
.name
,
281 data
.umsdos_dirent
.name_len
, 1);
282 ret
= PTR_ERR(new_dentry
);
283 if (!IS_ERR(new_dentry
)) {
284 printk("umsdos_ioctl: renaming %s/%s to %s/%s\n",
285 old_dentry
->d_parent
->d_name
.name
, old_dentry
->d_name
.name
,
286 new_dentry
->d_parent
->d_name
.name
, new_dentry
->d_name
.name
);
287 ret
= msdos_rename (dir
, old_dentry
, dir
, new_dentry
);
295 else if (cmd
== UMSDOS_UNLINK_EMD
) {
296 /* #Specification: ioctl / UMSDOS_UNLINK_EMD
297 * The umsdos_dirent field of the struct umsdos_ioctl is used
298 * as is to remove an entry from the EMD of the directory.
299 * No validation is done (yet). The mode field is used
300 * to validate S_ISDIR or S_ISREG.
302 * Return 0 if success.
304 struct umsdos_info info
;
306 /* This makes sure info.entry and info in general
307 * is correctly initialised
309 memcpy (&info
.entry
, &data
.umsdos_dirent
,
310 sizeof (data
.umsdos_dirent
));
311 umsdos_parse (data
.umsdos_dirent
.name
,
312 data
.umsdos_dirent
.name_len
, &info
);
313 ret
= umsdos_delentry (dentry
, &info
,
314 S_ISDIR (data
.umsdos_dirent
.mode
));
317 "umsdos_ioctl: delentry %s/%s failed, ret=%d\n",
318 dentry
->d_name
.name
, info
.entry
.name
, ret
);
322 else if (cmd
== UMSDOS_UNLINK_DOS
) {
325 /* #Specification: ioctl / UMSDOS_UNLINK_DOS
326 * The dos_dirent field of the struct umsdos_ioctl is used to
327 * execute a msdos_unlink operation. The d_name and d_reclen
330 * Return 0 if success.
332 temp
= umsdos_lookup_dentry(dentry
, data
.dos_dirent
.d_name
,
333 data
.dos_dirent
.d_reclen
, 1);
340 if (!S_ISDIR(temp
->d_inode
->i_mode
))
341 ret
= msdos_unlink (dir
, temp
);
348 else if (cmd
== UMSDOS_RMDIR_DOS
) {
351 /* #Specification: ioctl / UMSDOS_RMDIR_DOS
352 * The dos_dirent field of the struct umsdos_ioctl is used to
353 * execute a msdos_rmdir operation. The d_name and d_reclen
356 * Return 0 if success.
358 temp
= umsdos_lookup_dentry(dentry
, data
.dos_dirent
.d_name
,
359 data
.dos_dirent
.d_reclen
, 1);
366 if (S_ISDIR(temp
->d_inode
->i_mode
))
367 ret
= msdos_rmdir (dir
, temp
);
374 } else if (cmd
== UMSDOS_STAT_DOS
) {
375 /* #Specification: ioctl / UMSDOS_STAT_DOS
376 * The dos_dirent field of the struct umsdos_ioctl is
377 * used to execute a stat operation in the DOS directory.
378 * The d_name and d_reclen fields are used.
380 * The following field of umsdos_ioctl.stat are filled.
382 * st_ino,st_mode,st_size,st_atime,st_mtime,st_ctime,
383 * Return 0 if success.
388 dret
= umsdos_lookup_dentry(dentry
, data
.dos_dirent
.d_name
,
389 data
.dos_dirent
.d_reclen
, 1);
394 inode
= dret
->d_inode
;
396 data
.stat
.st_ino
= inode
->i_ino
;
397 data
.stat
.st_mode
= inode
->i_mode
;
398 data
.stat
.st_size
= inode
->i_size
;
399 data
.stat
.st_atime
= inode
->i_atime
;
400 data
.stat
.st_ctime
= inode
->i_ctime
;
401 data
.stat
.st_mtime
= inode
->i_mtime
;
403 if (!copy_to_user (&idata
->stat
, &data
.stat
,
410 else if (cmd
== UMSDOS_DOS_SETUP
) {
411 /* #Specification: ioctl / UMSDOS_DOS_SETUP
412 * The UMSDOS_DOS_SETUP ioctl allow changing the
413 * default permission of the MS-DOS filesystem driver
414 * on the fly. The MS-DOS driver applies global permissions
415 * to every file and directory. Normally these permissions
416 * are controlled by a mount option. This is not
417 * available for root partition, so a special utility
418 * (umssetup) is provided to do this, normally in
421 * Be aware that this applies ONLY to MS-DOS directories
422 * (those without EMD --linux-.---). Umsdos directory
423 * have independent (standard) permission for each
426 * The field umsdos_dirent provide the information needed.
427 * umsdos_dirent.uid and gid sets the owner and group.
428 * umsdos_dirent.mode set the permissions flags.
430 dir
->i_sb
->u
.msdos_sb
.options
.fs_uid
= data
.umsdos_dirent
.uid
;
431 dir
->i_sb
->u
.msdos_sb
.options
.fs_gid
= data
.umsdos_dirent
.gid
;
432 dir
->i_sb
->u
.msdos_sb
.options
.fs_umask
= data
.umsdos_dirent
.mode
;
436 Printk (("ioctl %d, returning %d\n", cmd
, ret
));