1 | /* |
2 | * JFFS2 -- Journalling Flash File System, Version 2. |
3 | * |
4 | * Copyright © 2001-2007 Red Hat, Inc. |
5 | * Copyright © 2004-2010 David Woodhouse <dwmw2@infradead.org> |
6 | * |
7 | * Created by David Woodhouse <dwmw2@infradead.org> |
8 | * |
9 | * For licensing information, see the file 'LICENCE' in this directory. |
10 | * |
11 | */ |
12 | |
13 | #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt |
14 | |
15 | #include <linux/kernel.h> |
16 | #include <linux/slab.h> |
17 | #include <linux/fs.h> |
18 | #include <linux/crc32.h> |
19 | #include <linux/jffs2.h> |
20 | #include "jffs2_fs_i.h" |
21 | #include "jffs2_fs_sb.h" |
22 | #include <linux/time.h> |
23 | #include "nodelist.h" |
24 | |
25 | static int jffs2_readdir (struct file *, struct dir_context *); |
26 | |
27 | static int jffs2_create (struct mnt_idmap *, struct inode *, |
28 | struct dentry *, umode_t, bool); |
29 | static struct dentry *jffs2_lookup (struct inode *,struct dentry *, |
30 | unsigned int); |
31 | static int jffs2_link (struct dentry *,struct inode *,struct dentry *); |
32 | static int jffs2_unlink (struct inode *,struct dentry *); |
33 | static int jffs2_symlink (struct mnt_idmap *, struct inode *, |
34 | struct dentry *, const char *); |
35 | static int jffs2_mkdir (struct mnt_idmap *, struct inode *,struct dentry *, |
36 | umode_t); |
37 | static int jffs2_rmdir (struct inode *,struct dentry *); |
38 | static int jffs2_mknod (struct mnt_idmap *, struct inode *,struct dentry *, |
39 | umode_t,dev_t); |
40 | static int jffs2_rename (struct mnt_idmap *, struct inode *, |
41 | struct dentry *, struct inode *, struct dentry *, |
42 | unsigned int); |
43 | |
44 | const struct file_operations jffs2_dir_operations = |
45 | { |
46 | .read = generic_read_dir, |
47 | .iterate_shared=jffs2_readdir, |
48 | .unlocked_ioctl=jffs2_ioctl, |
49 | .fsync = jffs2_fsync, |
50 | .llseek = generic_file_llseek, |
51 | }; |
52 | |
53 | |
54 | const struct inode_operations jffs2_dir_inode_operations = |
55 | { |
56 | .create = jffs2_create, |
57 | .lookup = jffs2_lookup, |
58 | .link = jffs2_link, |
59 | .unlink = jffs2_unlink, |
60 | .symlink = jffs2_symlink, |
61 | .mkdir = jffs2_mkdir, |
62 | .rmdir = jffs2_rmdir, |
63 | .mknod = jffs2_mknod, |
64 | .rename = jffs2_rename, |
65 | .get_inode_acl = jffs2_get_acl, |
66 | .set_acl = jffs2_set_acl, |
67 | .setattr = jffs2_setattr, |
68 | .listxattr = jffs2_listxattr, |
69 | }; |
70 | |
71 | /***********************************************************************/ |
72 | |
73 | |
74 | /* We keep the dirent list sorted in increasing order of name hash, |
75 | and we use the same hash function as the dentries. Makes this |
76 | nice and simple |
77 | */ |
78 | static struct dentry *jffs2_lookup(struct inode *dir_i, struct dentry *target, |
79 | unsigned int flags) |
80 | { |
81 | struct jffs2_inode_info *dir_f; |
82 | struct jffs2_full_dirent *fd = NULL, *fd_list; |
83 | uint32_t ino = 0; |
84 | struct inode *inode = NULL; |
85 | unsigned int nhash; |
86 | |
87 | jffs2_dbg(1, "jffs2_lookup()\n" ); |
88 | |
89 | if (target->d_name.len > JFFS2_MAX_NAME_LEN) |
90 | return ERR_PTR(error: -ENAMETOOLONG); |
91 | |
92 | dir_f = JFFS2_INODE_INFO(dir_i); |
93 | |
94 | /* The 'nhash' on the fd_list is not the same as the dentry hash */ |
95 | nhash = full_name_hash(NULL, target->d_name.name, target->d_name.len); |
96 | |
97 | mutex_lock(&dir_f->sem); |
98 | |
99 | /* NB: The 2.2 backport will need to explicitly check for '.' and '..' here */ |
100 | for (fd_list = dir_f->dents; fd_list && fd_list->nhash <= nhash; fd_list = fd_list->next) { |
101 | if (fd_list->nhash == nhash && |
102 | (!fd || fd_list->version > fd->version) && |
103 | strlen(fd_list->name) == target->d_name.len && |
104 | !strncmp(fd_list->name, target->d_name.name, target->d_name.len)) { |
105 | fd = fd_list; |
106 | } |
107 | } |
108 | if (fd) |
109 | ino = fd->ino; |
110 | mutex_unlock(lock: &dir_f->sem); |
111 | if (ino) { |
112 | inode = jffs2_iget(dir_i->i_sb, ino); |
113 | if (IS_ERR(ptr: inode)) |
114 | pr_warn("iget() failed for ino #%u\n" , ino); |
115 | } |
116 | |
117 | return d_splice_alias(inode, target); |
118 | } |
119 | |
120 | /***********************************************************************/ |
121 | |
122 | |
123 | static int jffs2_readdir(struct file *file, struct dir_context *ctx) |
124 | { |
125 | struct inode *inode = file_inode(f: file); |
126 | struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode); |
127 | struct jffs2_full_dirent *fd; |
128 | unsigned long curofs = 1; |
129 | |
130 | jffs2_dbg(1, "jffs2_readdir() for dir_i #%lu\n" , inode->i_ino); |
131 | |
132 | if (!dir_emit_dots(file, ctx)) |
133 | return 0; |
134 | |
135 | mutex_lock(&f->sem); |
136 | for (fd = f->dents; fd; fd = fd->next) { |
137 | curofs++; |
138 | /* First loop: curofs = 2; pos = 2 */ |
139 | if (curofs < ctx->pos) { |
140 | jffs2_dbg(2, "Skipping dirent: \"%s\", ino #%u, type %d, because curofs %ld < offset %ld\n" , |
141 | fd->name, fd->ino, fd->type, curofs, (unsigned long)ctx->pos); |
142 | continue; |
143 | } |
144 | if (!fd->ino) { |
145 | jffs2_dbg(2, "Skipping deletion dirent \"%s\"\n" , |
146 | fd->name); |
147 | ctx->pos++; |
148 | continue; |
149 | } |
150 | jffs2_dbg(2, "Dirent %ld: \"%s\", ino #%u, type %d\n" , |
151 | (unsigned long)ctx->pos, fd->name, fd->ino, fd->type); |
152 | if (!dir_emit(ctx, name: fd->name, strlen(fd->name), ino: fd->ino, type: fd->type)) |
153 | break; |
154 | ctx->pos++; |
155 | } |
156 | mutex_unlock(lock: &f->sem); |
157 | return 0; |
158 | } |
159 | |
160 | /***********************************************************************/ |
161 | |
162 | |
163 | static int jffs2_create(struct mnt_idmap *idmap, struct inode *dir_i, |
164 | struct dentry *dentry, umode_t mode, bool excl) |
165 | { |
166 | struct jffs2_raw_inode *ri; |
167 | struct jffs2_inode_info *f, *dir_f; |
168 | struct jffs2_sb_info *c; |
169 | struct inode *inode; |
170 | int ret; |
171 | |
172 | ri = jffs2_alloc_raw_inode(); |
173 | if (!ri) |
174 | return -ENOMEM; |
175 | |
176 | c = JFFS2_SB_INFO(dir_i->i_sb); |
177 | |
178 | jffs2_dbg(1, "%s()\n" , __func__); |
179 | |
180 | inode = jffs2_new_inode(dir_i, mode, ri); |
181 | |
182 | if (IS_ERR(ptr: inode)) { |
183 | jffs2_dbg(1, "jffs2_new_inode() failed\n" ); |
184 | jffs2_free_raw_inode(ri); |
185 | return PTR_ERR(ptr: inode); |
186 | } |
187 | |
188 | inode->i_op = &jffs2_file_inode_operations; |
189 | inode->i_fop = &jffs2_file_operations; |
190 | inode->i_mapping->a_ops = &jffs2_file_address_operations; |
191 | inode->i_mapping->nrpages = 0; |
192 | |
193 | f = JFFS2_INODE_INFO(inode); |
194 | dir_f = JFFS2_INODE_INFO(dir_i); |
195 | |
196 | /* jffs2_do_create() will want to lock it, _after_ reserving |
197 | space and taking c-alloc_sem. If we keep it locked here, |
198 | lockdep gets unhappy (although it's a false positive; |
199 | nothing else will be looking at this inode yet so there's |
200 | no chance of AB-BA deadlock involving its f->sem). */ |
201 | mutex_unlock(lock: &f->sem); |
202 | |
203 | ret = jffs2_do_create(c, dir_f, f, ri, qstr: &dentry->d_name); |
204 | if (ret) |
205 | goto fail; |
206 | |
207 | inode_set_mtime_to_ts(inode: dir_i, |
208 | ts: inode_set_ctime_to_ts(inode: dir_i, ITIME(je32_to_cpu(ri->ctime)))); |
209 | |
210 | jffs2_free_raw_inode(ri); |
211 | |
212 | jffs2_dbg(1, "%s(): Created ino #%lu with mode %o, nlink %d(%d). nrpages %ld\n" , |
213 | __func__, inode->i_ino, inode->i_mode, inode->i_nlink, |
214 | f->inocache->pino_nlink, inode->i_mapping->nrpages); |
215 | |
216 | d_instantiate_new(dentry, inode); |
217 | return 0; |
218 | |
219 | fail: |
220 | iget_failed(inode); |
221 | jffs2_free_raw_inode(ri); |
222 | return ret; |
223 | } |
224 | |
225 | /***********************************************************************/ |
226 | |
227 | |
228 | static int jffs2_unlink(struct inode *dir_i, struct dentry *dentry) |
229 | { |
230 | struct jffs2_sb_info *c = JFFS2_SB_INFO(dir_i->i_sb); |
231 | struct jffs2_inode_info *dir_f = JFFS2_INODE_INFO(dir_i); |
232 | struct jffs2_inode_info *dead_f = JFFS2_INODE_INFO(d_inode(dentry)); |
233 | int ret; |
234 | uint32_t now = JFFS2_NOW(); |
235 | |
236 | ret = jffs2_do_unlink(c, dir_f, name: dentry->d_name.name, |
237 | namelen: dentry->d_name.len, dead_f, time: now); |
238 | if (dead_f->inocache) |
239 | set_nlink(inode: d_inode(dentry), nlink: dead_f->inocache->pino_nlink); |
240 | if (!ret) |
241 | inode_set_mtime_to_ts(inode: dir_i, |
242 | ts: inode_set_ctime_to_ts(inode: dir_i, ITIME(now))); |
243 | return ret; |
244 | } |
245 | /***********************************************************************/ |
246 | |
247 | |
248 | static int jffs2_link (struct dentry *old_dentry, struct inode *dir_i, struct dentry *dentry) |
249 | { |
250 | struct jffs2_sb_info *c = JFFS2_SB_INFO(old_dentry->d_sb); |
251 | struct jffs2_inode_info *f = JFFS2_INODE_INFO(d_inode(old_dentry)); |
252 | struct jffs2_inode_info *dir_f = JFFS2_INODE_INFO(dir_i); |
253 | int ret; |
254 | uint8_t type; |
255 | uint32_t now; |
256 | |
257 | /* Don't let people make hard links to bad inodes. */ |
258 | if (!f->inocache) |
259 | return -EIO; |
260 | |
261 | if (d_is_dir(dentry: old_dentry)) |
262 | return -EPERM; |
263 | |
264 | /* XXX: This is ugly */ |
265 | type = (d_inode(dentry: old_dentry)->i_mode & S_IFMT) >> 12; |
266 | if (!type) type = DT_REG; |
267 | |
268 | now = JFFS2_NOW(); |
269 | ret = jffs2_do_link(c, dir_f, ino: f->inocache->ino, type, name: dentry->d_name.name, namelen: dentry->d_name.len, time: now); |
270 | |
271 | if (!ret) { |
272 | mutex_lock(&f->sem); |
273 | set_nlink(inode: d_inode(dentry: old_dentry), nlink: ++f->inocache->pino_nlink); |
274 | mutex_unlock(lock: &f->sem); |
275 | d_instantiate(dentry, d_inode(dentry: old_dentry)); |
276 | inode_set_mtime_to_ts(inode: dir_i, |
277 | ts: inode_set_ctime_to_ts(inode: dir_i, ITIME(now))); |
278 | ihold(inode: d_inode(dentry: old_dentry)); |
279 | } |
280 | return ret; |
281 | } |
282 | |
283 | /***********************************************************************/ |
284 | |
285 | static int jffs2_symlink (struct mnt_idmap *idmap, struct inode *dir_i, |
286 | struct dentry *dentry, const char *target) |
287 | { |
288 | struct jffs2_inode_info *f, *dir_f; |
289 | struct jffs2_sb_info *c; |
290 | struct inode *inode; |
291 | struct jffs2_raw_inode *ri; |
292 | struct jffs2_raw_dirent *rd; |
293 | struct jffs2_full_dnode *fn; |
294 | struct jffs2_full_dirent *fd; |
295 | int namelen; |
296 | uint32_t alloclen; |
297 | int ret, targetlen = strlen(target); |
298 | |
299 | /* FIXME: If you care. We'd need to use frags for the target |
300 | if it grows much more than this */ |
301 | if (targetlen > 254) |
302 | return -ENAMETOOLONG; |
303 | |
304 | ri = jffs2_alloc_raw_inode(); |
305 | |
306 | if (!ri) |
307 | return -ENOMEM; |
308 | |
309 | c = JFFS2_SB_INFO(dir_i->i_sb); |
310 | |
311 | /* Try to reserve enough space for both node and dirent. |
312 | * Just the node will do for now, though |
313 | */ |
314 | namelen = dentry->d_name.len; |
315 | ret = jffs2_reserve_space(c, minsize: sizeof(*ri) + targetlen, len: &alloclen, |
316 | ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE); |
317 | |
318 | if (ret) { |
319 | jffs2_free_raw_inode(ri); |
320 | return ret; |
321 | } |
322 | |
323 | inode = jffs2_new_inode(dir_i, S_IFLNK | S_IRWXUGO, ri); |
324 | |
325 | if (IS_ERR(ptr: inode)) { |
326 | jffs2_free_raw_inode(ri); |
327 | jffs2_complete_reservation(c); |
328 | return PTR_ERR(ptr: inode); |
329 | } |
330 | |
331 | inode->i_op = &jffs2_symlink_inode_operations; |
332 | |
333 | f = JFFS2_INODE_INFO(inode); |
334 | |
335 | inode->i_size = targetlen; |
336 | ri->isize = ri->dsize = ri->csize = cpu_to_je32(inode->i_size); |
337 | ri->totlen = cpu_to_je32(sizeof(*ri) + inode->i_size); |
338 | ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4)); |
339 | |
340 | ri->compr = JFFS2_COMPR_NONE; |
341 | ri->data_crc = cpu_to_je32(crc32(0, target, targetlen)); |
342 | ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8)); |
343 | |
344 | fn = jffs2_write_dnode(c, f, ri, data: target, datalen: targetlen, ALLOC_NORMAL); |
345 | |
346 | jffs2_free_raw_inode(ri); |
347 | |
348 | if (IS_ERR(ptr: fn)) { |
349 | /* Eeek. Wave bye bye */ |
350 | mutex_unlock(lock: &f->sem); |
351 | jffs2_complete_reservation(c); |
352 | ret = PTR_ERR(ptr: fn); |
353 | goto fail; |
354 | } |
355 | |
356 | /* We use f->target field to store the target path. */ |
357 | f->target = kmemdup(p: target, size: targetlen + 1, GFP_KERNEL); |
358 | if (!f->target) { |
359 | pr_warn("Can't allocate %d bytes of memory\n" , targetlen + 1); |
360 | mutex_unlock(lock: &f->sem); |
361 | jffs2_complete_reservation(c); |
362 | ret = -ENOMEM; |
363 | goto fail; |
364 | } |
365 | inode->i_link = f->target; |
366 | |
367 | jffs2_dbg(1, "%s(): symlink's target '%s' cached\n" , |
368 | __func__, (char *)f->target); |
369 | |
370 | /* No data here. Only a metadata node, which will be |
371 | obsoleted by the first data write |
372 | */ |
373 | f->metadata = fn; |
374 | mutex_unlock(lock: &f->sem); |
375 | |
376 | jffs2_complete_reservation(c); |
377 | |
378 | ret = jffs2_init_security(inode, dir: dir_i, qstr: &dentry->d_name); |
379 | if (ret) |
380 | goto fail; |
381 | |
382 | ret = jffs2_init_acl_post(inode); |
383 | if (ret) |
384 | goto fail; |
385 | |
386 | ret = jffs2_reserve_space(c, minsize: sizeof(*rd)+namelen, len: &alloclen, |
387 | ALLOC_NORMAL, JFFS2_SUMMARY_DIRENT_SIZE(namelen)); |
388 | if (ret) |
389 | goto fail; |
390 | |
391 | rd = jffs2_alloc_raw_dirent(); |
392 | if (!rd) { |
393 | /* Argh. Now we treat it like a normal delete */ |
394 | jffs2_complete_reservation(c); |
395 | ret = -ENOMEM; |
396 | goto fail; |
397 | } |
398 | |
399 | dir_f = JFFS2_INODE_INFO(dir_i); |
400 | mutex_lock(&dir_f->sem); |
401 | |
402 | rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK); |
403 | rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT); |
404 | rd->totlen = cpu_to_je32(sizeof(*rd) + namelen); |
405 | rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4)); |
406 | |
407 | rd->pino = cpu_to_je32(dir_i->i_ino); |
408 | rd->version = cpu_to_je32(++dir_f->highest_version); |
409 | rd->ino = cpu_to_je32(inode->i_ino); |
410 | rd->mctime = cpu_to_je32(JFFS2_NOW()); |
411 | rd->nsize = namelen; |
412 | rd->type = DT_LNK; |
413 | rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8)); |
414 | rd->name_crc = cpu_to_je32(crc32(0, dentry->d_name.name, namelen)); |
415 | |
416 | fd = jffs2_write_dirent(c, f: dir_f, rd, name: dentry->d_name.name, namelen, ALLOC_NORMAL); |
417 | |
418 | if (IS_ERR(ptr: fd)) { |
419 | /* dirent failed to write. Delete the inode normally |
420 | as if it were the final unlink() */ |
421 | jffs2_complete_reservation(c); |
422 | jffs2_free_raw_dirent(rd); |
423 | mutex_unlock(lock: &dir_f->sem); |
424 | ret = PTR_ERR(ptr: fd); |
425 | goto fail; |
426 | } |
427 | |
428 | inode_set_mtime_to_ts(inode: dir_i, |
429 | ts: inode_set_ctime_to_ts(inode: dir_i, ITIME(je32_to_cpu(rd->mctime)))); |
430 | |
431 | jffs2_free_raw_dirent(rd); |
432 | |
433 | /* Link the fd into the inode's list, obsoleting an old |
434 | one if necessary. */ |
435 | jffs2_add_fd_to_list(c, new: fd, list: &dir_f->dents); |
436 | |
437 | mutex_unlock(lock: &dir_f->sem); |
438 | jffs2_complete_reservation(c); |
439 | |
440 | d_instantiate_new(dentry, inode); |
441 | return 0; |
442 | |
443 | fail: |
444 | iget_failed(inode); |
445 | return ret; |
446 | } |
447 | |
448 | |
449 | static int jffs2_mkdir (struct mnt_idmap *idmap, struct inode *dir_i, |
450 | struct dentry *dentry, umode_t mode) |
451 | { |
452 | struct jffs2_inode_info *f, *dir_f; |
453 | struct jffs2_sb_info *c; |
454 | struct inode *inode; |
455 | struct jffs2_raw_inode *ri; |
456 | struct jffs2_raw_dirent *rd; |
457 | struct jffs2_full_dnode *fn; |
458 | struct jffs2_full_dirent *fd; |
459 | int namelen; |
460 | uint32_t alloclen; |
461 | int ret; |
462 | |
463 | mode |= S_IFDIR; |
464 | |
465 | ri = jffs2_alloc_raw_inode(); |
466 | if (!ri) |
467 | return -ENOMEM; |
468 | |
469 | c = JFFS2_SB_INFO(dir_i->i_sb); |
470 | |
471 | /* Try to reserve enough space for both node and dirent. |
472 | * Just the node will do for now, though |
473 | */ |
474 | namelen = dentry->d_name.len; |
475 | ret = jffs2_reserve_space(c, minsize: sizeof(*ri), len: &alloclen, ALLOC_NORMAL, |
476 | JFFS2_SUMMARY_INODE_SIZE); |
477 | |
478 | if (ret) { |
479 | jffs2_free_raw_inode(ri); |
480 | return ret; |
481 | } |
482 | |
483 | inode = jffs2_new_inode(dir_i, mode, ri); |
484 | |
485 | if (IS_ERR(ptr: inode)) { |
486 | jffs2_free_raw_inode(ri); |
487 | jffs2_complete_reservation(c); |
488 | return PTR_ERR(ptr: inode); |
489 | } |
490 | |
491 | inode->i_op = &jffs2_dir_inode_operations; |
492 | inode->i_fop = &jffs2_dir_operations; |
493 | |
494 | f = JFFS2_INODE_INFO(inode); |
495 | |
496 | /* Directories get nlink 2 at start */ |
497 | set_nlink(inode, nlink: 2); |
498 | /* but ic->pino_nlink is the parent ino# */ |
499 | f->inocache->pino_nlink = dir_i->i_ino; |
500 | |
501 | ri->data_crc = cpu_to_je32(0); |
502 | ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8)); |
503 | |
504 | fn = jffs2_write_dnode(c, f, ri, NULL, 0, ALLOC_NORMAL); |
505 | |
506 | jffs2_free_raw_inode(ri); |
507 | |
508 | if (IS_ERR(fn)) { |
509 | /* Eeek. Wave bye bye */ |
510 | mutex_unlock(&f->sem); |
511 | jffs2_complete_reservation(c); |
512 | ret = PTR_ERR(fn); |
513 | goto fail; |
514 | } |
515 | /* No data here. Only a metadata node, which will be |
516 | obsoleted by the first data write |
517 | */ |
518 | f->metadata = fn; |
519 | mutex_unlock(&f->sem); |
520 | |
521 | jffs2_complete_reservation(c); |
522 | |
523 | ret = jffs2_init_security(inode, dir_i, &dentry->d_name); |
524 | if (ret) |
525 | goto fail; |
526 | |
527 | ret = jffs2_init_acl_post(inode); |
528 | if (ret) |
529 | goto fail; |
530 | |
531 | ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &alloclen, |
532 | ALLOC_NORMAL, JFFS2_SUMMARY_DIRENT_SIZE(namelen)); |
533 | if (ret) |
534 | goto fail; |
535 | |
536 | rd = jffs2_alloc_raw_dirent(); |
537 | if (!rd) { |
538 | /* Argh. Now we treat it like a normal delete */ |
539 | jffs2_complete_reservation(c); |
540 | ret = -ENOMEM; |
541 | goto fail; |
542 | } |
543 | |
544 | dir_f = JFFS2_INODE_INFO(dir_i); |
545 | mutex_lock(&dir_f->sem); |
546 | |
547 | rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK); |
548 | rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT); |
549 | rd->totlen = cpu_to_je32(sizeof(*rd) + namelen); |
550 | rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4)); |
551 | |
552 | rd->pino = cpu_to_je32(dir_i->i_ino); |
553 | rd->version = cpu_to_je32(++dir_f->highest_version); |
554 | rd->ino = cpu_to_je32(inode->i_ino); |
555 | rd->mctime = cpu_to_je32(JFFS2_NOW()); |
556 | rd->nsize = namelen; |
557 | rd->type = DT_DIR; |
558 | rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8)); |
559 | rd->name_crc = cpu_to_je32(crc32(0, dentry->d_name.name, namelen)); |
560 | |
561 | fd = jffs2_write_dirent(c, dir_f, rd, dentry->d_name.name, namelen, ALLOC_NORMAL); |
562 | |
563 | if (IS_ERR(fd)) { |
564 | /* dirent failed to write. Delete the inode normally |
565 | as if it were the final unlink() */ |
566 | jffs2_complete_reservation(c); |
567 | jffs2_free_raw_dirent(rd); |
568 | mutex_unlock(&dir_f->sem); |
569 | ret = PTR_ERR(fd); |
570 | goto fail; |
571 | } |
572 | |
573 | inode_set_mtime_to_ts(dir_i, |
574 | inode_set_ctime_to_ts(dir_i, ITIME(je32_to_cpu(rd->mctime)))); |
575 | inc_nlink(dir_i); |
576 | |
577 | jffs2_free_raw_dirent(rd); |
578 | |
579 | /* Link the fd into the inode's list, obsoleting an old |
580 | one if necessary. */ |
581 | jffs2_add_fd_to_list(c, fd, &dir_f->dents); |
582 | |
583 | mutex_unlock(&dir_f->sem); |
584 | jffs2_complete_reservation(c); |
585 | |
586 | d_instantiate_new(dentry, inode); |
587 | return 0; |
588 | |
589 | fail: |
590 | iget_failed(inode); |
591 | return ret; |
592 | } |
593 | |
594 | static int jffs2_rmdir (struct inode *dir_i, struct dentry *dentry) |
595 | { |
596 | struct jffs2_sb_info *c = JFFS2_SB_INFO(dir_i->i_sb); |
597 | struct jffs2_inode_info *dir_f = JFFS2_INODE_INFO(dir_i); |
598 | struct jffs2_inode_info *f = JFFS2_INODE_INFO(d_inode(dentry)); |
599 | struct jffs2_full_dirent *fd; |
600 | int ret; |
601 | uint32_t now = JFFS2_NOW(); |
602 | |
603 | mutex_lock(&f->sem); |
604 | for (fd = f->dents ; fd; fd = fd->next) { |
605 | if (fd->ino) { |
606 | mutex_unlock(lock: &f->sem); |
607 | return -ENOTEMPTY; |
608 | } |
609 | } |
610 | mutex_unlock(lock: &f->sem); |
611 | |
612 | ret = jffs2_do_unlink(c, dir_f, name: dentry->d_name.name, |
613 | namelen: dentry->d_name.len, dead_f: f, time: now); |
614 | if (!ret) { |
615 | inode_set_mtime_to_ts(inode: dir_i, |
616 | ts: inode_set_ctime_to_ts(inode: dir_i, ITIME(now))); |
617 | clear_nlink(inode: d_inode(dentry)); |
618 | drop_nlink(inode: dir_i); |
619 | } |
620 | return ret; |
621 | } |
622 | |
623 | static int jffs2_mknod (struct mnt_idmap *idmap, struct inode *dir_i, |
624 | struct dentry *dentry, umode_t mode, dev_t rdev) |
625 | { |
626 | struct jffs2_inode_info *f, *dir_f; |
627 | struct jffs2_sb_info *c; |
628 | struct inode *inode; |
629 | struct jffs2_raw_inode *ri; |
630 | struct jffs2_raw_dirent *rd; |
631 | struct jffs2_full_dnode *fn; |
632 | struct jffs2_full_dirent *fd; |
633 | int namelen; |
634 | union jffs2_device_node dev; |
635 | int devlen = 0; |
636 | uint32_t alloclen; |
637 | int ret; |
638 | |
639 | ri = jffs2_alloc_raw_inode(); |
640 | if (!ri) |
641 | return -ENOMEM; |
642 | |
643 | c = JFFS2_SB_INFO(dir_i->i_sb); |
644 | |
645 | if (S_ISBLK(mode) || S_ISCHR(mode)) |
646 | devlen = jffs2_encode_dev(jdev: &dev, rdev); |
647 | |
648 | /* Try to reserve enough space for both node and dirent. |
649 | * Just the node will do for now, though |
650 | */ |
651 | namelen = dentry->d_name.len; |
652 | ret = jffs2_reserve_space(c, minsize: sizeof(*ri) + devlen, len: &alloclen, |
653 | ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE); |
654 | |
655 | if (ret) { |
656 | jffs2_free_raw_inode(ri); |
657 | return ret; |
658 | } |
659 | |
660 | inode = jffs2_new_inode(dir_i, mode, ri); |
661 | |
662 | if (IS_ERR(ptr: inode)) { |
663 | jffs2_free_raw_inode(ri); |
664 | jffs2_complete_reservation(c); |
665 | return PTR_ERR(ptr: inode); |
666 | } |
667 | inode->i_op = &jffs2_file_inode_operations; |
668 | init_special_inode(inode, inode->i_mode, rdev); |
669 | |
670 | f = JFFS2_INODE_INFO(inode); |
671 | |
672 | ri->dsize = ri->csize = cpu_to_je32(devlen); |
673 | ri->totlen = cpu_to_je32(sizeof(*ri) + devlen); |
674 | ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4)); |
675 | |
676 | ri->compr = JFFS2_COMPR_NONE; |
677 | ri->data_crc = cpu_to_je32(crc32(0, &dev, devlen)); |
678 | ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8)); |
679 | |
680 | fn = jffs2_write_dnode(c, f, ri, data: (char *)&dev, datalen: devlen, ALLOC_NORMAL); |
681 | |
682 | jffs2_free_raw_inode(ri); |
683 | |
684 | if (IS_ERR(ptr: fn)) { |
685 | /* Eeek. Wave bye bye */ |
686 | mutex_unlock(lock: &f->sem); |
687 | jffs2_complete_reservation(c); |
688 | ret = PTR_ERR(ptr: fn); |
689 | goto fail; |
690 | } |
691 | /* No data here. Only a metadata node, which will be |
692 | obsoleted by the first data write |
693 | */ |
694 | f->metadata = fn; |
695 | mutex_unlock(lock: &f->sem); |
696 | |
697 | jffs2_complete_reservation(c); |
698 | |
699 | ret = jffs2_init_security(inode, dir: dir_i, qstr: &dentry->d_name); |
700 | if (ret) |
701 | goto fail; |
702 | |
703 | ret = jffs2_init_acl_post(inode); |
704 | if (ret) |
705 | goto fail; |
706 | |
707 | ret = jffs2_reserve_space(c, minsize: sizeof(*rd)+namelen, len: &alloclen, |
708 | ALLOC_NORMAL, JFFS2_SUMMARY_DIRENT_SIZE(namelen)); |
709 | if (ret) |
710 | goto fail; |
711 | |
712 | rd = jffs2_alloc_raw_dirent(); |
713 | if (!rd) { |
714 | /* Argh. Now we treat it like a normal delete */ |
715 | jffs2_complete_reservation(c); |
716 | ret = -ENOMEM; |
717 | goto fail; |
718 | } |
719 | |
720 | dir_f = JFFS2_INODE_INFO(dir_i); |
721 | mutex_lock(&dir_f->sem); |
722 | |
723 | rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK); |
724 | rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT); |
725 | rd->totlen = cpu_to_je32(sizeof(*rd) + namelen); |
726 | rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4)); |
727 | |
728 | rd->pino = cpu_to_je32(dir_i->i_ino); |
729 | rd->version = cpu_to_je32(++dir_f->highest_version); |
730 | rd->ino = cpu_to_je32(inode->i_ino); |
731 | rd->mctime = cpu_to_je32(JFFS2_NOW()); |
732 | rd->nsize = namelen; |
733 | |
734 | /* XXX: This is ugly. */ |
735 | rd->type = (mode & S_IFMT) >> 12; |
736 | |
737 | rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8)); |
738 | rd->name_crc = cpu_to_je32(crc32(0, dentry->d_name.name, namelen)); |
739 | |
740 | fd = jffs2_write_dirent(c, f: dir_f, rd, name: dentry->d_name.name, namelen, ALLOC_NORMAL); |
741 | |
742 | if (IS_ERR(ptr: fd)) { |
743 | /* dirent failed to write. Delete the inode normally |
744 | as if it were the final unlink() */ |
745 | jffs2_complete_reservation(c); |
746 | jffs2_free_raw_dirent(rd); |
747 | mutex_unlock(lock: &dir_f->sem); |
748 | ret = PTR_ERR(ptr: fd); |
749 | goto fail; |
750 | } |
751 | |
752 | inode_set_mtime_to_ts(inode: dir_i, |
753 | ts: inode_set_ctime_to_ts(inode: dir_i, ITIME(je32_to_cpu(rd->mctime)))); |
754 | |
755 | jffs2_free_raw_dirent(rd); |
756 | |
757 | /* Link the fd into the inode's list, obsoleting an old |
758 | one if necessary. */ |
759 | jffs2_add_fd_to_list(c, new: fd, list: &dir_f->dents); |
760 | |
761 | mutex_unlock(lock: &dir_f->sem); |
762 | jffs2_complete_reservation(c); |
763 | |
764 | d_instantiate_new(dentry, inode); |
765 | return 0; |
766 | |
767 | fail: |
768 | iget_failed(inode); |
769 | return ret; |
770 | } |
771 | |
772 | static int jffs2_rename (struct mnt_idmap *idmap, |
773 | struct inode *old_dir_i, struct dentry *old_dentry, |
774 | struct inode *new_dir_i, struct dentry *new_dentry, |
775 | unsigned int flags) |
776 | { |
777 | int ret; |
778 | struct jffs2_sb_info *c = JFFS2_SB_INFO(old_dir_i->i_sb); |
779 | struct jffs2_inode_info *victim_f = NULL; |
780 | uint8_t type; |
781 | uint32_t now; |
782 | |
783 | if (flags & ~RENAME_NOREPLACE) |
784 | return -EINVAL; |
785 | |
786 | /* The VFS will check for us and prevent trying to rename a |
787 | * file over a directory and vice versa, but if it's a directory, |
788 | * the VFS can't check whether the victim is empty. The filesystem |
789 | * needs to do that for itself. |
790 | */ |
791 | if (d_really_is_positive(dentry: new_dentry)) { |
792 | victim_f = JFFS2_INODE_INFO(d_inode(new_dentry)); |
793 | if (d_is_dir(dentry: new_dentry)) { |
794 | struct jffs2_full_dirent *fd; |
795 | |
796 | mutex_lock(&victim_f->sem); |
797 | for (fd = victim_f->dents; fd; fd = fd->next) { |
798 | if (fd->ino) { |
799 | mutex_unlock(lock: &victim_f->sem); |
800 | return -ENOTEMPTY; |
801 | } |
802 | } |
803 | mutex_unlock(lock: &victim_f->sem); |
804 | } |
805 | } |
806 | |
807 | /* XXX: We probably ought to alloc enough space for |
808 | both nodes at the same time. Writing the new link, |
809 | then getting -ENOSPC, is quite bad :) |
810 | */ |
811 | |
812 | /* Make a hard link */ |
813 | |
814 | /* XXX: This is ugly */ |
815 | type = (d_inode(dentry: old_dentry)->i_mode & S_IFMT) >> 12; |
816 | if (!type) type = DT_REG; |
817 | |
818 | now = JFFS2_NOW(); |
819 | ret = jffs2_do_link(c, JFFS2_INODE_INFO(new_dir_i), |
820 | ino: d_inode(dentry: old_dentry)->i_ino, type, |
821 | name: new_dentry->d_name.name, namelen: new_dentry->d_name.len, time: now); |
822 | |
823 | if (ret) |
824 | return ret; |
825 | |
826 | if (victim_f) { |
827 | /* There was a victim. Kill it off nicely */ |
828 | if (d_is_dir(dentry: new_dentry)) |
829 | clear_nlink(inode: d_inode(dentry: new_dentry)); |
830 | else |
831 | drop_nlink(inode: d_inode(dentry: new_dentry)); |
832 | /* Don't oops if the victim was a dirent pointing to an |
833 | inode which didn't exist. */ |
834 | if (victim_f->inocache) { |
835 | mutex_lock(&victim_f->sem); |
836 | if (d_is_dir(dentry: new_dentry)) |
837 | victim_f->inocache->pino_nlink = 0; |
838 | else |
839 | victim_f->inocache->pino_nlink--; |
840 | mutex_unlock(lock: &victim_f->sem); |
841 | } |
842 | } |
843 | |
844 | /* If it was a directory we moved, and there was no victim, |
845 | increase i_nlink on its new parent */ |
846 | if (d_is_dir(dentry: old_dentry) && !victim_f) |
847 | inc_nlink(inode: new_dir_i); |
848 | |
849 | /* Unlink the original */ |
850 | ret = jffs2_do_unlink(c, JFFS2_INODE_INFO(old_dir_i), |
851 | name: old_dentry->d_name.name, namelen: old_dentry->d_name.len, NULL, time: now); |
852 | |
853 | /* We don't touch inode->i_nlink */ |
854 | |
855 | if (ret) { |
856 | /* Oh shit. We really ought to make a single node which can do both atomically */ |
857 | struct jffs2_inode_info *f = JFFS2_INODE_INFO(d_inode(old_dentry)); |
858 | mutex_lock(&f->sem); |
859 | inc_nlink(inode: d_inode(dentry: old_dentry)); |
860 | if (f->inocache && !d_is_dir(dentry: old_dentry)) |
861 | f->inocache->pino_nlink++; |
862 | mutex_unlock(lock: &f->sem); |
863 | |
864 | pr_notice("%s(): Link succeeded, unlink failed (err %d). You now have a hard link\n" , |
865 | __func__, ret); |
866 | /* |
867 | * We can't keep the target in dcache after that. |
868 | * For one thing, we can't afford dentry aliases for directories. |
869 | * For another, if there was a victim, we _can't_ set new inode |
870 | * for that sucker and we have to trigger mount eviction - the |
871 | * caller won't do it on its own since we are returning an error. |
872 | */ |
873 | d_invalidate(new_dentry); |
874 | inode_set_mtime_to_ts(inode: new_dir_i, |
875 | ts: inode_set_ctime_to_ts(inode: new_dir_i, ITIME(now))); |
876 | return ret; |
877 | } |
878 | |
879 | if (d_is_dir(dentry: old_dentry)) |
880 | drop_nlink(inode: old_dir_i); |
881 | |
882 | inode_set_mtime_to_ts(inode: old_dir_i, |
883 | ts: inode_set_ctime_to_ts(inode: old_dir_i, ITIME(now))); |
884 | inode_set_mtime_to_ts(inode: new_dir_i, |
885 | ts: inode_set_ctime_to_ts(inode: new_dir_i, ITIME(now))); |
886 | |
887 | return 0; |
888 | } |
889 | |
890 | |