~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/jffs2/dir.c

Version: ~ [ linux-5.18-rc6 ] ~ [ linux-5.17.6 ] ~ [ linux-5.16.20 ] ~ [ linux-5.15.38 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.114 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.192 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.241 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.277 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.312 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.302 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.9 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 = 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 = JFFS2_NOW();
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 = 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 = JFFS2_NOW();
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 = 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(JFFS2_NOW());
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 = 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(JFFS2_NOW());
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 = 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 = JFFS2_NOW();
592 
593         mutex_lock(&f->sem);
594         for (fd = f->dents ; fd; fd = fd->next) {
595                 if (fd->ino) {
596                         mutex_unlock(&f->sem);
597                         return -ENOTEMPTY;
598                 }
599         }
600         mutex_unlock(&f->sem);
601 
602         ret = jffs2_do_unlink(c, dir_f, dentry->d_name.name,
603                               dentry->d_name.len, f, now);
604         if (!ret) {
605                 dir_i->i_mtime = dir_i->i_ctime = ITIME(now);
606                 clear_nlink(d_inode(dentry));
607                 drop_nlink(dir_i);
608         }
609         return ret;
610 }
611 
612 static int jffs2_mknod (struct inode *dir_i, struct dentry *dentry, umode_t mode, dev_t rdev)
613 {
614         struct jffs2_inode_info *f, *dir_f;
615         struct jffs2_sb_info *c;
616         struct inode *inode;
617         struct jffs2_raw_inode *ri;
618         struct jffs2_raw_dirent *rd;
619         struct jffs2_full_dnode *fn;
620         struct jffs2_full_dirent *fd;
621         int namelen;
622         union jffs2_device_node dev;
623         int devlen = 0;
624         uint32_t alloclen;
625         int ret;
626 
627         ri = jffs2_alloc_raw_inode();
628         if (!ri)
629                 return -ENOMEM;
630 
631         c = JFFS2_SB_INFO(dir_i->i_sb);
632 
633         if (S_ISBLK(mode) || S_ISCHR(mode))
634                 devlen = jffs2_encode_dev(&dev, rdev);
635 
636         /* Try to reserve enough space for both node and dirent.
637          * Just the node will do for now, though
638          */
639         namelen = dentry->d_name.len;
640         ret = jffs2_reserve_space(c, sizeof(*ri) + devlen, &alloclen,
641                                   ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE);
642 
643         if (ret) {
644                 jffs2_free_raw_inode(ri);
645                 return ret;
646         }
647 
648         inode = jffs2_new_inode(dir_i, mode, ri);
649 
650         if (IS_ERR(inode)) {
651                 jffs2_free_raw_inode(ri);
652                 jffs2_complete_reservation(c);
653                 return PTR_ERR(inode);
654         }
655         inode->i_op = &jffs2_file_inode_operations;
656         init_special_inode(inode, inode->i_mode, rdev);
657 
658         f = JFFS2_INODE_INFO(inode);
659 
660         ri->dsize = ri->csize = cpu_to_je32(devlen);
661         ri->totlen = cpu_to_je32(sizeof(*ri) + devlen);
662         ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
663 
664         ri->compr = JFFS2_COMPR_NONE;
665         ri->data_crc = cpu_to_je32(crc32(0, &dev, devlen));
666         ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
667 
668         fn = jffs2_write_dnode(c, f, ri, (char *)&dev, devlen, ALLOC_NORMAL);
669 
670         jffs2_free_raw_inode(ri);
671 
672         if (IS_ERR(fn)) {
673                 /* Eeek. Wave bye bye */
674                 mutex_unlock(&f->sem);
675                 jffs2_complete_reservation(c);
676                 ret = PTR_ERR(fn);
677                 goto fail;
678         }
679         /* No data here. Only a metadata node, which will be
680            obsoleted by the first data write
681         */
682         f->metadata = fn;
683         mutex_unlock(&f->sem);
684 
685         jffs2_complete_reservation(c);
686 
687         ret = jffs2_init_security(inode, dir_i, &dentry->d_name);
688         if (ret)
689                 goto fail;
690 
691         ret = jffs2_init_acl_post(inode);
692         if (ret)
693                 goto fail;
694 
695         ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &alloclen,
696                                   ALLOC_NORMAL, JFFS2_SUMMARY_DIRENT_SIZE(namelen));
697         if (ret)
698                 goto fail;
699 
700         rd = jffs2_alloc_raw_dirent();
701         if (!rd) {
702                 /* Argh. Now we treat it like a normal delete */
703                 jffs2_complete_reservation(c);
704                 ret = -ENOMEM;
705                 goto fail;
706         }
707 
708         dir_f = JFFS2_INODE_INFO(dir_i);
709         mutex_lock(&dir_f->sem);
710 
711         rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
712         rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT);
713         rd->totlen = cpu_to_je32(sizeof(*rd) + namelen);
714         rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4));
715 
716         rd->pino = cpu_to_je32(dir_i->i_ino);
717         rd->version = cpu_to_je32(++dir_f->highest_version);
718         rd->ino = cpu_to_je32(inode->i_ino);
719         rd->mctime = cpu_to_je32(JFFS2_NOW());
720         rd->nsize = namelen;
721 
722         /* XXX: This is ugly. */
723         rd->type = (mode & S_IFMT) >> 12;
724 
725         rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
726         rd->name_crc = cpu_to_je32(crc32(0, dentry->d_name.name, namelen));
727 
728         fd = jffs2_write_dirent(c, dir_f, rd, dentry->d_name.name, namelen, ALLOC_NORMAL);
729 
730         if (IS_ERR(fd)) {
731                 /* dirent failed to write. Delete the inode normally
732                    as if it were the final unlink() */
733                 jffs2_complete_reservation(c);
734                 jffs2_free_raw_dirent(rd);
735                 mutex_unlock(&dir_f->sem);
736                 ret = PTR_ERR(fd);
737                 goto fail;
738         }
739 
740         dir_i->i_mtime = dir_i->i_ctime = ITIME(je32_to_cpu(rd->mctime));
741 
742         jffs2_free_raw_dirent(rd);
743 
744         /* Link the fd into the inode's list, obsoleting an old
745            one if necessary. */
746         jffs2_add_fd_to_list(c, fd, &dir_f->dents);
747 
748         mutex_unlock(&dir_f->sem);
749         jffs2_complete_reservation(c);
750 
751         d_instantiate_new(dentry, inode);
752         return 0;
753 
754  fail:
755         iget_failed(inode);
756         return ret;
757 }
758 
759 static int jffs2_rename (struct inode *old_dir_i, struct dentry *old_dentry,
760                          struct inode *new_dir_i, struct dentry *new_dentry,
761                          unsigned int flags)
762 {
763         int ret;
764         struct jffs2_sb_info *c = JFFS2_SB_INFO(old_dir_i->i_sb);
765         struct jffs2_inode_info *victim_f = NULL;
766         uint8_t type;
767         uint32_t now;
768 
769         if (flags & ~RENAME_NOREPLACE)
770                 return -EINVAL;
771 
772         /* The VFS will check for us and prevent trying to rename a
773          * file over a directory and vice versa, but if it's a directory,
774          * the VFS can't check whether the victim is empty. The filesystem
775          * needs to do that for itself.
776          */
777         if (d_really_is_positive(new_dentry)) {
778                 victim_f = JFFS2_INODE_INFO(d_inode(new_dentry));
779                 if (d_is_dir(new_dentry)) {
780                         struct jffs2_full_dirent *fd;
781 
782                         mutex_lock(&victim_f->sem);
783                         for (fd = victim_f->dents; fd; fd = fd->next) {
784                                 if (fd->ino) {
785                                         mutex_unlock(&victim_f->sem);
786                                         return -ENOTEMPTY;
787                                 }
788                         }
789                         mutex_unlock(&victim_f->sem);
790                 }
791         }
792 
793         /* XXX: We probably ought to alloc enough space for
794            both nodes at the same time. Writing the new link,
795            then getting -ENOSPC, is quite bad :)
796         */
797 
798         /* Make a hard link */
799 
800         /* XXX: This is ugly */
801         type = (d_inode(old_dentry)->i_mode & S_IFMT) >> 12;
802         if (!type) type = DT_REG;
803 
804         now = JFFS2_NOW();
805         ret = jffs2_do_link(c, JFFS2_INODE_INFO(new_dir_i),
806                             d_inode(old_dentry)->i_ino, type,
807                             new_dentry->d_name.name, new_dentry->d_name.len, now);
808 
809         if (ret)
810                 return ret;
811 
812         if (victim_f) {
813                 /* There was a victim. Kill it off nicely */
814                 if (d_is_dir(new_dentry))
815                         clear_nlink(d_inode(new_dentry));
816                 else
817                         drop_nlink(d_inode(new_dentry));
818                 /* Don't oops if the victim was a dirent pointing to an
819                    inode which didn't exist. */
820                 if (victim_f->inocache) {
821                         mutex_lock(&victim_f->sem);
822                         if (d_is_dir(new_dentry))
823                                 victim_f->inocache->pino_nlink = 0;
824                         else
825                                 victim_f->inocache->pino_nlink--;
826                         mutex_unlock(&victim_f->sem);
827                 }
828         }
829 
830         /* If it was a directory we moved, and there was no victim,
831            increase i_nlink on its new parent */
832         if (d_is_dir(old_dentry) && !victim_f)
833                 inc_nlink(new_dir_i);
834 
835         /* Unlink the original */
836         ret = jffs2_do_unlink(c, JFFS2_INODE_INFO(old_dir_i),
837                               old_dentry->d_name.name, old_dentry->d_name.len, NULL, now);
838 
839         /* We don't touch inode->i_nlink */
840 
841         if (ret) {
842                 /* Oh shit. We really ought to make a single node which can do both atomically */
843                 struct jffs2_inode_info *f = JFFS2_INODE_INFO(d_inode(old_dentry));
844                 mutex_lock(&f->sem);
845                 inc_nlink(d_inode(old_dentry));
846                 if (f->inocache && !d_is_dir(old_dentry))
847                         f->inocache->pino_nlink++;
848                 mutex_unlock(&f->sem);
849 
850                 pr_notice("%s(): Link succeeded, unlink failed (err %d). You now have a hard link\n",
851                           __func__, ret);
852                 /*
853                  * We can't keep the target in dcache after that.
854                  * For one thing, we can't afford dentry aliases for directories.
855                  * For another, if there was a victim, we _can't_ set new inode
856                  * for that sucker and we have to trigger mount eviction - the
857                  * caller won't do it on its own since we are returning an error.
858                  */
859                 d_invalidate(new_dentry);
860                 new_dir_i->i_mtime = new_dir_i->i_ctime = ITIME(now);
861                 return ret;
862         }
863 
864         if (d_is_dir(old_dentry))
865                 drop_nlink(old_dir_i);
866 
867         new_dir_i->i_mtime = new_dir_i->i_ctime = old_dir_i->i_mtime = old_dir_i->i_ctime = ITIME(now);
868 
869         return 0;
870 }
871 
872 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp