blob: 5c27c66c224af38618ec4f92b453bd8e65d24608 [file] [log] [blame]
Artem Bityutskiy1e517642008-07-14 19:08:37 +03001/* * This file is part of UBIFS.
2 *
3 * Copyright (C) 2006-2008 Nokia Corporation.
4 * Copyright (C) 2006, 2007 University of Szeged, Hungary
5 *
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License version 2 as published by
8 * the Free Software Foundation.
9 *
10 * This program is distributed in the hope that it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
13 * more details.
14 *
15 * You should have received a copy of the GNU General Public License along with
16 * this program; if not, write to the Free Software Foundation, Inc., 51
17 * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
18 *
19 * Authors: Artem Bityutskiy (Битюцкий Артём)
20 * Adrian Hunter
21 * Zoltan Sogor
22 */
23
24/*
25 * This file implements directory operations.
26 *
27 * All FS operations in this file allocate budget before writing anything to the
28 * media. If they fail to allocate it, the error is returned. The only
29 * exceptions are 'ubifs_unlink()' and 'ubifs_rmdir()' which keep working even
30 * if they unable to allocate the budget, because deletion %-ENOSPC failure is
31 * not what users are usually ready to get. UBIFS budgeting subsystem has some
32 * space reserved for these purposes.
33 *
34 * All operations in this file write all inodes which they change straight
35 * away, instead of marking them dirty. For example, 'ubifs_link()' changes
36 * @i_size of the parent inode and writes the parent inode together with the
37 * target inode. This was done to simplify file-system recovery which would
38 * otherwise be very difficult to do. The only exception is rename which marks
39 * the re-named inode dirty (because its @i_ctime is updated) but does not
40 * write it, but just marks it as dirty.
41 */
42
43#include "ubifs.h"
44
45/**
46 * inherit_flags - inherit flags of the parent inode.
47 * @dir: parent inode
48 * @mode: new inode mode flags
49 *
50 * This is a helper function for 'ubifs_new_inode()' which inherits flag of the
51 * parent directory inode @dir. UBIFS inodes inherit the following flags:
52 * o %UBIFS_COMPR_FL, which is useful to switch compression on/of on
53 * sub-directory basis;
54 * o %UBIFS_SYNC_FL - useful for the same reasons;
55 * o %UBIFS_DIRSYNC_FL - similar, but relevant only to directories.
56 *
57 * This function returns the inherited flags.
58 */
Al Viroad44be52011-07-26 03:12:59 -040059static int inherit_flags(const struct inode *dir, umode_t mode)
Artem Bityutskiy1e517642008-07-14 19:08:37 +030060{
61 int flags;
62 const struct ubifs_inode *ui = ubifs_inode(dir);
63
64 if (!S_ISDIR(dir->i_mode))
65 /*
66 * The parent is not a directory, which means that an extended
67 * attribute inode is being created. No flags.
68 */
69 return 0;
70
71 flags = ui->flags & (UBIFS_COMPR_FL | UBIFS_SYNC_FL | UBIFS_DIRSYNC_FL);
72 if (!S_ISDIR(mode))
73 /* The "DIRSYNC" flag only applies to directories */
74 flags &= ~UBIFS_DIRSYNC_FL;
75 return flags;
76}
77
78/**
79 * ubifs_new_inode - allocate new UBIFS inode object.
80 * @c: UBIFS file-system description object
81 * @dir: parent directory inode
82 * @mode: inode mode flags
83 *
84 * This function finds an unused inode number, allocates new inode and
85 * initializes it. Returns new inode in case of success and an error code in
86 * case of failure.
87 */
88struct inode *ubifs_new_inode(struct ubifs_info *c, const struct inode *dir,
Al Viroad44be52011-07-26 03:12:59 -040089 umode_t mode)
Artem Bityutskiy1e517642008-07-14 19:08:37 +030090{
91 struct inode *inode;
92 struct ubifs_inode *ui;
93
94 inode = new_inode(c->vfs_sb);
95 ui = ubifs_inode(inode);
96 if (!inode)
97 return ERR_PTR(-ENOMEM);
98
99 /*
100 * Set 'S_NOCMTIME' to prevent VFS form updating [mc]time of inodes and
101 * marking them dirty in file write path (see 'file_update_time()').
102 * UBIFS has to fully control "clean <-> dirty" transitions of inodes
103 * to make budgeting work.
104 */
Artem Bityutskiy12e776a2011-05-27 15:50:39 +0300105 inode->i_flags |= S_NOCMTIME;
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300106
Dmitry Monakhovabf5d082010-03-04 17:32:21 +0300107 inode_init_owner(inode, dir, mode);
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300108 inode->i_mtime = inode->i_atime = inode->i_ctime =
109 ubifs_current_time(inode);
110 inode->i_mapping->nrpages = 0;
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300111
112 switch (mode & S_IFMT) {
113 case S_IFREG:
114 inode->i_mapping->a_ops = &ubifs_file_address_operations;
115 inode->i_op = &ubifs_file_inode_operations;
116 inode->i_fop = &ubifs_file_operations;
117 break;
118 case S_IFDIR:
119 inode->i_op = &ubifs_dir_inode_operations;
120 inode->i_fop = &ubifs_dir_operations;
121 inode->i_size = ui->ui_size = UBIFS_INO_NODE_SZ;
122 break;
123 case S_IFLNK:
124 inode->i_op = &ubifs_symlink_inode_operations;
125 break;
126 case S_IFSOCK:
127 case S_IFIFO:
128 case S_IFBLK:
129 case S_IFCHR:
130 inode->i_op = &ubifs_file_inode_operations;
131 break;
132 default:
133 BUG();
134 }
135
136 ui->flags = inherit_flags(dir, mode);
137 ubifs_set_inode_flags(inode);
138 if (S_ISREG(mode))
139 ui->compr_type = c->default_compr;
140 else
141 ui->compr_type = UBIFS_COMPR_NONE;
142 ui->synced_i_size = 0;
143
144 spin_lock(&c->cnt_lock);
145 /* Inode number overflow is currently not supported */
146 if (c->highest_inum >= INUM_WARN_WATERMARK) {
147 if (c->highest_inum >= INUM_WATERMARK) {
148 spin_unlock(&c->cnt_lock);
Sheng Yong235c3622015-03-20 10:39:42 +0000149 ubifs_err(c, "out of inode numbers");
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300150 make_bad_inode(inode);
151 iput(inode);
152 return ERR_PTR(-EINVAL);
153 }
Sheng Yong1a7e985d2015-04-03 03:13:42 +0000154 ubifs_warn(c, "running out of inode numbers (current %lu, max %u)",
Artem Bityutskiye84461a2008-10-29 12:08:43 +0200155 (unsigned long)c->highest_inum, INUM_WATERMARK);
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300156 }
157
158 inode->i_ino = ++c->highest_inum;
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300159 /*
160 * The creation sequence number remains with this inode for its
161 * lifetime. All nodes for this inode have a greater sequence number,
162 * and so it is possible to distinguish obsolete nodes belonging to a
163 * previous incarnation of the same inode number - for example, for the
164 * purpose of rebuilding the index.
165 */
166 ui->creat_sqnum = ++c->max_sqnum;
167 spin_unlock(&c->cnt_lock);
168 return inode;
169}
170
Artem Bityutskiybb2615d2011-05-31 17:47:53 +0300171static int dbg_check_name(const struct ubifs_info *c,
172 const struct ubifs_dent_node *dent,
173 const struct qstr *nm)
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300174{
Artem Bityutskiy2b1844a2011-06-03 08:31:29 +0300175 if (!dbg_is_chk_gen(c))
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300176 return 0;
177 if (le16_to_cpu(dent->nlen) != nm->len)
178 return -EINVAL;
179 if (memcmp(dent->name, nm->name, nm->len))
180 return -EINVAL;
181 return 0;
182}
183
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300184static struct dentry *ubifs_lookup(struct inode *dir, struct dentry *dentry,
Al Viro00cd8dd2012-06-10 17:13:09 -0400185 unsigned int flags)
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300186{
187 int err;
188 union ubifs_key key;
189 struct inode *inode = NULL;
190 struct ubifs_dent_node *dent;
191 struct ubifs_info *c = dir->i_sb->s_fs_info;
192
Al Viro4cb2a012013-09-16 10:58:53 -0400193 dbg_gen("'%pd' in dir ino %lu", dentry, dir->i_ino);
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300194
195 if (dentry->d_name.len > UBIFS_MAX_NLEN)
196 return ERR_PTR(-ENAMETOOLONG);
197
198 dent = kmalloc(UBIFS_MAX_DENT_NODE_SZ, GFP_NOFS);
199 if (!dent)
200 return ERR_PTR(-ENOMEM);
201
202 dent_key_init(c, &key, dir->i_ino, &dentry->d_name);
203
204 err = ubifs_tnc_lookup_nm(c, &key, dent, &dentry->d_name);
205 if (err) {
Artem Bityutskiy720b4992008-08-13 16:16:31 +0300206 if (err == -ENOENT) {
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300207 dbg_gen("not found");
208 goto done;
209 }
210 goto out;
211 }
212
Artem Bityutskiybb2615d2011-05-31 17:47:53 +0300213 if (dbg_check_name(c, dent, &dentry->d_name)) {
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300214 err = -EINVAL;
215 goto out;
216 }
217
218 inode = ubifs_iget(dir->i_sb, le64_to_cpu(dent->inum));
219 if (IS_ERR(inode)) {
220 /*
221 * This should not happen. Probably the file-system needs
222 * checking.
223 */
224 err = PTR_ERR(inode);
Sheng Yong235c3622015-03-20 10:39:42 +0000225 ubifs_err(c, "dead directory entry '%pd', error %d",
Al Viro4cb2a012013-09-16 10:58:53 -0400226 dentry, err);
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300227 ubifs_ro_mode(c, err);
228 goto out;
229 }
230
231done:
232 kfree(dent);
233 /*
234 * Note, d_splice_alias() would be required instead if we supported
235 * NFS.
236 */
237 d_add(dentry, inode);
238 return NULL;
239
240out:
241 kfree(dent);
242 return ERR_PTR(err);
243}
244
Al Viro4acdaf22011-07-26 01:42:34 -0400245static int ubifs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
Al Viroebfc3b42012-06-10 18:05:36 -0400246 bool excl)
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300247{
248 struct inode *inode;
249 struct ubifs_info *c = dir->i_sb->s_fs_info;
250 int err, sz_change = CALC_DENT_SIZE(dentry->d_name.len);
251 struct ubifs_budget_req req = { .new_ino = 1, .new_dent = 1,
252 .dirtied_ino = 1 };
253 struct ubifs_inode *dir_ui = ubifs_inode(dir);
254
255 /*
256 * Budget request settings: new inode, new direntry, changing the
257 * parent directory inode.
258 */
259
Al Viro4cb2a012013-09-16 10:58:53 -0400260 dbg_gen("dent '%pd', mode %#hx in dir ino %lu",
261 dentry, mode, dir->i_ino);
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300262
263 err = ubifs_budget_space(c, &req);
264 if (err)
265 return err;
266
267 inode = ubifs_new_inode(c, dir, mode);
268 if (IS_ERR(inode)) {
269 err = PTR_ERR(inode);
270 goto out_budg;
271 }
272
Subodh Nijsured7f0b702014-10-31 13:50:30 -0500273 err = ubifs_init_security(dir, inode, &dentry->d_name);
274 if (err)
Taesoo Kim9401a792015-03-25 09:53:37 +0100275 goto out_inode;
Subodh Nijsured7f0b702014-10-31 13:50:30 -0500276
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300277 mutex_lock(&dir_ui->ui_mutex);
278 dir->i_size += sz_change;
279 dir_ui->ui_size = dir->i_size;
280 dir->i_mtime = dir->i_ctime = inode->i_ctime;
281 err = ubifs_jnl_update(c, dir, &dentry->d_name, inode, 0, 0);
282 if (err)
283 goto out_cancel;
284 mutex_unlock(&dir_ui->ui_mutex);
285
286 ubifs_release_budget(c, &req);
287 insert_inode_hash(inode);
288 d_instantiate(dentry, inode);
289 return 0;
290
291out_cancel:
292 dir->i_size -= sz_change;
293 dir_ui->ui_size = dir->i_size;
294 mutex_unlock(&dir_ui->ui_mutex);
Taesoo Kim9401a792015-03-25 09:53:37 +0100295out_inode:
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300296 make_bad_inode(inode);
297 iput(inode);
298out_budg:
299 ubifs_release_budget(c, &req);
Sheng Yong235c3622015-03-20 10:39:42 +0000300 ubifs_err(c, "cannot create regular file, error %d", err);
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300301 return err;
302}
303
304/**
305 * vfs_dent_type - get VFS directory entry type.
306 * @type: UBIFS directory entry type
307 *
308 * This function converts UBIFS directory entry type into VFS directory entry
309 * type.
310 */
311static unsigned int vfs_dent_type(uint8_t type)
312{
313 switch (type) {
314 case UBIFS_ITYPE_REG:
315 return DT_REG;
316 case UBIFS_ITYPE_DIR:
317 return DT_DIR;
318 case UBIFS_ITYPE_LNK:
319 return DT_LNK;
320 case UBIFS_ITYPE_BLK:
321 return DT_BLK;
322 case UBIFS_ITYPE_CHR:
323 return DT_CHR;
324 case UBIFS_ITYPE_FIFO:
325 return DT_FIFO;
326 case UBIFS_ITYPE_SOCK:
327 return DT_SOCK;
328 default:
329 BUG();
330 }
331 return 0;
332}
333
334/*
335 * The classical Unix view for directory is that it is a linear array of
336 * (name, inode number) entries. Linux/VFS assumes this model as well.
337 * Particularly, 'readdir()' call wants us to return a directory entry offset
338 * which later may be used to continue 'readdir()'ing the directory or to
339 * 'seek()' to that specific direntry. Obviously UBIFS does not really fit this
340 * model because directory entries are identified by keys, which may collide.
341 *
342 * UBIFS uses directory entry hash value for directory offsets, so
343 * 'seekdir()'/'telldir()' may not always work because of possible key
344 * collisions. But UBIFS guarantees that consecutive 'readdir()' calls work
345 * properly by means of saving full directory entry name in the private field
346 * of the file description object.
347 *
348 * This means that UBIFS cannot support NFS which requires full
349 * 'seekdir()'/'telldir()' support.
350 */
Al Viro01122e02013-05-16 01:14:46 -0400351static int ubifs_readdir(struct file *file, struct dir_context *ctx)
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300352{
Al Viro01122e02013-05-16 01:14:46 -0400353 int err;
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300354 struct qstr nm;
355 union ubifs_key key;
356 struct ubifs_dent_node *dent;
Al Viro496ad9a2013-01-23 17:07:38 -0500357 struct inode *dir = file_inode(file);
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300358 struct ubifs_info *c = dir->i_sb->s_fs_info;
359
Al Viro01122e02013-05-16 01:14:46 -0400360 dbg_gen("dir ino %lu, f_pos %#llx", dir->i_ino, ctx->pos);
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300361
Al Viro01122e02013-05-16 01:14:46 -0400362 if (ctx->pos > UBIFS_S_KEY_HASH_MASK || ctx->pos == 2)
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300363 /*
364 * The directory was seek'ed to a senseless position or there
365 * are no more entries.
366 */
367 return 0;
368
Artem Bityutskiy605c9122013-06-28 14:15:15 +0300369 if (file->f_version == 0) {
370 /*
371 * The file was seek'ed, which means that @file->private_data
372 * is now invalid. This may also be just the first
373 * 'ubifs_readdir()' invocation, in which case
374 * @file->private_data is NULL, and the below code is
375 * basically a no-op.
376 */
377 kfree(file->private_data);
378 file->private_data = NULL;
379 }
380
381 /*
382 * 'generic_file_llseek()' unconditionally sets @file->f_version to
383 * zero, and we use this for detecting whether the file was seek'ed.
384 */
385 file->f_version = 1;
386
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300387 /* File positions 0 and 1 correspond to "." and ".." */
Al Viro01122e02013-05-16 01:14:46 -0400388 if (ctx->pos < 2) {
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300389 ubifs_assert(!file->private_data);
Al Viro01122e02013-05-16 01:14:46 -0400390 if (!dir_emit_dots(file, ctx))
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300391 return 0;
392
393 /* Find the first entry in TNC and save it */
394 lowest_dent_key(c, &key, dir->i_ino);
395 nm.name = NULL;
396 dent = ubifs_tnc_next_ent(c, &key, &nm);
397 if (IS_ERR(dent)) {
398 err = PTR_ERR(dent);
399 goto out;
400 }
401
Al Viro01122e02013-05-16 01:14:46 -0400402 ctx->pos = key_hash_flash(c, &dent->key);
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300403 file->private_data = dent;
404 }
405
406 dent = file->private_data;
407 if (!dent) {
408 /*
409 * The directory was seek'ed to and is now readdir'ed.
Al Viro01122e02013-05-16 01:14:46 -0400410 * Find the entry corresponding to @ctx->pos or the closest one.
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300411 */
Al Viro01122e02013-05-16 01:14:46 -0400412 dent_key_init_hash(c, &key, dir->i_ino, ctx->pos);
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300413 nm.name = NULL;
414 dent = ubifs_tnc_next_ent(c, &key, &nm);
415 if (IS_ERR(dent)) {
416 err = PTR_ERR(dent);
417 goto out;
418 }
Al Viro01122e02013-05-16 01:14:46 -0400419 ctx->pos = key_hash_flash(c, &dent->key);
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300420 file->private_data = dent;
421 }
422
423 while (1) {
424 dbg_gen("feed '%s', ino %llu, new f_pos %#x",
Alexander Beregalov7424bac2008-09-17 22:09:41 +0400425 dent->name, (unsigned long long)le64_to_cpu(dent->inum),
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300426 key_hash_flash(c, &dent->key));
Harvey Harrison0ecb9522008-10-24 10:52:57 -0700427 ubifs_assert(le64_to_cpu(dent->ch.sqnum) >
428 ubifs_inode(dir)->creat_sqnum);
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300429
430 nm.len = le16_to_cpu(dent->nlen);
Al Viro01122e02013-05-16 01:14:46 -0400431 if (!dir_emit(ctx, dent->name, nm.len,
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300432 le64_to_cpu(dent->inum),
Al Viro01122e02013-05-16 01:14:46 -0400433 vfs_dent_type(dent->type)))
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300434 return 0;
435
436 /* Switch to the next entry */
437 key_read(c, &dent->key, &key);
438 nm.name = dent->name;
439 dent = ubifs_tnc_next_ent(c, &key, &nm);
440 if (IS_ERR(dent)) {
441 err = PTR_ERR(dent);
442 goto out;
443 }
444
445 kfree(file->private_data);
Al Viro01122e02013-05-16 01:14:46 -0400446 ctx->pos = key_hash_flash(c, &dent->key);
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300447 file->private_data = dent;
448 cond_resched();
449 }
450
451out:
452 if (err != -ENOENT) {
Sheng Yong235c3622015-03-20 10:39:42 +0000453 ubifs_err(c, "cannot find next direntry, error %d", err);
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300454 return err;
455 }
456
457 kfree(file->private_data);
458 file->private_data = NULL;
Artem Bityutskiy605c9122013-06-28 14:15:15 +0300459 /* 2 is a special value indicating that there are no more direntries */
Al Viro01122e02013-05-16 01:14:46 -0400460 ctx->pos = 2;
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300461 return 0;
462}
463
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300464/* Free saved readdir() state when the directory is closed */
465static int ubifs_dir_release(struct inode *dir, struct file *file)
466{
467 kfree(file->private_data);
468 file->private_data = NULL;
469 return 0;
470}
471
472/**
Artem Bityutskiy82c15932009-01-20 16:46:02 +0200473 * lock_2_inodes - a wrapper for locking two UBIFS inodes.
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300474 * @inode1: first inode
475 * @inode2: second inode
Artem Bityutskiy82c15932009-01-20 16:46:02 +0200476 *
477 * We do not implement any tricks to guarantee strict lock ordering, because
478 * VFS has already done it for us on the @i_mutex. So this is just a simple
479 * wrapper function.
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300480 */
481static void lock_2_inodes(struct inode *inode1, struct inode *inode2)
482{
Artem Bityutskiy82c15932009-01-20 16:46:02 +0200483 mutex_lock_nested(&ubifs_inode(inode1)->ui_mutex, WB_MUTEX_1);
484 mutex_lock_nested(&ubifs_inode(inode2)->ui_mutex, WB_MUTEX_2);
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300485}
486
487/**
Artem Bityutskiy82c15932009-01-20 16:46:02 +0200488 * unlock_2_inodes - a wrapper for unlocking two UBIFS inodes.
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300489 * @inode1: first inode
490 * @inode2: second inode
491 */
492static void unlock_2_inodes(struct inode *inode1, struct inode *inode2)
493{
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300494 mutex_unlock(&ubifs_inode(inode2)->ui_mutex);
Artem Bityutskiy82c15932009-01-20 16:46:02 +0200495 mutex_unlock(&ubifs_inode(inode1)->ui_mutex);
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300496}
497
498static int ubifs_link(struct dentry *old_dentry, struct inode *dir,
499 struct dentry *dentry)
500{
501 struct ubifs_info *c = dir->i_sb->s_fs_info;
David Howells2b0143b2015-03-17 22:25:59 +0000502 struct inode *inode = d_inode(old_dentry);
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300503 struct ubifs_inode *ui = ubifs_inode(inode);
504 struct ubifs_inode *dir_ui = ubifs_inode(dir);
505 int err, sz_change = CALC_DENT_SIZE(dentry->d_name.len);
506 struct ubifs_budget_req req = { .new_dent = 1, .dirtied_ino = 2,
Artem Bityutskiydab4b4d2008-07-24 14:52:45 +0300507 .dirtied_ino_d = ALIGN(ui->data_len, 8) };
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300508
509 /*
510 * Budget request settings: new direntry, changing the target inode,
511 * changing the parent inode.
512 */
513
Al Viro4cb2a012013-09-16 10:58:53 -0400514 dbg_gen("dent '%pd' to ino %lu (nlink %d) in dir ino %lu",
515 dentry, inode->i_ino,
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300516 inode->i_nlink, dir->i_ino);
Artem Bityutskiy82c15932009-01-20 16:46:02 +0200517 ubifs_assert(mutex_is_locked(&dir->i_mutex));
518 ubifs_assert(mutex_is_locked(&inode->i_mutex));
Hunter Adrian8b3884a2009-05-14 06:32:30 +0200519
Artem Bityutskiyd808efb2011-05-31 18:14:38 +0300520 err = dbg_check_synced_i_size(c, inode);
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300521 if (err)
522 return err;
523
524 err = ubifs_budget_space(c, &req);
525 if (err)
526 return err;
527
528 lock_2_inodes(dir, inode);
529 inc_nlink(inode);
Al Viro7de9c6ee2010-10-23 11:11:40 -0400530 ihold(inode);
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300531 inode->i_ctime = ubifs_current_time(inode);
532 dir->i_size += sz_change;
533 dir_ui->ui_size = dir->i_size;
534 dir->i_mtime = dir->i_ctime = inode->i_ctime;
535 err = ubifs_jnl_update(c, dir, &dentry->d_name, inode, 0, 0);
536 if (err)
537 goto out_cancel;
538 unlock_2_inodes(dir, inode);
539
540 ubifs_release_budget(c, &req);
541 d_instantiate(dentry, inode);
542 return 0;
543
544out_cancel:
545 dir->i_size -= sz_change;
546 dir_ui->ui_size = dir->i_size;
547 drop_nlink(inode);
548 unlock_2_inodes(dir, inode);
549 ubifs_release_budget(c, &req);
550 iput(inode);
551 return err;
552}
553
554static int ubifs_unlink(struct inode *dir, struct dentry *dentry)
555{
556 struct ubifs_info *c = dir->i_sb->s_fs_info;
David Howells2b0143b2015-03-17 22:25:59 +0000557 struct inode *inode = d_inode(dentry);
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300558 struct ubifs_inode *dir_ui = ubifs_inode(dir);
559 int sz_change = CALC_DENT_SIZE(dentry->d_name.len);
560 int err, budgeted = 1;
561 struct ubifs_budget_req req = { .mod_dent = 1, .dirtied_ino = 2 };
Artem Bityutskiyc43be102012-02-07 10:58:51 +0200562 unsigned int saved_nlink = inode->i_nlink;
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300563
564 /*
565 * Budget request settings: deletion direntry, deletion inode (+1 for
566 * @dirtied_ino), changing the parent directory inode. If budgeting
567 * fails, go ahead anyway because we have extra space reserved for
568 * deletions.
569 */
570
Al Viro4cb2a012013-09-16 10:58:53 -0400571 dbg_gen("dent '%pd' from ino %lu (nlink %d) in dir ino %lu",
572 dentry, inode->i_ino,
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300573 inode->i_nlink, dir->i_ino);
Artem Bityutskiy82c15932009-01-20 16:46:02 +0200574 ubifs_assert(mutex_is_locked(&dir->i_mutex));
575 ubifs_assert(mutex_is_locked(&inode->i_mutex));
Artem Bityutskiyd808efb2011-05-31 18:14:38 +0300576 err = dbg_check_synced_i_size(c, inode);
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300577 if (err)
578 return err;
579
580 err = ubifs_budget_space(c, &req);
581 if (err) {
582 if (err != -ENOSPC)
583 return err;
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300584 budgeted = 0;
585 }
586
587 lock_2_inodes(dir, inode);
588 inode->i_ctime = ubifs_current_time(dir);
589 drop_nlink(inode);
590 dir->i_size -= sz_change;
591 dir_ui->ui_size = dir->i_size;
592 dir->i_mtime = dir->i_ctime = inode->i_ctime;
593 err = ubifs_jnl_update(c, dir, &dentry->d_name, inode, 1, 0);
594 if (err)
595 goto out_cancel;
596 unlock_2_inodes(dir, inode);
597
598 if (budgeted)
599 ubifs_release_budget(c, &req);
600 else {
601 /* We've deleted something - clean the "no space" flags */
Artem Bityutskiyb1375452011-03-29 18:04:05 +0300602 c->bi.nospace = c->bi.nospace_rp = 0;
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300603 smp_wmb();
604 }
605 return 0;
606
607out_cancel:
608 dir->i_size += sz_change;
609 dir_ui->ui_size = dir->i_size;
Artem Bityutskiyc43be102012-02-07 10:58:51 +0200610 set_nlink(inode, saved_nlink);
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300611 unlock_2_inodes(dir, inode);
612 if (budgeted)
613 ubifs_release_budget(c, &req);
614 return err;
615}
616
617/**
618 * check_dir_empty - check if a directory is empty or not.
619 * @c: UBIFS file-system description object
620 * @dir: VFS inode object of the directory to check
621 *
622 * This function checks if directory @dir is empty. Returns zero if the
623 * directory is empty, %-ENOTEMPTY if it is not, and other negative error codes
624 * in case of of errors.
625 */
626static int check_dir_empty(struct ubifs_info *c, struct inode *dir)
627{
628 struct qstr nm = { .name = NULL };
629 struct ubifs_dent_node *dent;
630 union ubifs_key key;
631 int err;
632
633 lowest_dent_key(c, &key, dir->i_ino);
634 dent = ubifs_tnc_next_ent(c, &key, &nm);
635 if (IS_ERR(dent)) {
636 err = PTR_ERR(dent);
637 if (err == -ENOENT)
638 err = 0;
639 } else {
640 kfree(dent);
641 err = -ENOTEMPTY;
642 }
643 return err;
644}
645
646static int ubifs_rmdir(struct inode *dir, struct dentry *dentry)
647{
648 struct ubifs_info *c = dir->i_sb->s_fs_info;
David Howells2b0143b2015-03-17 22:25:59 +0000649 struct inode *inode = d_inode(dentry);
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300650 int sz_change = CALC_DENT_SIZE(dentry->d_name.len);
651 int err, budgeted = 1;
652 struct ubifs_inode *dir_ui = ubifs_inode(dir);
653 struct ubifs_budget_req req = { .mod_dent = 1, .dirtied_ino = 2 };
654
655 /*
656 * Budget request settings: deletion direntry, deletion inode and
657 * changing the parent inode. If budgeting fails, go ahead anyway
658 * because we have extra space reserved for deletions.
659 */
660
Al Viro4cb2a012013-09-16 10:58:53 -0400661 dbg_gen("directory '%pd', ino %lu in dir ino %lu", dentry,
662 inode->i_ino, dir->i_ino);
Artem Bityutskiy82c15932009-01-20 16:46:02 +0200663 ubifs_assert(mutex_is_locked(&dir->i_mutex));
664 ubifs_assert(mutex_is_locked(&inode->i_mutex));
David Howells2b0143b2015-03-17 22:25:59 +0000665 err = check_dir_empty(c, d_inode(dentry));
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300666 if (err)
667 return err;
668
669 err = ubifs_budget_space(c, &req);
670 if (err) {
671 if (err != -ENOSPC)
672 return err;
673 budgeted = 0;
674 }
675
676 lock_2_inodes(dir, inode);
677 inode->i_ctime = ubifs_current_time(dir);
678 clear_nlink(inode);
679 drop_nlink(dir);
680 dir->i_size -= sz_change;
681 dir_ui->ui_size = dir->i_size;
682 dir->i_mtime = dir->i_ctime = inode->i_ctime;
683 err = ubifs_jnl_update(c, dir, &dentry->d_name, inode, 1, 0);
684 if (err)
685 goto out_cancel;
686 unlock_2_inodes(dir, inode);
687
688 if (budgeted)
689 ubifs_release_budget(c, &req);
690 else {
691 /* We've deleted something - clean the "no space" flags */
Artem Bityutskiyb1375452011-03-29 18:04:05 +0300692 c->bi.nospace = c->bi.nospace_rp = 0;
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300693 smp_wmb();
694 }
695 return 0;
696
697out_cancel:
698 dir->i_size += sz_change;
699 dir_ui->ui_size = dir->i_size;
700 inc_nlink(dir);
Artem Bityutskiyc43be102012-02-07 10:58:51 +0200701 set_nlink(inode, 2);
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300702 unlock_2_inodes(dir, inode);
703 if (budgeted)
704 ubifs_release_budget(c, &req);
705 return err;
706}
707
Al Viro18bb1db2011-07-26 01:41:39 -0400708static int ubifs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300709{
710 struct inode *inode;
711 struct ubifs_inode *dir_ui = ubifs_inode(dir);
712 struct ubifs_info *c = dir->i_sb->s_fs_info;
713 int err, sz_change = CALC_DENT_SIZE(dentry->d_name.len);
Artem Bityutskiy182854b2008-07-18 18:54:29 +0300714 struct ubifs_budget_req req = { .new_ino = 1, .new_dent = 1 };
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300715
716 /*
717 * Budget request settings: new inode, new direntry and changing parent
718 * directory inode.
719 */
720
Al Viro4cb2a012013-09-16 10:58:53 -0400721 dbg_gen("dent '%pd', mode %#hx in dir ino %lu",
722 dentry, mode, dir->i_ino);
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300723
724 err = ubifs_budget_space(c, &req);
725 if (err)
726 return err;
727
728 inode = ubifs_new_inode(c, dir, S_IFDIR | mode);
729 if (IS_ERR(inode)) {
730 err = PTR_ERR(inode);
731 goto out_budg;
732 }
733
Subodh Nijsured7f0b702014-10-31 13:50:30 -0500734 err = ubifs_init_security(dir, inode, &dentry->d_name);
735 if (err)
Taesoo Kim9401a792015-03-25 09:53:37 +0100736 goto out_inode;
Subodh Nijsured7f0b702014-10-31 13:50:30 -0500737
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300738 mutex_lock(&dir_ui->ui_mutex);
739 insert_inode_hash(inode);
740 inc_nlink(inode);
741 inc_nlink(dir);
742 dir->i_size += sz_change;
743 dir_ui->ui_size = dir->i_size;
744 dir->i_mtime = dir->i_ctime = inode->i_ctime;
745 err = ubifs_jnl_update(c, dir, &dentry->d_name, inode, 0, 0);
746 if (err) {
Sheng Yong235c3622015-03-20 10:39:42 +0000747 ubifs_err(c, "cannot create directory, error %d", err);
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300748 goto out_cancel;
749 }
750 mutex_unlock(&dir_ui->ui_mutex);
751
752 ubifs_release_budget(c, &req);
753 d_instantiate(dentry, inode);
754 return 0;
755
756out_cancel:
757 dir->i_size -= sz_change;
758 dir_ui->ui_size = dir->i_size;
759 drop_nlink(dir);
760 mutex_unlock(&dir_ui->ui_mutex);
Taesoo Kim9401a792015-03-25 09:53:37 +0100761out_inode:
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300762 make_bad_inode(inode);
763 iput(inode);
764out_budg:
765 ubifs_release_budget(c, &req);
766 return err;
767}
768
769static int ubifs_mknod(struct inode *dir, struct dentry *dentry,
Al Viro1a67aaf2011-07-26 01:52:52 -0400770 umode_t mode, dev_t rdev)
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300771{
772 struct inode *inode;
773 struct ubifs_inode *ui;
774 struct ubifs_inode *dir_ui = ubifs_inode(dir);
775 struct ubifs_info *c = dir->i_sb->s_fs_info;
776 union ubifs_dev_desc *dev = NULL;
777 int sz_change = CALC_DENT_SIZE(dentry->d_name.len);
778 int err, devlen = 0;
779 struct ubifs_budget_req req = { .new_ino = 1, .new_dent = 1,
Artem Bityutskiydab4b4d2008-07-24 14:52:45 +0300780 .new_ino_d = ALIGN(devlen, 8),
781 .dirtied_ino = 1 };
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300782
783 /*
784 * Budget request settings: new inode, new direntry and changing parent
785 * directory inode.
786 */
787
Al Viro4cb2a012013-09-16 10:58:53 -0400788 dbg_gen("dent '%pd' in dir ino %lu", dentry, dir->i_ino);
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300789
790 if (!new_valid_dev(rdev))
791 return -EINVAL;
792
793 if (S_ISBLK(mode) || S_ISCHR(mode)) {
794 dev = kmalloc(sizeof(union ubifs_dev_desc), GFP_NOFS);
795 if (!dev)
796 return -ENOMEM;
797 devlen = ubifs_encode_dev(dev, rdev);
798 }
799
800 err = ubifs_budget_space(c, &req);
801 if (err) {
802 kfree(dev);
803 return err;
804 }
805
806 inode = ubifs_new_inode(c, dir, mode);
807 if (IS_ERR(inode)) {
808 kfree(dev);
809 err = PTR_ERR(inode);
810 goto out_budg;
811 }
812
813 init_special_inode(inode, inode->i_mode, rdev);
814 inode->i_size = ubifs_inode(inode)->ui_size = devlen;
815 ui = ubifs_inode(inode);
816 ui->data = dev;
817 ui->data_len = devlen;
818
Subodh Nijsured7f0b702014-10-31 13:50:30 -0500819 err = ubifs_init_security(dir, inode, &dentry->d_name);
820 if (err)
Taesoo Kim9401a792015-03-25 09:53:37 +0100821 goto out_inode;
Subodh Nijsured7f0b702014-10-31 13:50:30 -0500822
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300823 mutex_lock(&dir_ui->ui_mutex);
824 dir->i_size += sz_change;
825 dir_ui->ui_size = dir->i_size;
826 dir->i_mtime = dir->i_ctime = inode->i_ctime;
827 err = ubifs_jnl_update(c, dir, &dentry->d_name, inode, 0, 0);
828 if (err)
829 goto out_cancel;
830 mutex_unlock(&dir_ui->ui_mutex);
831
832 ubifs_release_budget(c, &req);
833 insert_inode_hash(inode);
834 d_instantiate(dentry, inode);
835 return 0;
836
837out_cancel:
838 dir->i_size -= sz_change;
839 dir_ui->ui_size = dir->i_size;
840 mutex_unlock(&dir_ui->ui_mutex);
Taesoo Kim9401a792015-03-25 09:53:37 +0100841out_inode:
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300842 make_bad_inode(inode);
843 iput(inode);
844out_budg:
845 ubifs_release_budget(c, &req);
846 return err;
847}
848
849static int ubifs_symlink(struct inode *dir, struct dentry *dentry,
850 const char *symname)
851{
852 struct inode *inode;
853 struct ubifs_inode *ui;
854 struct ubifs_inode *dir_ui = ubifs_inode(dir);
855 struct ubifs_info *c = dir->i_sb->s_fs_info;
856 int err, len = strlen(symname);
857 int sz_change = CALC_DENT_SIZE(dentry->d_name.len);
858 struct ubifs_budget_req req = { .new_ino = 1, .new_dent = 1,
Artem Bityutskiydab4b4d2008-07-24 14:52:45 +0300859 .new_ino_d = ALIGN(len, 8),
860 .dirtied_ino = 1 };
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300861
862 /*
863 * Budget request settings: new inode, new direntry and changing parent
864 * directory inode.
865 */
866
Al Viro4cb2a012013-09-16 10:58:53 -0400867 dbg_gen("dent '%pd', target '%s' in dir ino %lu", dentry,
868 symname, dir->i_ino);
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300869
870 if (len > UBIFS_MAX_INO_DATA)
871 return -ENAMETOOLONG;
872
873 err = ubifs_budget_space(c, &req);
874 if (err)
875 return err;
876
877 inode = ubifs_new_inode(c, dir, S_IFLNK | S_IRWXUGO);
878 if (IS_ERR(inode)) {
879 err = PTR_ERR(inode);
880 goto out_budg;
881 }
882
883 ui = ubifs_inode(inode);
884 ui->data = kmalloc(len + 1, GFP_NOFS);
885 if (!ui->data) {
886 err = -ENOMEM;
887 goto out_inode;
888 }
889
890 memcpy(ui->data, symname, len);
891 ((char *)ui->data)[len] = '\0';
Al Viro0f301bd2015-05-02 10:35:42 -0400892 inode->i_link = ui->data;
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300893 /*
894 * The terminating zero byte is not written to the flash media and it
895 * is put just to make later in-memory string processing simpler. Thus,
896 * data length is @len, not @len + %1.
897 */
898 ui->data_len = len;
899 inode->i_size = ubifs_inode(inode)->ui_size = len;
900
Subodh Nijsured7f0b702014-10-31 13:50:30 -0500901 err = ubifs_init_security(dir, inode, &dentry->d_name);
902 if (err)
Taesoo Kim9401a792015-03-25 09:53:37 +0100903 goto out_inode;
Subodh Nijsured7f0b702014-10-31 13:50:30 -0500904
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300905 mutex_lock(&dir_ui->ui_mutex);
906 dir->i_size += sz_change;
907 dir_ui->ui_size = dir->i_size;
908 dir->i_mtime = dir->i_ctime = inode->i_ctime;
909 err = ubifs_jnl_update(c, dir, &dentry->d_name, inode, 0, 0);
910 if (err)
911 goto out_cancel;
912 mutex_unlock(&dir_ui->ui_mutex);
913
914 ubifs_release_budget(c, &req);
915 insert_inode_hash(inode);
916 d_instantiate(dentry, inode);
917 return 0;
918
919out_cancel:
920 dir->i_size -= sz_change;
921 dir_ui->ui_size = dir->i_size;
922 mutex_unlock(&dir_ui->ui_mutex);
923out_inode:
924 make_bad_inode(inode);
925 iput(inode);
926out_budg:
927 ubifs_release_budget(c, &req);
928 return err;
929}
930
931/**
Artem Bityutskiy82c15932009-01-20 16:46:02 +0200932 * lock_3_inodes - a wrapper for locking three UBIFS inodes.
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300933 * @inode1: first inode
934 * @inode2: second inode
935 * @inode3: third inode
936 *
Artem Bityutskiy82c15932009-01-20 16:46:02 +0200937 * This function is used for 'ubifs_rename()' and @inode1 may be the same as
938 * @inode2 whereas @inode3 may be %NULL.
939 *
940 * We do not implement any tricks to guarantee strict lock ordering, because
941 * VFS has already done it for us on the @i_mutex. So this is just a simple
942 * wrapper function.
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300943 */
944static void lock_3_inodes(struct inode *inode1, struct inode *inode2,
945 struct inode *inode3)
946{
Artem Bityutskiy82c15932009-01-20 16:46:02 +0200947 mutex_lock_nested(&ubifs_inode(inode1)->ui_mutex, WB_MUTEX_1);
948 if (inode2 != inode1)
949 mutex_lock_nested(&ubifs_inode(inode2)->ui_mutex, WB_MUTEX_2);
950 if (inode3)
951 mutex_lock_nested(&ubifs_inode(inode3)->ui_mutex, WB_MUTEX_3);
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300952}
953
954/**
Artem Bityutskiy82c15932009-01-20 16:46:02 +0200955 * unlock_3_inodes - a wrapper for unlocking three UBIFS inodes for rename.
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300956 * @inode1: first inode
957 * @inode2: second inode
958 * @inode3: third inode
959 */
960static void unlock_3_inodes(struct inode *inode1, struct inode *inode2,
961 struct inode *inode3)
962{
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300963 if (inode3)
964 mutex_unlock(&ubifs_inode(inode3)->ui_mutex);
Artem Bityutskiy82c15932009-01-20 16:46:02 +0200965 if (inode1 != inode2)
966 mutex_unlock(&ubifs_inode(inode2)->ui_mutex);
967 mutex_unlock(&ubifs_inode(inode1)->ui_mutex);
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300968}
969
970static int ubifs_rename(struct inode *old_dir, struct dentry *old_dentry,
971 struct inode *new_dir, struct dentry *new_dentry)
972{
973 struct ubifs_info *c = old_dir->i_sb->s_fs_info;
David Howells2b0143b2015-03-17 22:25:59 +0000974 struct inode *old_inode = d_inode(old_dentry);
975 struct inode *new_inode = d_inode(new_dentry);
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300976 struct ubifs_inode *old_inode_ui = ubifs_inode(old_inode);
977 int err, release, sync = 0, move = (new_dir != old_dir);
978 int is_dir = S_ISDIR(old_inode->i_mode);
979 int unlink = !!new_inode;
980 int new_sz = CALC_DENT_SIZE(new_dentry->d_name.len);
981 int old_sz = CALC_DENT_SIZE(old_dentry->d_name.len);
982 struct ubifs_budget_req req = { .new_dent = 1, .mod_dent = 1,
983 .dirtied_ino = 3 };
984 struct ubifs_budget_req ino_req = { .dirtied_ino = 1,
Artem Bityutskiydab4b4d2008-07-24 14:52:45 +0300985 .dirtied_ino_d = ALIGN(old_inode_ui->data_len, 8) };
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300986 struct timespec time;
Alexandre Pereira da Silva782759b2012-06-25 17:47:49 -0300987 unsigned int uninitialized_var(saved_nlink);
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300988
989 /*
990 * Budget request settings: deletion direntry, new direntry, removing
991 * the old inode, and changing old and new parent directory inodes.
992 *
993 * However, this operation also marks the target inode as dirty and
994 * does not write it, so we allocate budget for the target inode
995 * separately.
996 */
997
Al Viro4cb2a012013-09-16 10:58:53 -0400998 dbg_gen("dent '%pd' ino %lu in dir ino %lu to dent '%pd' in dir ino %lu",
999 old_dentry, old_inode->i_ino, old_dir->i_ino,
1000 new_dentry, new_dir->i_ino);
Artem Bityutskiy82c15932009-01-20 16:46:02 +02001001 ubifs_assert(mutex_is_locked(&old_dir->i_mutex));
1002 ubifs_assert(mutex_is_locked(&new_dir->i_mutex));
1003 if (unlink)
1004 ubifs_assert(mutex_is_locked(&new_inode->i_mutex));
1005
Artem Bityutskiy1e517642008-07-14 19:08:37 +03001006
1007 if (unlink && is_dir) {
1008 err = check_dir_empty(c, new_inode);
1009 if (err)
1010 return err;
1011 }
1012
1013 err = ubifs_budget_space(c, &req);
1014 if (err)
1015 return err;
1016 err = ubifs_budget_space(c, &ino_req);
1017 if (err) {
1018 ubifs_release_budget(c, &req);
1019 return err;
1020 }
1021
1022 lock_3_inodes(old_dir, new_dir, new_inode);
1023
1024 /*
1025 * Like most other Unix systems, set the @i_ctime for inodes on a
1026 * rename.
1027 */
1028 time = ubifs_current_time(old_dir);
1029 old_inode->i_ctime = time;
1030
1031 /* We must adjust parent link count when renaming directories */
1032 if (is_dir) {
1033 if (move) {
1034 /*
1035 * @old_dir loses a link because we are moving
1036 * @old_inode to a different directory.
1037 */
1038 drop_nlink(old_dir);
1039 /*
1040 * @new_dir only gains a link if we are not also
1041 * overwriting an existing directory.
1042 */
1043 if (!unlink)
1044 inc_nlink(new_dir);
1045 } else {
1046 /*
1047 * @old_inode is not moving to a different directory,
1048 * but @old_dir still loses a link if we are
1049 * overwriting an existing directory.
1050 */
1051 if (unlink)
1052 drop_nlink(old_dir);
1053 }
1054 }
1055
1056 old_dir->i_size -= old_sz;
1057 ubifs_inode(old_dir)->ui_size = old_dir->i_size;
1058 old_dir->i_mtime = old_dir->i_ctime = time;
1059 new_dir->i_mtime = new_dir->i_ctime = time;
1060
1061 /*
1062 * And finally, if we unlinked a direntry which happened to have the
1063 * same name as the moved direntry, we have to decrement @i_nlink of
1064 * the unlinked inode and change its ctime.
1065 */
1066 if (unlink) {
1067 /*
1068 * Directories cannot have hard-links, so if this is a
Artem Bityutskiyc43be102012-02-07 10:58:51 +02001069 * directory, just clear @i_nlink.
Artem Bityutskiy1e517642008-07-14 19:08:37 +03001070 */
Artem Bityutskiyc43be102012-02-07 10:58:51 +02001071 saved_nlink = new_inode->i_nlink;
Artem Bityutskiy1e517642008-07-14 19:08:37 +03001072 if (is_dir)
Artem Bityutskiyc43be102012-02-07 10:58:51 +02001073 clear_nlink(new_inode);
1074 else
Artem Bityutskiy1e517642008-07-14 19:08:37 +03001075 drop_nlink(new_inode);
1076 new_inode->i_ctime = time;
Artem Bityutskiy1e517642008-07-14 19:08:37 +03001077 } else {
1078 new_dir->i_size += new_sz;
1079 ubifs_inode(new_dir)->ui_size = new_dir->i_size;
1080 }
1081
1082 /*
1083 * Do not ask 'ubifs_jnl_rename()' to flush write-buffer if @old_inode
1084 * is dirty, because this will be done later on at the end of
1085 * 'ubifs_rename()'.
1086 */
1087 if (IS_SYNC(old_inode)) {
1088 sync = IS_DIRSYNC(old_dir) || IS_DIRSYNC(new_dir);
1089 if (unlink && IS_SYNC(new_inode))
1090 sync = 1;
1091 }
1092 err = ubifs_jnl_rename(c, old_dir, old_dentry, new_dir, new_dentry,
1093 sync);
1094 if (err)
1095 goto out_cancel;
1096
1097 unlock_3_inodes(old_dir, new_dir, new_inode);
1098 ubifs_release_budget(c, &req);
1099
1100 mutex_lock(&old_inode_ui->ui_mutex);
1101 release = old_inode_ui->dirty;
1102 mark_inode_dirty_sync(old_inode);
1103 mutex_unlock(&old_inode_ui->ui_mutex);
1104
1105 if (release)
1106 ubifs_release_budget(c, &ino_req);
1107 if (IS_SYNC(old_inode))
Christoph Hellwiga9185b42010-03-05 09:21:37 +01001108 err = old_inode->i_sb->s_op->write_inode(old_inode, NULL);
Artem Bityutskiy1e517642008-07-14 19:08:37 +03001109 return err;
1110
1111out_cancel:
1112 if (unlink) {
Artem Bityutskiyc43be102012-02-07 10:58:51 +02001113 set_nlink(new_inode, saved_nlink);
Artem Bityutskiy1e517642008-07-14 19:08:37 +03001114 } else {
1115 new_dir->i_size -= new_sz;
1116 ubifs_inode(new_dir)->ui_size = new_dir->i_size;
1117 }
1118 old_dir->i_size += old_sz;
1119 ubifs_inode(old_dir)->ui_size = old_dir->i_size;
1120 if (is_dir) {
1121 if (move) {
1122 inc_nlink(old_dir);
1123 if (!unlink)
1124 drop_nlink(new_dir);
1125 } else {
1126 if (unlink)
1127 inc_nlink(old_dir);
1128 }
1129 }
1130 unlock_3_inodes(old_dir, new_dir, new_inode);
1131 ubifs_release_budget(c, &ino_req);
1132 ubifs_release_budget(c, &req);
1133 return err;
1134}
1135
1136int ubifs_getattr(struct vfsmount *mnt, struct dentry *dentry,
1137 struct kstat *stat)
1138{
1139 loff_t size;
David Howells2b0143b2015-03-17 22:25:59 +00001140 struct inode *inode = d_inode(dentry);
Artem Bityutskiy1e517642008-07-14 19:08:37 +03001141 struct ubifs_inode *ui = ubifs_inode(inode);
1142
1143 mutex_lock(&ui->ui_mutex);
Al Viro6d42e7e2012-04-02 14:25:07 -04001144 generic_fillattr(inode, stat);
Artem Bityutskiy1e517642008-07-14 19:08:37 +03001145 stat->blksize = UBIFS_BLOCK_SIZE;
1146 stat->size = ui->ui_size;
1147
1148 /*
1149 * Unfortunately, the 'stat()' system call was designed for block
1150 * device based file systems, and it is not appropriate for UBIFS,
1151 * because UBIFS does not have notion of "block". For example, it is
1152 * difficult to tell how many block a directory takes - it actually
1153 * takes less than 300 bytes, but we have to round it to block size,
1154 * which introduces large mistake. This makes utilities like 'du' to
1155 * report completely senseless numbers. This is the reason why UBIFS
1156 * goes the same way as JFFS2 - it reports zero blocks for everything
1157 * but regular files, which makes more sense than reporting completely
1158 * wrong sizes.
1159 */
1160 if (S_ISREG(inode->i_mode)) {
1161 size = ui->xattr_size;
1162 size += stat->size;
1163 size = ALIGN(size, UBIFS_BLOCK_SIZE);
1164 /*
1165 * Note, user-space expects 512-byte blocks count irrespectively
1166 * of what was reported in @stat->size.
1167 */
1168 stat->blocks = size >> 9;
1169 } else
1170 stat->blocks = 0;
1171 mutex_unlock(&ui->ui_mutex);
1172 return 0;
1173}
1174
Artem Bityutskiye8b81562009-01-15 17:43:23 +02001175const struct inode_operations ubifs_dir_inode_operations = {
Artem Bityutskiy1e517642008-07-14 19:08:37 +03001176 .lookup = ubifs_lookup,
1177 .create = ubifs_create,
1178 .link = ubifs_link,
1179 .symlink = ubifs_symlink,
1180 .unlink = ubifs_unlink,
1181 .mkdir = ubifs_mkdir,
1182 .rmdir = ubifs_rmdir,
1183 .mknod = ubifs_mknod,
1184 .rename = ubifs_rename,
1185 .setattr = ubifs_setattr,
1186 .getattr = ubifs_getattr,
Artem Bityutskiy1e517642008-07-14 19:08:37 +03001187 .setxattr = ubifs_setxattr,
1188 .getxattr = ubifs_getxattr,
1189 .listxattr = ubifs_listxattr,
1190 .removexattr = ubifs_removexattr,
Artem Bityutskiy1e517642008-07-14 19:08:37 +03001191};
1192
Artem Bityutskiye8b81562009-01-15 17:43:23 +02001193const struct file_operations ubifs_dir_operations = {
Al Viro01122e02013-05-16 01:14:46 -04001194 .llseek = generic_file_llseek,
Artem Bityutskiy1e517642008-07-14 19:08:37 +03001195 .release = ubifs_dir_release,
1196 .read = generic_read_dir,
Al Viro01122e02013-05-16 01:14:46 -04001197 .iterate = ubifs_readdir,
Artem Bityutskiy1e517642008-07-14 19:08:37 +03001198 .fsync = ubifs_fsync,
1199 .unlocked_ioctl = ubifs_ioctl,
1200#ifdef CONFIG_COMPAT
1201 .compat_ioctl = ubifs_compat_ioctl,
1202#endif
1203};