blob: d3db95f51a4e339a49295dc819898bc1e0532ab5 [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
11static int hpfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
12{
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;
32 dnode = hpfs_alloc_dnode(dir->i_sb, fno, &dno, &qbh0, 1);
33 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] == '.';
40 dee.fnode = fno;
41 dee.creation_date = dee.write_date = dee.read_date = gmt_to_local(dir->i_sb, get_seconds());
42 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;
49 result->i_ctime.tv_sec = result->i_mtime.tv_sec = result->i_atime.tv_sec = local_to_gmt(dir->i_sb, dee.creation_date);
50 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;
59 result->i_nlink = 2;
60 if (dee.read_only)
61 result->i_mode &= ~0222;
62
Ingo Molnar7bf6d782006-03-23 03:00:42 -080063 mutex_lock(&hpfs_i(dir)->i_mutex);
Al Viro7e7742e2010-01-31 17:09:29 -050064 r = hpfs_add_dirent(dir, name, len, &dee, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -070065 if (r == 1)
66 goto bail3;
67 if (r == -1) {
68 err = -EEXIST;
69 goto bail3;
70 }
71 fnode->len = len;
72 memcpy(fnode->name, name, len > 15 ? 15 : len);
73 fnode->up = dir->i_ino;
74 fnode->dirflag = 1;
75 fnode->btree.n_free_nodes = 7;
76 fnode->btree.n_used_nodes = 1;
77 fnode->btree.first_free = 0x14;
78 fnode->u.external[0].disk_secno = dno;
79 fnode->u.external[0].file_secno = -1;
80 dnode->root_dnode = 1;
81 dnode->up = fno;
82 de = hpfs_add_de(dir->i_sb, dnode, "\001\001", 2, 0);
83 de->creation_date = de->write_date = de->read_date = gmt_to_local(dir->i_sb, get_seconds());
84 if (!(mode & 0222)) de->read_only = 1;
85 de->first = de->directory = 1;
86 /*de->hidden = de->system = 0;*/
87 de->fnode = fno;
88 mark_buffer_dirty(bh);
89 brelse(bh);
90 hpfs_mark_4buffers_dirty(&qbh0);
91 hpfs_brelse4(&qbh0);
Dave Hansend8c76e62006-09-30 23:29:04 -070092 inc_nlink(dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -070093 insert_inode_hash(result);
94
David Howellsde395b82008-11-14 10:38:55 +110095 if (result->i_uid != current_fsuid() ||
96 result->i_gid != current_fsgid() ||
Linus Torvalds1da177e2005-04-16 15:20:36 -070097 result->i_mode != (mode | S_IFDIR)) {
David Howellsde395b82008-11-14 10:38:55 +110098 result->i_uid = current_fsuid();
99 result->i_gid = current_fsgid();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100 result->i_mode = mode | S_IFDIR;
101 hpfs_write_inode_nolock(result);
102 }
103 d_instantiate(dentry, result);
Ingo Molnar7bf6d782006-03-23 03:00:42 -0800104 mutex_unlock(&hpfs_i(dir)->i_mutex);
Arnd Bergmann9a311b92011-01-22 20:26:12 +0100105 hpfs_unlock(dir->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106 return 0;
107bail3:
Ingo Molnar7bf6d782006-03-23 03:00:42 -0800108 mutex_unlock(&hpfs_i(dir)->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109 iput(result);
110bail2:
111 hpfs_brelse4(&qbh0);
112 hpfs_free_dnode(dir->i_sb, dno);
113bail1:
114 brelse(bh);
115 hpfs_free_sectors(dir->i_sb, fno, 1);
116bail:
Arnd Bergmann9a311b92011-01-22 20:26:12 +0100117 hpfs_unlock(dir->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118 return err;
119}
120
121static int hpfs_create(struct inode *dir, struct dentry *dentry, int mode, struct nameidata *nd)
122{
Al Viro7e7742e2010-01-31 17:09:29 -0500123 const unsigned char *name = dentry->d_name.name;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124 unsigned len = dentry->d_name.len;
125 struct inode *result = NULL;
126 struct buffer_head *bh;
127 struct fnode *fnode;
128 fnode_secno fno;
129 int r;
130 struct hpfs_dirent dee;
131 int err;
Al Viro7e7742e2010-01-31 17:09:29 -0500132 if ((err = hpfs_chk_name(name, &len)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133 return err==-ENOENT ? -EINVAL : err;
Arnd Bergmann9a311b92011-01-22 20:26:12 +0100134 hpfs_lock(dir->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135 err = -ENOSPC;
136 fnode = hpfs_alloc_fnode(dir->i_sb, hpfs_i(dir)->i_dno, &fno, &bh);
137 if (!fnode)
138 goto bail;
139 memset(&dee, 0, sizeof dee);
140 if (!(mode & 0222)) dee.read_only = 1;
141 dee.archive = 1;
142 dee.hidden = name[0] == '.';
143 dee.fnode = fno;
144 dee.creation_date = dee.write_date = dee.read_date = gmt_to_local(dir->i_sb, get_seconds());
145
146 result = new_inode(dir->i_sb);
147 if (!result)
148 goto bail1;
149
150 hpfs_init_inode(result);
151 result->i_ino = fno;
152 result->i_mode |= S_IFREG;
153 result->i_mode &= ~0111;
154 result->i_op = &hpfs_file_iops;
155 result->i_fop = &hpfs_file_ops;
156 result->i_nlink = 1;
Al Viro7e7742e2010-01-31 17:09:29 -0500157 hpfs_decide_conv(result, name, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158 hpfs_i(result)->i_parent_dir = dir->i_ino;
159 result->i_ctime.tv_sec = result->i_mtime.tv_sec = result->i_atime.tv_sec = local_to_gmt(dir->i_sb, dee.creation_date);
160 result->i_ctime.tv_nsec = 0;
161 result->i_mtime.tv_nsec = 0;
162 result->i_atime.tv_nsec = 0;
163 hpfs_i(result)->i_ea_size = 0;
164 if (dee.read_only)
165 result->i_mode &= ~0222;
166 result->i_blocks = 1;
167 result->i_size = 0;
168 result->i_data.a_ops = &hpfs_aops;
169 hpfs_i(result)->mmu_private = 0;
170
Ingo Molnar7bf6d782006-03-23 03:00:42 -0800171 mutex_lock(&hpfs_i(dir)->i_mutex);
Al Viro7e7742e2010-01-31 17:09:29 -0500172 r = hpfs_add_dirent(dir, name, len, &dee, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173 if (r == 1)
174 goto bail2;
175 if (r == -1) {
176 err = -EEXIST;
177 goto bail2;
178 }
179 fnode->len = len;
180 memcpy(fnode->name, name, len > 15 ? 15 : len);
181 fnode->up = dir->i_ino;
182 mark_buffer_dirty(bh);
183 brelse(bh);
184
185 insert_inode_hash(result);
186
David Howellsde395b82008-11-14 10:38:55 +1100187 if (result->i_uid != current_fsuid() ||
188 result->i_gid != current_fsgid() ||
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189 result->i_mode != (mode | S_IFREG)) {
David Howellsde395b82008-11-14 10:38:55 +1100190 result->i_uid = current_fsuid();
191 result->i_gid = current_fsgid();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192 result->i_mode = mode | S_IFREG;
193 hpfs_write_inode_nolock(result);
194 }
195 d_instantiate(dentry, result);
Ingo Molnar7bf6d782006-03-23 03:00:42 -0800196 mutex_unlock(&hpfs_i(dir)->i_mutex);
Arnd Bergmann9a311b92011-01-22 20:26:12 +0100197 hpfs_unlock(dir->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198 return 0;
199
200bail2:
Ingo Molnar7bf6d782006-03-23 03:00:42 -0800201 mutex_unlock(&hpfs_i(dir)->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202 iput(result);
203bail1:
204 brelse(bh);
205 hpfs_free_sectors(dir->i_sb, fno, 1);
206bail:
Arnd Bergmann9a311b92011-01-22 20:26:12 +0100207 hpfs_unlock(dir->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208 return err;
209}
210
211static int hpfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t rdev)
212{
Al Viro7e7742e2010-01-31 17:09:29 -0500213 const unsigned char *name = dentry->d_name.name;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214 unsigned len = dentry->d_name.len;
215 struct buffer_head *bh;
216 struct fnode *fnode;
217 fnode_secno fno;
218 int r;
219 struct hpfs_dirent dee;
220 struct inode *result = NULL;
221 int err;
Al Viro7e7742e2010-01-31 17:09:29 -0500222 if ((err = hpfs_chk_name(name, &len))) return err==-ENOENT ? -EINVAL : err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223 if (hpfs_sb(dir->i_sb)->sb_eas < 2) return -EPERM;
224 if (!new_valid_dev(rdev))
225 return -EINVAL;
Arnd Bergmann9a311b92011-01-22 20:26:12 +0100226 hpfs_lock(dir->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227 err = -ENOSPC;
228 fnode = hpfs_alloc_fnode(dir->i_sb, hpfs_i(dir)->i_dno, &fno, &bh);
229 if (!fnode)
230 goto bail;
231 memset(&dee, 0, sizeof dee);
232 if (!(mode & 0222)) dee.read_only = 1;
233 dee.archive = 1;
234 dee.hidden = name[0] == '.';
235 dee.fnode = fno;
236 dee.creation_date = dee.write_date = dee.read_date = gmt_to_local(dir->i_sb, get_seconds());
237
238 result = new_inode(dir->i_sb);
239 if (!result)
240 goto bail1;
241
242 hpfs_init_inode(result);
243 result->i_ino = fno;
244 hpfs_i(result)->i_parent_dir = dir->i_ino;
245 result->i_ctime.tv_sec = result->i_mtime.tv_sec = result->i_atime.tv_sec = local_to_gmt(dir->i_sb, dee.creation_date);
246 result->i_ctime.tv_nsec = 0;
247 result->i_mtime.tv_nsec = 0;
248 result->i_atime.tv_nsec = 0;
249 hpfs_i(result)->i_ea_size = 0;
David Howellsde395b82008-11-14 10:38:55 +1100250 result->i_uid = current_fsuid();
251 result->i_gid = current_fsgid();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252 result->i_nlink = 1;
253 result->i_size = 0;
254 result->i_blocks = 1;
255 init_special_inode(result, mode, rdev);
256
Ingo Molnar7bf6d782006-03-23 03:00:42 -0800257 mutex_lock(&hpfs_i(dir)->i_mutex);
Al Viro7e7742e2010-01-31 17:09:29 -0500258 r = hpfs_add_dirent(dir, name, len, &dee, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259 if (r == 1)
260 goto bail2;
261 if (r == -1) {
262 err = -EEXIST;
263 goto bail2;
264 }
265 fnode->len = len;
266 memcpy(fnode->name, name, len > 15 ? 15 : len);
267 fnode->up = dir->i_ino;
268 mark_buffer_dirty(bh);
269
270 insert_inode_hash(result);
271
272 hpfs_write_inode_nolock(result);
273 d_instantiate(dentry, result);
Ingo Molnar7bf6d782006-03-23 03:00:42 -0800274 mutex_unlock(&hpfs_i(dir)->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275 brelse(bh);
Arnd Bergmann9a311b92011-01-22 20:26:12 +0100276 hpfs_unlock(dir->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277 return 0;
278bail2:
Ingo Molnar7bf6d782006-03-23 03:00:42 -0800279 mutex_unlock(&hpfs_i(dir)->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280 iput(result);
281bail1:
282 brelse(bh);
283 hpfs_free_sectors(dir->i_sb, fno, 1);
284bail:
Arnd Bergmann9a311b92011-01-22 20:26:12 +0100285 hpfs_unlock(dir->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286 return err;
287}
288
289static int hpfs_symlink(struct inode *dir, struct dentry *dentry, const char *symlink)
290{
Al Viro7e7742e2010-01-31 17:09:29 -0500291 const unsigned char *name = dentry->d_name.name;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292 unsigned len = dentry->d_name.len;
293 struct buffer_head *bh;
294 struct fnode *fnode;
295 fnode_secno fno;
296 int r;
297 struct hpfs_dirent dee;
298 struct inode *result;
299 int err;
Al Viro7e7742e2010-01-31 17:09:29 -0500300 if ((err = hpfs_chk_name(name, &len))) return err==-ENOENT ? -EINVAL : err;
Arnd Bergmann9a311b92011-01-22 20:26:12 +0100301 hpfs_lock(dir->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302 if (hpfs_sb(dir->i_sb)->sb_eas < 2) {
Arnd Bergmann9a311b92011-01-22 20:26:12 +0100303 hpfs_unlock(dir->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304 return -EPERM;
305 }
306 err = -ENOSPC;
307 fnode = hpfs_alloc_fnode(dir->i_sb, hpfs_i(dir)->i_dno, &fno, &bh);
308 if (!fnode)
309 goto bail;
310 memset(&dee, 0, sizeof dee);
311 dee.archive = 1;
312 dee.hidden = name[0] == '.';
313 dee.fnode = fno;
314 dee.creation_date = dee.write_date = dee.read_date = gmt_to_local(dir->i_sb, get_seconds());
315
316 result = new_inode(dir->i_sb);
317 if (!result)
318 goto bail1;
319 result->i_ino = fno;
320 hpfs_init_inode(result);
321 hpfs_i(result)->i_parent_dir = dir->i_ino;
322 result->i_ctime.tv_sec = result->i_mtime.tv_sec = result->i_atime.tv_sec = local_to_gmt(dir->i_sb, dee.creation_date);
323 result->i_ctime.tv_nsec = 0;
324 result->i_mtime.tv_nsec = 0;
325 result->i_atime.tv_nsec = 0;
326 hpfs_i(result)->i_ea_size = 0;
327 result->i_mode = S_IFLNK | 0777;
David Howellsde395b82008-11-14 10:38:55 +1100328 result->i_uid = current_fsuid();
329 result->i_gid = current_fsgid();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330 result->i_blocks = 1;
331 result->i_nlink = 1;
332 result->i_size = strlen(symlink);
333 result->i_op = &page_symlink_inode_operations;
334 result->i_data.a_ops = &hpfs_symlink_aops;
335
Ingo Molnar7bf6d782006-03-23 03:00:42 -0800336 mutex_lock(&hpfs_i(dir)->i_mutex);
Al Viro7e7742e2010-01-31 17:09:29 -0500337 r = hpfs_add_dirent(dir, name, len, &dee, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338 if (r == 1)
339 goto bail2;
340 if (r == -1) {
341 err = -EEXIST;
342 goto bail2;
343 }
344 fnode->len = len;
345 memcpy(fnode->name, name, len > 15 ? 15 : len);
346 fnode->up = dir->i_ino;
Al Viro7e7742e2010-01-31 17:09:29 -0500347 hpfs_set_ea(result, fnode, "SYMLINK", symlink, strlen(symlink));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348 mark_buffer_dirty(bh);
349 brelse(bh);
350
351 insert_inode_hash(result);
352
353 hpfs_write_inode_nolock(result);
354 d_instantiate(dentry, result);
Ingo Molnar7bf6d782006-03-23 03:00:42 -0800355 mutex_unlock(&hpfs_i(dir)->i_mutex);
Arnd Bergmann9a311b92011-01-22 20:26:12 +0100356 hpfs_unlock(dir->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357 return 0;
358bail2:
Ingo Molnar7bf6d782006-03-23 03:00:42 -0800359 mutex_unlock(&hpfs_i(dir)->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360 iput(result);
361bail1:
362 brelse(bh);
363 hpfs_free_sectors(dir->i_sb, fno, 1);
364bail:
Arnd Bergmann9a311b92011-01-22 20:26:12 +0100365 hpfs_unlock(dir->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366 return err;
367}
368
369static int hpfs_unlink(struct inode *dir, struct dentry *dentry)
370{
Al Viro7e7742e2010-01-31 17:09:29 -0500371 const unsigned char *name = dentry->d_name.name;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372 unsigned len = dentry->d_name.len;
373 struct quad_buffer_head qbh;
374 struct hpfs_dirent *de;
375 struct inode *inode = dentry->d_inode;
376 dnode_secno dno;
377 fnode_secno fno;
378 int r;
379 int rep = 0;
380 int err;
381
Arnd Bergmann9a311b92011-01-22 20:26:12 +0100382 hpfs_lock(dir->i_sb);
Al Viro7e7742e2010-01-31 17:09:29 -0500383 hpfs_adjust_length(name, &len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384again:
Ingo Molnar7bf6d782006-03-23 03:00:42 -0800385 mutex_lock(&hpfs_i(inode)->i_parent_mutex);
386 mutex_lock(&hpfs_i(dir)->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387 err = -ENOENT;
Al Viro7e7742e2010-01-31 17:09:29 -0500388 de = map_dirent(dir, hpfs_i(dir)->i_dno, name, len, &dno, &qbh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389 if (!de)
390 goto out;
391
392 err = -EPERM;
393 if (de->first)
394 goto out1;
395
396 err = -EISDIR;
397 if (de->directory)
398 goto out1;
399
400 fno = de->fnode;
401 r = hpfs_remove_dirent(dir, dno, de, &qbh, 1);
402 switch (r) {
403 case 1:
404 hpfs_error(dir->i_sb, "there was error when removing dirent");
405 err = -EFSERROR;
406 break;
407 case 2: /* no space for deleting, try to truncate file */
408
409 err = -ENOSPC;
410 if (rep++)
411 break;
412
Ingo Molnar7bf6d782006-03-23 03:00:42 -0800413 mutex_unlock(&hpfs_i(dir)->i_mutex);
414 mutex_unlock(&hpfs_i(inode)->i_parent_mutex);
Al Viroe21e7092010-02-01 11:05:16 -0500415 dentry_unhash(dentry);
416 if (!d_unhashed(dentry)) {
Arnd Bergmann9a311b92011-01-22 20:26:12 +0100417 hpfs_unlock(dir->i_sb);
Al Viroe21e7092010-02-01 11:05:16 -0500418 return -ENOSPC;
419 }
Nick Pigginb74c79e2011-01-07 17:49:58 +1100420 if (generic_permission(inode, MAY_WRITE, 0, NULL) ||
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421 !S_ISREG(inode->i_mode) ||
422 get_write_access(inode)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423 d_rehash(dentry);
424 } else {
425 struct iattr newattrs;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426 /*printk("HPFS: truncating file before delete.\n");*/
427 newattrs.ia_size = 0;
428 newattrs.ia_valid = ATTR_SIZE | ATTR_CTIME;
429 err = notify_change(dentry, &newattrs);
430 put_write_access(inode);
431 if (!err)
432 goto again;
433 }
Arnd Bergmann9a311b92011-01-22 20:26:12 +0100434 hpfs_unlock(dir->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435 return -ENOSPC;
436 default:
Dave Hansen9a53c3a2006-09-30 23:29:03 -0700437 drop_nlink(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438 err = 0;
439 }
440 goto out;
441
442out1:
443 hpfs_brelse4(&qbh);
444out:
Ingo Molnar7bf6d782006-03-23 03:00:42 -0800445 mutex_unlock(&hpfs_i(dir)->i_mutex);
446 mutex_unlock(&hpfs_i(inode)->i_parent_mutex);
Arnd Bergmann9a311b92011-01-22 20:26:12 +0100447 hpfs_unlock(dir->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448 return err;
449}
450
451static int hpfs_rmdir(struct inode *dir, struct dentry *dentry)
452{
Al Viro7e7742e2010-01-31 17:09:29 -0500453 const unsigned char *name = dentry->d_name.name;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454 unsigned len = dentry->d_name.len;
455 struct quad_buffer_head qbh;
456 struct hpfs_dirent *de;
457 struct inode *inode = dentry->d_inode;
458 dnode_secno dno;
459 fnode_secno fno;
460 int n_items = 0;
461 int err;
462 int r;
463
Sage Weil79bf7c72011-05-24 13:06:06 -0700464 dentry_unhash(dentry);
465
Al Viro7e7742e2010-01-31 17:09:29 -0500466 hpfs_adjust_length(name, &len);
Arnd Bergmann9a311b92011-01-22 20:26:12 +0100467 hpfs_lock(dir->i_sb);
Ingo Molnar7bf6d782006-03-23 03:00:42 -0800468 mutex_lock(&hpfs_i(inode)->i_parent_mutex);
469 mutex_lock(&hpfs_i(dir)->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470 err = -ENOENT;
Al Viro7e7742e2010-01-31 17:09:29 -0500471 de = map_dirent(dir, hpfs_i(dir)->i_dno, name, len, &dno, &qbh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472 if (!de)
473 goto out;
474
475 err = -EPERM;
476 if (de->first)
477 goto out1;
478
479 err = -ENOTDIR;
480 if (!de->directory)
481 goto out1;
482
483 hpfs_count_dnodes(dir->i_sb, hpfs_i(inode)->i_dno, NULL, NULL, &n_items);
484 err = -ENOTEMPTY;
485 if (n_items)
486 goto out1;
487
488 fno = de->fnode;
489 r = hpfs_remove_dirent(dir, dno, de, &qbh, 1);
490 switch (r) {
491 case 1:
492 hpfs_error(dir->i_sb, "there was error when removing dirent");
493 err = -EFSERROR;
494 break;
495 case 2:
496 err = -ENOSPC;
497 break;
498 default:
Dave Hansen9a53c3a2006-09-30 23:29:03 -0700499 drop_nlink(dir);
Dave Hansence71ec32006-09-30 23:29:06 -0700500 clear_nlink(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501 err = 0;
502 }
503 goto out;
504out1:
505 hpfs_brelse4(&qbh);
506out:
Ingo Molnar7bf6d782006-03-23 03:00:42 -0800507 mutex_unlock(&hpfs_i(dir)->i_mutex);
508 mutex_unlock(&hpfs_i(inode)->i_parent_mutex);
Arnd Bergmann9a311b92011-01-22 20:26:12 +0100509 hpfs_unlock(dir->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510 return err;
511}
512
513static int hpfs_symlink_readpage(struct file *file, struct page *page)
514{
515 char *link = kmap(page);
516 struct inode *i = page->mapping->host;
517 struct fnode *fnode;
518 struct buffer_head *bh;
519 int err;
520
521 err = -EIO;
Arnd Bergmann9a311b92011-01-22 20:26:12 +0100522 hpfs_lock(i->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523 if (!(fnode = hpfs_map_fnode(i->i_sb, i->i_ino, &bh)))
524 goto fail;
525 err = hpfs_read_ea(i->i_sb, fnode, "SYMLINK", link, PAGE_SIZE);
526 brelse(bh);
527 if (err)
528 goto fail;
Arnd Bergmann9a311b92011-01-22 20:26:12 +0100529 hpfs_unlock(i->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530 SetPageUptodate(page);
531 kunmap(page);
532 unlock_page(page);
533 return 0;
534
535fail:
Arnd Bergmann9a311b92011-01-22 20:26:12 +0100536 hpfs_unlock(i->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537 SetPageError(page);
538 kunmap(page);
539 unlock_page(page);
540 return err;
541}
542
Christoph Hellwigf5e54d62006-06-28 04:26:44 -0700543const struct address_space_operations hpfs_symlink_aops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544 .readpage = hpfs_symlink_readpage
545};
546
547static int hpfs_rename(struct inode *old_dir, struct dentry *old_dentry,
548 struct inode *new_dir, struct dentry *new_dentry)
549{
Al Viro7e7742e2010-01-31 17:09:29 -0500550 const unsigned char *old_name = old_dentry->d_name.name;
551 unsigned old_len = old_dentry->d_name.len;
552 const unsigned char *new_name = new_dentry->d_name.name;
553 unsigned new_len = new_dentry->d_name.len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554 struct inode *i = old_dentry->d_inode;
555 struct inode *new_inode = new_dentry->d_inode;
556 struct quad_buffer_head qbh, qbh1;
557 struct hpfs_dirent *dep, *nde;
558 struct hpfs_dirent de;
559 dnode_secno dno;
560 int r;
561 struct buffer_head *bh;
562 struct fnode *fnode;
563 int err;
Sage Weile4eaac02011-05-24 13:06:07 -0700564
565 if (new_inode && S_ISDIR(new_inode->i_mode))
566 dentry_unhash(new_dentry);
567
Al Viro7e7742e2010-01-31 17:09:29 -0500568 if ((err = hpfs_chk_name(new_name, &new_len))) return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569 err = 0;
Al Viro7e7742e2010-01-31 17:09:29 -0500570 hpfs_adjust_length(old_name, &old_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700571
Arnd Bergmann9a311b92011-01-22 20:26:12 +0100572 hpfs_lock(i->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573 /* order doesn't matter, due to VFS exclusion */
Ingo Molnar7bf6d782006-03-23 03:00:42 -0800574 mutex_lock(&hpfs_i(i)->i_parent_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575 if (new_inode)
Ingo Molnar7bf6d782006-03-23 03:00:42 -0800576 mutex_lock(&hpfs_i(new_inode)->i_parent_mutex);
577 mutex_lock(&hpfs_i(old_dir)->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578 if (new_dir != old_dir)
Ingo Molnar7bf6d782006-03-23 03:00:42 -0800579 mutex_lock(&hpfs_i(new_dir)->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580
581 /* Erm? Moving over the empty non-busy directory is perfectly legal */
582 if (new_inode && S_ISDIR(new_inode->i_mode)) {
583 err = -EINVAL;
584 goto end1;
585 }
586
Al Viro7e7742e2010-01-31 17:09:29 -0500587 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 -0700588 hpfs_error(i->i_sb, "lookup succeeded but map dirent failed");
589 err = -ENOENT;
590 goto end1;
591 }
592 copy_de(&de, dep);
593 de.hidden = new_name[0] == '.';
594
595 if (new_inode) {
596 int r;
597 if ((r = hpfs_remove_dirent(old_dir, dno, dep, &qbh, 1)) != 2) {
Al Viro7e7742e2010-01-31 17:09:29 -0500598 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 -0700599 clear_nlink(new_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600 copy_de(nde, &de);
601 memcpy(nde->name, new_name, new_len);
602 hpfs_mark_4buffers_dirty(&qbh1);
603 hpfs_brelse4(&qbh1);
604 goto end;
605 }
606 hpfs_error(new_dir->i_sb, "hpfs_rename: could not find dirent");
607 err = -EFSERROR;
608 goto end1;
609 }
610 err = r == 2 ? -ENOSPC : r == 1 ? -EFSERROR : 0;
611 goto end1;
612 }
613
614 if (new_dir == old_dir) hpfs_brelse4(&qbh);
615
616 hpfs_lock_creation(i->i_sb);
617 if ((r = hpfs_add_dirent(new_dir, new_name, new_len, &de, 1))) {
618 hpfs_unlock_creation(i->i_sb);
619 if (r == -1) hpfs_error(new_dir->i_sb, "hpfs_rename: dirent already exists!");
620 err = r == 1 ? -ENOSPC : -EFSERROR;
621 if (new_dir != old_dir) hpfs_brelse4(&qbh);
622 goto end1;
623 }
624
625 if (new_dir == old_dir)
Al Viro7e7742e2010-01-31 17:09:29 -0500626 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 -0700627 hpfs_unlock_creation(i->i_sb);
628 hpfs_error(i->i_sb, "lookup succeeded but map dirent failed at #2");
629 err = -ENOENT;
630 goto end1;
631 }
632
633 if ((r = hpfs_remove_dirent(old_dir, dno, dep, &qbh, 0))) {
634 hpfs_unlock_creation(i->i_sb);
635 hpfs_error(i->i_sb, "hpfs_rename: could not remove dirent");
636 err = r == 2 ? -ENOSPC : -EFSERROR;
637 goto end1;
638 }
639 hpfs_unlock_creation(i->i_sb);
640
641 end:
642 hpfs_i(i)->i_parent_dir = new_dir->i_ino;
643 if (S_ISDIR(i->i_mode)) {
Dave Hansend8c76e62006-09-30 23:29:04 -0700644 inc_nlink(new_dir);
Dave Hansen9a53c3a2006-09-30 23:29:03 -0700645 drop_nlink(old_dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700646 }
647 if ((fnode = hpfs_map_fnode(i->i_sb, i->i_ino, &bh))) {
648 fnode->up = new_dir->i_ino;
649 fnode->len = new_len;
650 memcpy(fnode->name, new_name, new_len>15?15:new_len);
651 if (new_len < 15) memset(&fnode->name[new_len], 0, 15 - new_len);
652 mark_buffer_dirty(bh);
653 brelse(bh);
654 }
655 hpfs_i(i)->i_conv = hpfs_sb(i->i_sb)->sb_conv;
Al Viro7e7742e2010-01-31 17:09:29 -0500656 hpfs_decide_conv(i, new_name, new_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700657end1:
658 if (old_dir != new_dir)
Ingo Molnar7bf6d782006-03-23 03:00:42 -0800659 mutex_unlock(&hpfs_i(new_dir)->i_mutex);
660 mutex_unlock(&hpfs_i(old_dir)->i_mutex);
661 mutex_unlock(&hpfs_i(i)->i_parent_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662 if (new_inode)
Ingo Molnar7bf6d782006-03-23 03:00:42 -0800663 mutex_unlock(&hpfs_i(new_inode)->i_parent_mutex);
Arnd Bergmann9a311b92011-01-22 20:26:12 +0100664 hpfs_unlock(i->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665 return err;
666}
667
Arjan van de Ven92e1d5b2007-02-12 00:55:39 -0800668const struct inode_operations hpfs_dir_iops =
Linus Torvalds1da177e2005-04-16 15:20:36 -0700669{
670 .create = hpfs_create,
671 .lookup = hpfs_lookup,
672 .unlink = hpfs_unlink,
673 .symlink = hpfs_symlink,
674 .mkdir = hpfs_mkdir,
675 .rmdir = hpfs_rmdir,
676 .mknod = hpfs_mknod,
677 .rename = hpfs_rename,
Christoph Hellwigca30bc92008-08-11 00:27:59 +0200678 .setattr = hpfs_setattr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700679};