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