xref: /openbmc/linux/fs/affs/namei.c (revision 22246614)
1 /*
2  *  linux/fs/affs/namei.c
3  *
4  *  (c) 1996  Hans-Joachim Widmaier - Rewritten
5  *
6  *  (C) 1993  Ray Burr - Modified for Amiga FFS filesystem.
7  *
8  *  (C) 1991  Linus Torvalds - minix filesystem
9  */
10 
11 #include "affs.h"
12 
13 typedef int (*toupper_t)(int);
14 
15 static int	 affs_toupper(int ch);
16 static int	 affs_hash_dentry(struct dentry *, struct qstr *);
17 static int       affs_compare_dentry(struct dentry *, struct qstr *, struct qstr *);
18 static int	 affs_intl_toupper(int ch);
19 static int	 affs_intl_hash_dentry(struct dentry *, struct qstr *);
20 static int       affs_intl_compare_dentry(struct dentry *, struct qstr *, struct qstr *);
21 
22 struct dentry_operations affs_dentry_operations = {
23 	.d_hash		= affs_hash_dentry,
24 	.d_compare	= affs_compare_dentry,
25 };
26 
27 static struct dentry_operations affs_intl_dentry_operations = {
28 	.d_hash		= affs_intl_hash_dentry,
29 	.d_compare	= affs_intl_compare_dentry,
30 };
31 
32 
33 /* Simple toupper() for DOS\1 */
34 
35 static int
36 affs_toupper(int ch)
37 {
38 	return ch >= 'a' && ch <= 'z' ? ch -= ('a' - 'A') : ch;
39 }
40 
41 /* International toupper() for DOS\3 ("international") */
42 
43 static int
44 affs_intl_toupper(int ch)
45 {
46 	return (ch >= 'a' && ch <= 'z') || (ch >= 0xE0
47 		&& ch <= 0xFE && ch != 0xF7) ?
48 		ch - ('a' - 'A') : ch;
49 }
50 
51 static inline toupper_t
52 affs_get_toupper(struct super_block *sb)
53 {
54 	return AFFS_SB(sb)->s_flags & SF_INTL ? affs_intl_toupper : affs_toupper;
55 }
56 
57 /*
58  * Note: the dentry argument is the parent dentry.
59  */
60 static inline int
61 __affs_hash_dentry(struct dentry *dentry, struct qstr *qstr, toupper_t toupper)
62 {
63 	const u8 *name = qstr->name;
64 	unsigned long hash;
65 	int i;
66 
67 	i = affs_check_name(qstr->name,qstr->len);
68 	if (i)
69 		return i;
70 
71 	hash = init_name_hash();
72 	i = min(qstr->len, 30u);
73 	for (; i > 0; name++, i--)
74 		hash = partial_name_hash(toupper(*name), hash);
75 	qstr->hash = end_name_hash(hash);
76 
77 	return 0;
78 }
79 
80 static int
81 affs_hash_dentry(struct dentry *dentry, struct qstr *qstr)
82 {
83 	return __affs_hash_dentry(dentry, qstr, affs_toupper);
84 }
85 static int
86 affs_intl_hash_dentry(struct dentry *dentry, struct qstr *qstr)
87 {
88 	return __affs_hash_dentry(dentry, qstr, affs_intl_toupper);
89 }
90 
91 static inline int
92 __affs_compare_dentry(struct dentry *dentry, struct qstr *a, struct qstr *b, toupper_t toupper)
93 {
94 	const u8 *aname = a->name;
95 	const u8 *bname = b->name;
96 	int len;
97 
98 	/* 'a' is the qstr of an already existing dentry, so the name
99 	 * must be valid. 'b' must be validated first.
100 	 */
101 
102 	if (affs_check_name(b->name,b->len))
103 		return 1;
104 
105 	/* If the names are longer than the allowed 30 chars,
106 	 * the excess is ignored, so their length may differ.
107 	 */
108 	len = a->len;
109 	if (len >= 30) {
110 		if (b->len < 30)
111 			return 1;
112 		len = 30;
113 	} else if (len != b->len)
114 		return 1;
115 
116 	for (; len > 0; len--)
117 		if (toupper(*aname++) != toupper(*bname++))
118 			return 1;
119 
120 	return 0;
121 }
122 
123 static int
124 affs_compare_dentry(struct dentry *dentry, struct qstr *a, struct qstr *b)
125 {
126 	return __affs_compare_dentry(dentry, a, b, affs_toupper);
127 }
128 static int
129 affs_intl_compare_dentry(struct dentry *dentry, struct qstr *a, struct qstr *b)
130 {
131 	return __affs_compare_dentry(dentry, a, b, affs_intl_toupper);
132 }
133 
134 /*
135  * NOTE! unlike strncmp, affs_match returns 1 for success, 0 for failure.
136  */
137 
138 static inline int
139 affs_match(struct dentry *dentry, const u8 *name2, toupper_t toupper)
140 {
141 	const u8 *name = dentry->d_name.name;
142 	int len = dentry->d_name.len;
143 
144 	if (len >= 30) {
145 		if (*name2 < 30)
146 			return 0;
147 		len = 30;
148 	} else if (len != *name2)
149 		return 0;
150 
151 	for (name2++; len > 0; len--)
152 		if (toupper(*name++) != toupper(*name2++))
153 			return 0;
154 	return 1;
155 }
156 
157 int
158 affs_hash_name(struct super_block *sb, const u8 *name, unsigned int len)
159 {
160 	toupper_t toupper = affs_get_toupper(sb);
161 	int hash;
162 
163 	hash = len = min(len, 30u);
164 	for (; len > 0; len--)
165 		hash = (hash * 13 + toupper(*name++)) & 0x7ff;
166 
167 	return hash % AFFS_SB(sb)->s_hashsize;
168 }
169 
170 static struct buffer_head *
171 affs_find_entry(struct inode *dir, struct dentry *dentry)
172 {
173 	struct super_block *sb = dir->i_sb;
174 	struct buffer_head *bh;
175 	toupper_t toupper = affs_get_toupper(sb);
176 	u32 key;
177 
178 	pr_debug("AFFS: find_entry(\"%.*s\")\n", (int)dentry->d_name.len, dentry->d_name.name);
179 
180 	bh = affs_bread(sb, dir->i_ino);
181 	if (!bh)
182 		return ERR_PTR(-EIO);
183 
184 	key = be32_to_cpu(AFFS_HEAD(bh)->table[affs_hash_name(sb, dentry->d_name.name, dentry->d_name.len)]);
185 
186 	for (;;) {
187 		affs_brelse(bh);
188 		if (key == 0)
189 			return NULL;
190 		bh = affs_bread(sb, key);
191 		if (!bh)
192 			return ERR_PTR(-EIO);
193 		if (affs_match(dentry, AFFS_TAIL(sb, bh)->name, toupper))
194 			return bh;
195 		key = be32_to_cpu(AFFS_TAIL(sb, bh)->hash_chain);
196 	}
197 }
198 
199 struct dentry *
200 affs_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
201 {
202 	struct super_block *sb = dir->i_sb;
203 	struct buffer_head *bh;
204 	struct inode *inode = NULL;
205 
206 	pr_debug("AFFS: lookup(\"%.*s\")\n",(int)dentry->d_name.len,dentry->d_name.name);
207 
208 	affs_lock_dir(dir);
209 	bh = affs_find_entry(dir, dentry);
210 	affs_unlock_dir(dir);
211 	if (IS_ERR(bh))
212 		return ERR_CAST(bh);
213 	if (bh) {
214 		u32 ino = bh->b_blocknr;
215 
216 		/* store the real header ino in d_fsdata for faster lookups */
217 		dentry->d_fsdata = (void *)(long)ino;
218 		switch (be32_to_cpu(AFFS_TAIL(sb, bh)->stype)) {
219 		//link to dirs disabled
220 		//case ST_LINKDIR:
221 		case ST_LINKFILE:
222 			ino = be32_to_cpu(AFFS_TAIL(sb, bh)->original);
223 		}
224 		affs_brelse(bh);
225 		inode = affs_iget(sb, ino);
226 		if (IS_ERR(inode))
227 			return ERR_PTR(PTR_ERR(inode));
228 	}
229 	dentry->d_op = AFFS_SB(sb)->s_flags & SF_INTL ? &affs_intl_dentry_operations : &affs_dentry_operations;
230 	d_add(dentry, inode);
231 	return NULL;
232 }
233 
234 int
235 affs_unlink(struct inode *dir, struct dentry *dentry)
236 {
237 	pr_debug("AFFS: unlink(dir=%d, %lu \"%.*s\")\n", (u32)dir->i_ino,
238 		 dentry->d_inode->i_ino,
239 		 (int)dentry->d_name.len, dentry->d_name.name);
240 
241 	return affs_remove_header(dentry);
242 }
243 
244 int
245 affs_create(struct inode *dir, struct dentry *dentry, int mode, struct nameidata *nd)
246 {
247 	struct super_block *sb = dir->i_sb;
248 	struct inode	*inode;
249 	int		 error;
250 
251 	pr_debug("AFFS: create(%lu,\"%.*s\",0%o)\n",dir->i_ino,(int)dentry->d_name.len,
252 		 dentry->d_name.name,mode);
253 
254 	inode = affs_new_inode(dir);
255 	if (!inode)
256 		return -ENOSPC;
257 
258 	inode->i_mode = mode;
259 	mode_to_prot(inode);
260 	mark_inode_dirty(inode);
261 
262 	inode->i_op = &affs_file_inode_operations;
263 	inode->i_fop = &affs_file_operations;
264 	inode->i_mapping->a_ops = (AFFS_SB(sb)->s_flags & SF_OFS) ? &affs_aops_ofs : &affs_aops;
265 	error = affs_add_entry(dir, inode, dentry, ST_FILE);
266 	if (error) {
267 		inode->i_nlink = 0;
268 		iput(inode);
269 		return error;
270 	}
271 	return 0;
272 }
273 
274 int
275 affs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
276 {
277 	struct inode		*inode;
278 	int			 error;
279 
280 	pr_debug("AFFS: mkdir(%lu,\"%.*s\",0%o)\n",dir->i_ino,
281 		 (int)dentry->d_name.len,dentry->d_name.name,mode);
282 
283 	inode = affs_new_inode(dir);
284 	if (!inode)
285 		return -ENOSPC;
286 
287 	inode->i_mode = S_IFDIR | mode;
288 	mode_to_prot(inode);
289 
290 	inode->i_op = &affs_dir_inode_operations;
291 	inode->i_fop = &affs_dir_operations;
292 
293 	error = affs_add_entry(dir, inode, dentry, ST_USERDIR);
294 	if (error) {
295 		inode->i_nlink = 0;
296 		mark_inode_dirty(inode);
297 		iput(inode);
298 		return error;
299 	}
300 	return 0;
301 }
302 
303 int
304 affs_rmdir(struct inode *dir, struct dentry *dentry)
305 {
306 	pr_debug("AFFS: rmdir(dir=%u, %lu \"%.*s\")\n", (u32)dir->i_ino,
307 		 dentry->d_inode->i_ino,
308 		 (int)dentry->d_name.len, dentry->d_name.name);
309 
310 	return affs_remove_header(dentry);
311 }
312 
313 int
314 affs_symlink(struct inode *dir, struct dentry *dentry, const char *symname)
315 {
316 	struct super_block	*sb = dir->i_sb;
317 	struct buffer_head	*bh;
318 	struct inode		*inode;
319 	char			*p;
320 	int			 i, maxlen, error;
321 	char			 c, lc;
322 
323 	pr_debug("AFFS: symlink(%lu,\"%.*s\" -> \"%s\")\n",dir->i_ino,
324 		 (int)dentry->d_name.len,dentry->d_name.name,symname);
325 
326 	maxlen = AFFS_SB(sb)->s_hashsize * sizeof(u32) - 1;
327 	inode  = affs_new_inode(dir);
328 	if (!inode)
329 		return -ENOSPC;
330 
331 	inode->i_op = &affs_symlink_inode_operations;
332 	inode->i_data.a_ops = &affs_symlink_aops;
333 	inode->i_mode = S_IFLNK | 0777;
334 	mode_to_prot(inode);
335 
336 	error = -EIO;
337 	bh = affs_bread(sb, inode->i_ino);
338 	if (!bh)
339 		goto err;
340 	i  = 0;
341 	p  = (char *)AFFS_HEAD(bh)->table;
342 	lc = '/';
343 	if (*symname == '/') {
344 		while (*symname == '/')
345 			symname++;
346 		while (AFFS_SB(sb)->s_volume[i])	/* Cannot overflow */
347 			*p++ = AFFS_SB(sb)->s_volume[i++];
348 	}
349 	while (i < maxlen && (c = *symname++)) {
350 		if (c == '.' && lc == '/' && *symname == '.' && symname[1] == '/') {
351 			*p++ = '/';
352 			i++;
353 			symname += 2;
354 			lc = '/';
355 		} else if (c == '.' && lc == '/' && *symname == '/') {
356 			symname++;
357 			lc = '/';
358 		} else {
359 			*p++ = c;
360 			lc   = c;
361 			i++;
362 		}
363 		if (lc == '/')
364 			while (*symname == '/')
365 				symname++;
366 	}
367 	*p = 0;
368 	mark_buffer_dirty_inode(bh, inode);
369 	affs_brelse(bh);
370 	mark_inode_dirty(inode);
371 
372 	error = affs_add_entry(dir, inode, dentry, ST_SOFTLINK);
373 	if (error)
374 		goto err;
375 
376 	return 0;
377 
378 err:
379 	inode->i_nlink = 0;
380 	mark_inode_dirty(inode);
381 	iput(inode);
382 	return error;
383 }
384 
385 int
386 affs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry)
387 {
388 	struct inode *inode = old_dentry->d_inode;
389 
390 	pr_debug("AFFS: link(%u, %u, \"%.*s\")\n", (u32)inode->i_ino, (u32)dir->i_ino,
391 		 (int)dentry->d_name.len,dentry->d_name.name);
392 
393 	return affs_add_entry(dir, inode, dentry, ST_LINKFILE);
394 }
395 
396 int
397 affs_rename(struct inode *old_dir, struct dentry *old_dentry,
398 	    struct inode *new_dir, struct dentry *new_dentry)
399 {
400 	struct super_block *sb = old_dir->i_sb;
401 	struct buffer_head *bh = NULL;
402 	int retval;
403 
404 	pr_debug("AFFS: rename(old=%u,\"%*s\" to new=%u,\"%*s\")\n",
405 		 (u32)old_dir->i_ino, (int)old_dentry->d_name.len, old_dentry->d_name.name,
406 		 (u32)new_dir->i_ino, (int)new_dentry->d_name.len, new_dentry->d_name.name);
407 
408 	retval = affs_check_name(new_dentry->d_name.name,new_dentry->d_name.len);
409 	if (retval)
410 		return retval;
411 
412 	/* Unlink destination if it already exists */
413 	if (new_dentry->d_inode) {
414 		retval = affs_remove_header(new_dentry);
415 		if (retval)
416 			return retval;
417 	}
418 
419 	bh = affs_bread(sb, old_dentry->d_inode->i_ino);
420 	if (!bh)
421 		return -EIO;
422 
423 	/* Remove header from its parent directory. */
424 	affs_lock_dir(old_dir);
425 	retval = affs_remove_hash(old_dir, bh);
426 	affs_unlock_dir(old_dir);
427 	if (retval)
428 		goto done;
429 
430 	/* And insert it into the new directory with the new name. */
431 	affs_copy_name(AFFS_TAIL(sb, bh)->name, new_dentry);
432 	affs_fix_checksum(sb, bh);
433 	affs_lock_dir(new_dir);
434 	retval = affs_insert_hash(new_dir, bh);
435 	affs_unlock_dir(new_dir);
436 	/* TODO: move it back to old_dir, if error? */
437 
438 done:
439 	mark_buffer_dirty_inode(bh, retval ? old_dir : new_dir);
440 	affs_brelse(bh);
441 	return retval;
442 }
443