blob: 30dd7b10b507a077877d58a2bb4d5ada18ee3101 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * linux/fs/hpfs/namei.c
3 *
4 * Mikulas Patocka (mikulas@artax.karlin.mff.cuni.cz), 1998-1999
5 *
6 * adding & removing files & directories
7 */
Alexey Dobriyane8edc6e2007-05-21 01:22:52 +04008#include <linux/sched.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -07009#include "hpfs_fn.h"
10
Al Viro18bb1db2011-07-26 01:41:39 -040011static int hpfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -070012{
Al Viro7e7742e2010-01-31 17:09:29 -050013 const unsigned char *name = dentry->d_name.name;
Linus Torvalds1da177e2005-04-16 15:20:36 -070014 unsigned len = dentry->d_name.len;
15 struct quad_buffer_head qbh0;
16 struct buffer_head *bh;
17 struct hpfs_dirent *de;
18 struct fnode *fnode;
19 struct dnode *dnode;
20 struct inode *result;
21 fnode_secno fno;
22 dnode_secno dno;
23 int r;
24 struct hpfs_dirent dee;
25 int err;
Al Viro7e7742e2010-01-31 17:09:29 -050026 if ((err = hpfs_chk_name(name, &len))) return err==-ENOENT ? -EINVAL : err;
Arnd Bergmann9a311b92011-01-22 20:26:12 +010027 hpfs_lock(dir->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -070028 err = -ENOSPC;
29 fnode = hpfs_alloc_fnode(dir->i_sb, hpfs_i(dir)->i_dno, &fno, &bh);
30 if (!fnode)
31 goto bail;
Mikulas Patocka7d23ce32011-05-08 20:43:06 +020032 dnode = hpfs_alloc_dnode(dir->i_sb, fno, &dno, &qbh0);
Linus Torvalds1da177e2005-04-16 15:20:36 -070033 if (!dnode)
34 goto bail1;
35 memset(&dee, 0, sizeof dee);
36 dee.directory = 1;
37 if (!(mode & 0222)) dee.read_only = 1;
38 /*dee.archive = 0;*/
39 dee.hidden = name[0] == '.';
Mikulas Patocka0b697602011-05-08 20:44:26 +020040 dee.fnode = cpu_to_le32(fno);
41 dee.creation_date = dee.write_date = dee.read_date = cpu_to_le32(gmt_to_local(dir->i_sb, get_seconds()));
Linus Torvalds1da177e2005-04-16 15:20:36 -070042 result = new_inode(dir->i_sb);
43 if (!result)
44 goto bail2;
45 hpfs_init_inode(result);
46 result->i_ino = fno;
47 hpfs_i(result)->i_parent_dir = dir->i_ino;
48 hpfs_i(result)->i_dno = dno;
Mikulas Patocka0b697602011-05-08 20:44:26 +020049 result->i_ctime.tv_sec = result->i_mtime.tv_sec = result->i_atime.tv_sec = local_to_gmt(dir->i_sb, le32_to_cpu(dee.creation_date));
Linus Torvalds1da177e2005-04-16 15:20:36 -070050 result->i_ctime.tv_nsec = 0;
51 result->i_mtime.tv_nsec = 0;
52 result->i_atime.tv_nsec = 0;
53 hpfs_i(result)->i_ea_size = 0;
54 result->i_mode |= S_IFDIR;
55 result->i_op = &hpfs_dir_iops;
56 result->i_fop = &hpfs_dir_ops;
57 result->i_blocks = 4;
58 result->i_size = 2048;
Miklos Szeredibfe86842011-10-28 14:13:29 +020059 set_nlink(result, 2);
Linus Torvalds1da177e2005-04-16 15:20:36 -070060 if (dee.read_only)
61 result->i_mode &= ~0222;
62
Mikulas Patocka7d23ce32011-05-08 20:43:06 +020063 r = hpfs_add_dirent(dir, name, len, &dee);
Linus Torvalds1da177e2005-04-16 15:20:36 -070064 if (r == 1)
65 goto bail3;
66 if (r == -1) {
67 err = -EEXIST;
68 goto bail3;
69 }
70 fnode->len = len;
71 memcpy(fnode->name, name, len > 15 ? 15 : len);
Mikulas Patocka0b697602011-05-08 20:44:26 +020072 fnode->up = cpu_to_le32(dir->i_ino);
Linus Torvalds1da177e2005-04-16 15:20:36 -070073 fnode->dirflag = 1;
74 fnode->btree.n_free_nodes = 7;
75 fnode->btree.n_used_nodes = 1;
Mikulas Patocka0b697602011-05-08 20:44:26 +020076 fnode->btree.first_free = cpu_to_le16(0x14);
77 fnode->u.external[0].disk_secno = cpu_to_le32(dno);
78 fnode->u.external[0].file_secno = cpu_to_le32(-1);
Linus Torvalds1da177e2005-04-16 15:20:36 -070079 dnode->root_dnode = 1;
Mikulas Patocka0b697602011-05-08 20:44:26 +020080 dnode->up = cpu_to_le32(fno);
Linus Torvalds1da177e2005-04-16 15:20:36 -070081 de = hpfs_add_de(dir->i_sb, dnode, "\001\001", 2, 0);
Mikulas Patocka0b697602011-05-08 20:44:26 +020082 de->creation_date = de->write_date = de->read_date = cpu_to_le32(gmt_to_local(dir->i_sb, get_seconds()));
Linus Torvalds1da177e2005-04-16 15:20:36 -070083 if (!(mode & 0222)) de->read_only = 1;
84 de->first = de->directory = 1;
85 /*de->hidden = de->system = 0;*/
Mikulas Patocka0b697602011-05-08 20:44:26 +020086 de->fnode = cpu_to_le32(fno);
Linus Torvalds1da177e2005-04-16 15:20:36 -070087 mark_buffer_dirty(bh);
88 brelse(bh);
89 hpfs_mark_4buffers_dirty(&qbh0);
90 hpfs_brelse4(&qbh0);
Dave Hansend8c76e62006-09-30 23:29:04 -070091 inc_nlink(dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -070092 insert_inode_hash(result);
93
David Howellsde395b82008-11-14 10:38:55 +110094 if (result->i_uid != current_fsuid() ||
95 result->i_gid != current_fsgid() ||
Linus Torvalds1da177e2005-04-16 15:20:36 -070096 result->i_mode != (mode | S_IFDIR)) {
David Howellsde395b82008-11-14 10:38:55 +110097 result->i_uid = current_fsuid();
98 result->i_gid = current_fsgid();
Linus Torvalds1da177e2005-04-16 15:20:36 -070099 result->i_mode = mode | S_IFDIR;
100 hpfs_write_inode_nolock(result);
101 }
102 d_instantiate(dentry, result);
Arnd Bergmann9a311b92011-01-22 20:26:12 +0100103 hpfs_unlock(dir->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104 return 0;
105bail3:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106 iput(result);
107bail2:
108 hpfs_brelse4(&qbh0);
109 hpfs_free_dnode(dir->i_sb, dno);
110bail1:
111 brelse(bh);
112 hpfs_free_sectors(dir->i_sb, fno, 1);
113bail:
Arnd Bergmann9a311b92011-01-22 20:26:12 +0100114 hpfs_unlock(dir->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115 return err;
116}
117
Al Viro4acdaf22011-07-26 01:42:34 -0400118static int hpfs_create(struct inode *dir, struct dentry *dentry, umode_t mode, struct nameidata *nd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119{
Al Viro7e7742e2010-01-31 17:09:29 -0500120 const unsigned char *name = dentry->d_name.name;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121 unsigned len = dentry->d_name.len;
122 struct inode *result = NULL;
123 struct buffer_head *bh;
124 struct fnode *fnode;
125 fnode_secno fno;
126 int r;
127 struct hpfs_dirent dee;
128 int err;
Al Viro7e7742e2010-01-31 17:09:29 -0500129 if ((err = hpfs_chk_name(name, &len)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130 return err==-ENOENT ? -EINVAL : err;
Arnd Bergmann9a311b92011-01-22 20:26:12 +0100131 hpfs_lock(dir->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132 err = -ENOSPC;
133 fnode = hpfs_alloc_fnode(dir->i_sb, hpfs_i(dir)->i_dno, &fno, &bh);
134 if (!fnode)
135 goto bail;
136 memset(&dee, 0, sizeof dee);
137 if (!(mode & 0222)) dee.read_only = 1;
138 dee.archive = 1;
139 dee.hidden = name[0] == '.';
Mikulas Patocka0b697602011-05-08 20:44:26 +0200140 dee.fnode = cpu_to_le32(fno);
141 dee.creation_date = dee.write_date = dee.read_date = cpu_to_le32(gmt_to_local(dir->i_sb, get_seconds()));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142
143 result = new_inode(dir->i_sb);
144 if (!result)
145 goto bail1;
146
147 hpfs_init_inode(result);
148 result->i_ino = fno;
149 result->i_mode |= S_IFREG;
150 result->i_mode &= ~0111;
151 result->i_op = &hpfs_file_iops;
152 result->i_fop = &hpfs_file_ops;
Miklos Szeredibfe86842011-10-28 14:13:29 +0200153 set_nlink(result, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154 hpfs_i(result)->i_parent_dir = dir->i_ino;
Mikulas Patocka0b697602011-05-08 20:44:26 +0200155 result->i_ctime.tv_sec = result->i_mtime.tv_sec = result->i_atime.tv_sec = local_to_gmt(dir->i_sb, le32_to_cpu(dee.creation_date));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156 result->i_ctime.tv_nsec = 0;
157 result->i_mtime.tv_nsec = 0;
158 result->i_atime.tv_nsec = 0;
159 hpfs_i(result)->i_ea_size = 0;
160 if (dee.read_only)
161 result->i_mode &= ~0222;
162 result->i_blocks = 1;
163 result->i_size = 0;
164 result->i_data.a_ops = &hpfs_aops;
165 hpfs_i(result)->mmu_private = 0;
166
Mikulas Patocka7d23ce32011-05-08 20:43:06 +0200167 r = hpfs_add_dirent(dir, name, len, &dee);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168 if (r == 1)
169 goto bail2;
170 if (r == -1) {
171 err = -EEXIST;
172 goto bail2;
173 }
174 fnode->len = len;
175 memcpy(fnode->name, name, len > 15 ? 15 : len);
Mikulas Patocka0b697602011-05-08 20:44:26 +0200176 fnode->up = cpu_to_le32(dir->i_ino);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177 mark_buffer_dirty(bh);
178 brelse(bh);
179
180 insert_inode_hash(result);
181
David Howellsde395b82008-11-14 10:38:55 +1100182 if (result->i_uid != current_fsuid() ||
183 result->i_gid != current_fsgid() ||
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184 result->i_mode != (mode | S_IFREG)) {
David Howellsde395b82008-11-14 10:38:55 +1100185 result->i_uid = current_fsuid();
186 result->i_gid = current_fsgid();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187 result->i_mode = mode | S_IFREG;
188 hpfs_write_inode_nolock(result);
189 }
190 d_instantiate(dentry, result);
Arnd Bergmann9a311b92011-01-22 20:26:12 +0100191 hpfs_unlock(dir->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192 return 0;
193
194bail2:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195 iput(result);
196bail1:
197 brelse(bh);
198 hpfs_free_sectors(dir->i_sb, fno, 1);
199bail:
Arnd Bergmann9a311b92011-01-22 20:26:12 +0100200 hpfs_unlock(dir->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201 return err;
202}
203
Al Viro1a67aaf2011-07-26 01:52:52 -0400204static int hpfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, dev_t rdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205{
Al Viro7e7742e2010-01-31 17:09:29 -0500206 const unsigned char *name = dentry->d_name.name;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207 unsigned len = dentry->d_name.len;
208 struct buffer_head *bh;
209 struct fnode *fnode;
210 fnode_secno fno;
211 int r;
212 struct hpfs_dirent dee;
213 struct inode *result = NULL;
214 int err;
Al Viro7e7742e2010-01-31 17:09:29 -0500215 if ((err = hpfs_chk_name(name, &len))) return err==-ENOENT ? -EINVAL : err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216 if (hpfs_sb(dir->i_sb)->sb_eas < 2) return -EPERM;
217 if (!new_valid_dev(rdev))
218 return -EINVAL;
Arnd Bergmann9a311b92011-01-22 20:26:12 +0100219 hpfs_lock(dir->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220 err = -ENOSPC;
221 fnode = hpfs_alloc_fnode(dir->i_sb, hpfs_i(dir)->i_dno, &fno, &bh);
222 if (!fnode)
223 goto bail;
224 memset(&dee, 0, sizeof dee);
225 if (!(mode & 0222)) dee.read_only = 1;
226 dee.archive = 1;
227 dee.hidden = name[0] == '.';
Mikulas Patocka0b697602011-05-08 20:44:26 +0200228 dee.fnode = cpu_to_le32(fno);
229 dee.creation_date = dee.write_date = dee.read_date = cpu_to_le32(gmt_to_local(dir->i_sb, get_seconds()));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230
231 result = new_inode(dir->i_sb);
232 if (!result)
233 goto bail1;
234
235 hpfs_init_inode(result);
236 result->i_ino = fno;
237 hpfs_i(result)->i_parent_dir = dir->i_ino;
Mikulas Patocka0b697602011-05-08 20:44:26 +0200238 result->i_ctime.tv_sec = result->i_mtime.tv_sec = result->i_atime.tv_sec = local_to_gmt(dir->i_sb, le32_to_cpu(dee.creation_date));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239 result->i_ctime.tv_nsec = 0;
240 result->i_mtime.tv_nsec = 0;
241 result->i_atime.tv_nsec = 0;
242 hpfs_i(result)->i_ea_size = 0;
David Howellsde395b82008-11-14 10:38:55 +1100243 result->i_uid = current_fsuid();
244 result->i_gid = current_fsgid();
Miklos Szeredibfe86842011-10-28 14:13:29 +0200245 set_nlink(result, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246 result->i_size = 0;
247 result->i_blocks = 1;
248 init_special_inode(result, mode, rdev);
249
Mikulas Patocka7d23ce32011-05-08 20:43:06 +0200250 r = hpfs_add_dirent(dir, name, len, &dee);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251 if (r == 1)
252 goto bail2;
253 if (r == -1) {
254 err = -EEXIST;
255 goto bail2;
256 }
257 fnode->len = len;
258 memcpy(fnode->name, name, len > 15 ? 15 : len);
Mikulas Patocka0b697602011-05-08 20:44:26 +0200259 fnode->up = cpu_to_le32(dir->i_ino);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260 mark_buffer_dirty(bh);
261
262 insert_inode_hash(result);
263
264 hpfs_write_inode_nolock(result);
265 d_instantiate(dentry, result);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266 brelse(bh);
Arnd Bergmann9a311b92011-01-22 20:26:12 +0100267 hpfs_unlock(dir->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268 return 0;
269bail2:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270 iput(result);
271bail1:
272 brelse(bh);
273 hpfs_free_sectors(dir->i_sb, fno, 1);
274bail:
Arnd Bergmann9a311b92011-01-22 20:26:12 +0100275 hpfs_unlock(dir->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276 return err;
277}
278
279static int hpfs_symlink(struct inode *dir, struct dentry *dentry, const char *symlink)
280{
Al Viro7e7742e2010-01-31 17:09:29 -0500281 const unsigned char *name = dentry->d_name.name;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282 unsigned len = dentry->d_name.len;
283 struct buffer_head *bh;
284 struct fnode *fnode;
285 fnode_secno fno;
286 int r;
287 struct hpfs_dirent dee;
288 struct inode *result;
289 int err;
Al Viro7e7742e2010-01-31 17:09:29 -0500290 if ((err = hpfs_chk_name(name, &len))) return err==-ENOENT ? -EINVAL : err;
Arnd Bergmann9a311b92011-01-22 20:26:12 +0100291 hpfs_lock(dir->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292 if (hpfs_sb(dir->i_sb)->sb_eas < 2) {
Arnd Bergmann9a311b92011-01-22 20:26:12 +0100293 hpfs_unlock(dir->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294 return -EPERM;
295 }
296 err = -ENOSPC;
297 fnode = hpfs_alloc_fnode(dir->i_sb, hpfs_i(dir)->i_dno, &fno, &bh);
298 if (!fnode)
299 goto bail;
300 memset(&dee, 0, sizeof dee);
301 dee.archive = 1;
302 dee.hidden = name[0] == '.';
Mikulas Patocka0b697602011-05-08 20:44:26 +0200303 dee.fnode = cpu_to_le32(fno);
304 dee.creation_date = dee.write_date = dee.read_date = cpu_to_le32(gmt_to_local(dir->i_sb, get_seconds()));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305
306 result = new_inode(dir->i_sb);
307 if (!result)
308 goto bail1;
309 result->i_ino = fno;
310 hpfs_init_inode(result);
311 hpfs_i(result)->i_parent_dir = dir->i_ino;
Mikulas Patocka0b697602011-05-08 20:44:26 +0200312 result->i_ctime.tv_sec = result->i_mtime.tv_sec = result->i_atime.tv_sec = local_to_gmt(dir->i_sb, le32_to_cpu(dee.creation_date));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313 result->i_ctime.tv_nsec = 0;
314 result->i_mtime.tv_nsec = 0;
315 result->i_atime.tv_nsec = 0;
316 hpfs_i(result)->i_ea_size = 0;
317 result->i_mode = S_IFLNK | 0777;
David Howellsde395b82008-11-14 10:38:55 +1100318 result->i_uid = current_fsuid();
319 result->i_gid = current_fsgid();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320 result->i_blocks = 1;
Miklos Szeredibfe86842011-10-28 14:13:29 +0200321 set_nlink(result, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322 result->i_size = strlen(symlink);
323 result->i_op = &page_symlink_inode_operations;
324 result->i_data.a_ops = &hpfs_symlink_aops;
325
Mikulas Patocka7d23ce32011-05-08 20:43:06 +0200326 r = hpfs_add_dirent(dir, name, len, &dee);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327 if (r == 1)
328 goto bail2;
329 if (r == -1) {
330 err = -EEXIST;
331 goto bail2;
332 }
333 fnode->len = len;
334 memcpy(fnode->name, name, len > 15 ? 15 : len);
Mikulas Patocka0b697602011-05-08 20:44:26 +0200335 fnode->up = cpu_to_le32(dir->i_ino);
Al Viro7e7742e2010-01-31 17:09:29 -0500336 hpfs_set_ea(result, fnode, "SYMLINK", symlink, strlen(symlink));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337 mark_buffer_dirty(bh);
338 brelse(bh);
339
340 insert_inode_hash(result);
341
342 hpfs_write_inode_nolock(result);
343 d_instantiate(dentry, result);
Arnd Bergmann9a311b92011-01-22 20:26:12 +0100344 hpfs_unlock(dir->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345 return 0;
346bail2:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347 iput(result);
348bail1:
349 brelse(bh);
350 hpfs_free_sectors(dir->i_sb, fno, 1);
351bail:
Arnd Bergmann9a311b92011-01-22 20:26:12 +0100352 hpfs_unlock(dir->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353 return err;
354}
355
356static int hpfs_unlink(struct inode *dir, struct dentry *dentry)
357{
Al Viro7e7742e2010-01-31 17:09:29 -0500358 const unsigned char *name = dentry->d_name.name;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359 unsigned len = dentry->d_name.len;
360 struct quad_buffer_head qbh;
361 struct hpfs_dirent *de;
362 struct inode *inode = dentry->d_inode;
363 dnode_secno dno;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364 int r;
365 int rep = 0;
366 int err;
367
Arnd Bergmann9a311b92011-01-22 20:26:12 +0100368 hpfs_lock(dir->i_sb);
Al Viro7e7742e2010-01-31 17:09:29 -0500369 hpfs_adjust_length(name, &len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370again:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371 err = -ENOENT;
Al Viro7e7742e2010-01-31 17:09:29 -0500372 de = map_dirent(dir, hpfs_i(dir)->i_dno, name, len, &dno, &qbh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373 if (!de)
374 goto out;
375
376 err = -EPERM;
377 if (de->first)
378 goto out1;
379
380 err = -EISDIR;
381 if (de->directory)
382 goto out1;
383
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384 r = hpfs_remove_dirent(dir, dno, de, &qbh, 1);
385 switch (r) {
386 case 1:
387 hpfs_error(dir->i_sb, "there was error when removing dirent");
388 err = -EFSERROR;
389 break;
390 case 2: /* no space for deleting, try to truncate file */
391
392 err = -ENOSPC;
393 if (rep++)
394 break;
395
Al Viroe21e7092010-02-01 11:05:16 -0500396 dentry_unhash(dentry);
397 if (!d_unhashed(dentry)) {
Arnd Bergmann9a311b92011-01-22 20:26:12 +0100398 hpfs_unlock(dir->i_sb);
Al Viroe21e7092010-02-01 11:05:16 -0500399 return -ENOSPC;
400 }
Al Viro2830ba72011-06-20 19:16:29 -0400401 if (generic_permission(inode, MAY_WRITE) ||
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402 !S_ISREG(inode->i_mode) ||
403 get_write_access(inode)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700404 d_rehash(dentry);
405 } else {
406 struct iattr newattrs;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407 /*printk("HPFS: truncating file before delete.\n");*/
408 newattrs.ia_size = 0;
409 newattrs.ia_valid = ATTR_SIZE | ATTR_CTIME;
410 err = notify_change(dentry, &newattrs);
411 put_write_access(inode);
412 if (!err)
413 goto again;
414 }
Arnd Bergmann9a311b92011-01-22 20:26:12 +0100415 hpfs_unlock(dir->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416 return -ENOSPC;
417 default:
Dave Hansen9a53c3a2006-09-30 23:29:03 -0700418 drop_nlink(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419 err = 0;
420 }
421 goto out;
422
423out1:
424 hpfs_brelse4(&qbh);
425out:
Arnd Bergmann9a311b92011-01-22 20:26:12 +0100426 hpfs_unlock(dir->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427 return err;
428}
429
430static int hpfs_rmdir(struct inode *dir, struct dentry *dentry)
431{
Al Viro7e7742e2010-01-31 17:09:29 -0500432 const unsigned char *name = dentry->d_name.name;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433 unsigned len = dentry->d_name.len;
434 struct quad_buffer_head qbh;
435 struct hpfs_dirent *de;
436 struct inode *inode = dentry->d_inode;
437 dnode_secno dno;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438 int n_items = 0;
439 int err;
440 int r;
441
Al Viro7e7742e2010-01-31 17:09:29 -0500442 hpfs_adjust_length(name, &len);
Arnd Bergmann9a311b92011-01-22 20:26:12 +0100443 hpfs_lock(dir->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444 err = -ENOENT;
Al Viro7e7742e2010-01-31 17:09:29 -0500445 de = map_dirent(dir, hpfs_i(dir)->i_dno, name, len, &dno, &qbh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700446 if (!de)
447 goto out;
448
449 err = -EPERM;
450 if (de->first)
451 goto out1;
452
453 err = -ENOTDIR;
454 if (!de->directory)
455 goto out1;
456
457 hpfs_count_dnodes(dir->i_sb, hpfs_i(inode)->i_dno, NULL, NULL, &n_items);
458 err = -ENOTEMPTY;
459 if (n_items)
460 goto out1;
461
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462 r = hpfs_remove_dirent(dir, dno, de, &qbh, 1);
463 switch (r) {
464 case 1:
465 hpfs_error(dir->i_sb, "there was error when removing dirent");
466 err = -EFSERROR;
467 break;
468 case 2:
469 err = -ENOSPC;
470 break;
471 default:
Dave Hansen9a53c3a2006-09-30 23:29:03 -0700472 drop_nlink(dir);
Dave Hansence71ec32006-09-30 23:29:06 -0700473 clear_nlink(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474 err = 0;
475 }
476 goto out;
477out1:
478 hpfs_brelse4(&qbh);
479out:
Arnd Bergmann9a311b92011-01-22 20:26:12 +0100480 hpfs_unlock(dir->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481 return err;
482}
483
484static int hpfs_symlink_readpage(struct file *file, struct page *page)
485{
486 char *link = kmap(page);
487 struct inode *i = page->mapping->host;
488 struct fnode *fnode;
489 struct buffer_head *bh;
490 int err;
491
492 err = -EIO;
Arnd Bergmann9a311b92011-01-22 20:26:12 +0100493 hpfs_lock(i->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494 if (!(fnode = hpfs_map_fnode(i->i_sb, i->i_ino, &bh)))
495 goto fail;
496 err = hpfs_read_ea(i->i_sb, fnode, "SYMLINK", link, PAGE_SIZE);
497 brelse(bh);
498 if (err)
499 goto fail;
Arnd Bergmann9a311b92011-01-22 20:26:12 +0100500 hpfs_unlock(i->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501 SetPageUptodate(page);
502 kunmap(page);
503 unlock_page(page);
504 return 0;
505
506fail:
Arnd Bergmann9a311b92011-01-22 20:26:12 +0100507 hpfs_unlock(i->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508 SetPageError(page);
509 kunmap(page);
510 unlock_page(page);
511 return err;
512}
513
Christoph Hellwigf5e54d62006-06-28 04:26:44 -0700514const struct address_space_operations hpfs_symlink_aops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515 .readpage = hpfs_symlink_readpage
516};
517
518static int hpfs_rename(struct inode *old_dir, struct dentry *old_dentry,
519 struct inode *new_dir, struct dentry *new_dentry)
520{
Al Viro7e7742e2010-01-31 17:09:29 -0500521 const unsigned char *old_name = old_dentry->d_name.name;
522 unsigned old_len = old_dentry->d_name.len;
523 const unsigned char *new_name = new_dentry->d_name.name;
524 unsigned new_len = new_dentry->d_name.len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525 struct inode *i = old_dentry->d_inode;
526 struct inode *new_inode = new_dentry->d_inode;
527 struct quad_buffer_head qbh, qbh1;
528 struct hpfs_dirent *dep, *nde;
529 struct hpfs_dirent de;
530 dnode_secno dno;
531 int r;
532 struct buffer_head *bh;
533 struct fnode *fnode;
534 int err;
Sage Weile4eaac02011-05-24 13:06:07 -0700535
Al Viro7e7742e2010-01-31 17:09:29 -0500536 if ((err = hpfs_chk_name(new_name, &new_len))) return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537 err = 0;
Al Viro7e7742e2010-01-31 17:09:29 -0500538 hpfs_adjust_length(old_name, &old_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539
Arnd Bergmann9a311b92011-01-22 20:26:12 +0100540 hpfs_lock(i->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700541 /* order doesn't matter, due to VFS exclusion */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542
543 /* Erm? Moving over the empty non-busy directory is perfectly legal */
544 if (new_inode && S_ISDIR(new_inode->i_mode)) {
545 err = -EINVAL;
546 goto end1;
547 }
548
Al Viro7e7742e2010-01-31 17:09:29 -0500549 if (!(dep = map_dirent(old_dir, hpfs_i(old_dir)->i_dno, old_name, old_len, &dno, &qbh))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550 hpfs_error(i->i_sb, "lookup succeeded but map dirent failed");
551 err = -ENOENT;
552 goto end1;
553 }
554 copy_de(&de, dep);
555 de.hidden = new_name[0] == '.';
556
557 if (new_inode) {
558 int r;
559 if ((r = hpfs_remove_dirent(old_dir, dno, dep, &qbh, 1)) != 2) {
Al Viro7e7742e2010-01-31 17:09:29 -0500560 if ((nde = map_dirent(new_dir, hpfs_i(new_dir)->i_dno, new_name, new_len, NULL, &qbh1))) {
Dave Hansence71ec32006-09-30 23:29:06 -0700561 clear_nlink(new_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562 copy_de(nde, &de);
563 memcpy(nde->name, new_name, new_len);
564 hpfs_mark_4buffers_dirty(&qbh1);
565 hpfs_brelse4(&qbh1);
566 goto end;
567 }
568 hpfs_error(new_dir->i_sb, "hpfs_rename: could not find dirent");
569 err = -EFSERROR;
570 goto end1;
571 }
572 err = r == 2 ? -ENOSPC : r == 1 ? -EFSERROR : 0;
573 goto end1;
574 }
575
576 if (new_dir == old_dir) hpfs_brelse4(&qbh);
577
Mikulas Patocka7d23ce32011-05-08 20:43:06 +0200578 if ((r = hpfs_add_dirent(new_dir, new_name, new_len, &de))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579 if (r == -1) hpfs_error(new_dir->i_sb, "hpfs_rename: dirent already exists!");
580 err = r == 1 ? -ENOSPC : -EFSERROR;
581 if (new_dir != old_dir) hpfs_brelse4(&qbh);
582 goto end1;
583 }
584
585 if (new_dir == old_dir)
Al Viro7e7742e2010-01-31 17:09:29 -0500586 if (!(dep = map_dirent(old_dir, hpfs_i(old_dir)->i_dno, old_name, old_len, &dno, &qbh))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587 hpfs_error(i->i_sb, "lookup succeeded but map dirent failed at #2");
588 err = -ENOENT;
589 goto end1;
590 }
591
592 if ((r = hpfs_remove_dirent(old_dir, dno, dep, &qbh, 0))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593 hpfs_error(i->i_sb, "hpfs_rename: could not remove dirent");
594 err = r == 2 ? -ENOSPC : -EFSERROR;
595 goto end1;
596 }
Mikulas Patocka7d23ce32011-05-08 20:43:06 +0200597
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598 end:
599 hpfs_i(i)->i_parent_dir = new_dir->i_ino;
600 if (S_ISDIR(i->i_mode)) {
Dave Hansend8c76e62006-09-30 23:29:04 -0700601 inc_nlink(new_dir);
Dave Hansen9a53c3a2006-09-30 23:29:03 -0700602 drop_nlink(old_dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700603 }
604 if ((fnode = hpfs_map_fnode(i->i_sb, i->i_ino, &bh))) {
Mikulas Patocka0b697602011-05-08 20:44:26 +0200605 fnode->up = cpu_to_le32(new_dir->i_ino);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606 fnode->len = new_len;
607 memcpy(fnode->name, new_name, new_len>15?15:new_len);
608 if (new_len < 15) memset(&fnode->name[new_len], 0, 15 - new_len);
609 mark_buffer_dirty(bh);
610 brelse(bh);
611 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612end1:
Arnd Bergmann9a311b92011-01-22 20:26:12 +0100613 hpfs_unlock(i->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614 return err;
615}
616
Arjan van de Ven92e1d5b2007-02-12 00:55:39 -0800617const struct inode_operations hpfs_dir_iops =
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618{
619 .create = hpfs_create,
620 .lookup = hpfs_lookup,
621 .unlink = hpfs_unlink,
622 .symlink = hpfs_symlink,
623 .mkdir = hpfs_mkdir,
624 .rmdir = hpfs_rmdir,
625 .mknod = hpfs_mknod,
626 .rename = hpfs_rename,
Christoph Hellwigca30bc92008-08-11 00:27:59 +0200627 .setattr = hpfs_setattr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700628};