blob: 4b86d3a738e1807c667fb6736f1deaa28a93d429 [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:
Richard Weinbergeraeeb14f2015-10-12 23:35:36 +0200452 kfree(file->private_data);
453 file->private_data = NULL;
454
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300455 if (err != -ENOENT) {
Sheng Yong235c3622015-03-20 10:39:42 +0000456 ubifs_err(c, "cannot find next direntry, error %d", err);
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300457 return err;
458 }
459
Artem Bityutskiy605c9122013-06-28 14:15:15 +0300460 /* 2 is a special value indicating that there are no more direntries */
Al Viro01122e02013-05-16 01:14:46 -0400461 ctx->pos = 2;
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300462 return 0;
463}
464
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300465/* Free saved readdir() state when the directory is closed */
466static int ubifs_dir_release(struct inode *dir, struct file *file)
467{
468 kfree(file->private_data);
469 file->private_data = NULL;
470 return 0;
471}
472
473/**
Artem Bityutskiy82c15932009-01-20 16:46:02 +0200474 * lock_2_inodes - a wrapper for locking two UBIFS inodes.
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300475 * @inode1: first inode
476 * @inode2: second inode
Artem Bityutskiy82c15932009-01-20 16:46:02 +0200477 *
478 * We do not implement any tricks to guarantee strict lock ordering, because
479 * VFS has already done it for us on the @i_mutex. So this is just a simple
480 * wrapper function.
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300481 */
482static void lock_2_inodes(struct inode *inode1, struct inode *inode2)
483{
Artem Bityutskiy82c15932009-01-20 16:46:02 +0200484 mutex_lock_nested(&ubifs_inode(inode1)->ui_mutex, WB_MUTEX_1);
485 mutex_lock_nested(&ubifs_inode(inode2)->ui_mutex, WB_MUTEX_2);
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300486}
487
488/**
Artem Bityutskiy82c15932009-01-20 16:46:02 +0200489 * unlock_2_inodes - a wrapper for unlocking two UBIFS inodes.
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300490 * @inode1: first inode
491 * @inode2: second inode
492 */
493static void unlock_2_inodes(struct inode *inode1, struct inode *inode2)
494{
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300495 mutex_unlock(&ubifs_inode(inode2)->ui_mutex);
Artem Bityutskiy82c15932009-01-20 16:46:02 +0200496 mutex_unlock(&ubifs_inode(inode1)->ui_mutex);
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300497}
498
499static int ubifs_link(struct dentry *old_dentry, struct inode *dir,
500 struct dentry *dentry)
501{
502 struct ubifs_info *c = dir->i_sb->s_fs_info;
David Howells2b0143b2015-03-17 22:25:59 +0000503 struct inode *inode = d_inode(old_dentry);
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300504 struct ubifs_inode *ui = ubifs_inode(inode);
505 struct ubifs_inode *dir_ui = ubifs_inode(dir);
506 int err, sz_change = CALC_DENT_SIZE(dentry->d_name.len);
507 struct ubifs_budget_req req = { .new_dent = 1, .dirtied_ino = 2,
Artem Bityutskiydab4b4d2008-07-24 14:52:45 +0300508 .dirtied_ino_d = ALIGN(ui->data_len, 8) };
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300509
510 /*
511 * Budget request settings: new direntry, changing the target inode,
512 * changing the parent inode.
513 */
514
Al Viro4cb2a012013-09-16 10:58:53 -0400515 dbg_gen("dent '%pd' to ino %lu (nlink %d) in dir ino %lu",
516 dentry, inode->i_ino,
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300517 inode->i_nlink, dir->i_ino);
Al Viro59551022016-01-22 15:40:57 -0500518 ubifs_assert(inode_is_locked(dir));
519 ubifs_assert(inode_is_locked(inode));
Hunter Adrian8b3884a2009-05-14 06:32:30 +0200520
Artem Bityutskiyd808efb2011-05-31 18:14:38 +0300521 err = dbg_check_synced_i_size(c, inode);
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300522 if (err)
523 return err;
524
525 err = ubifs_budget_space(c, &req);
526 if (err)
527 return err;
528
529 lock_2_inodes(dir, inode);
530 inc_nlink(inode);
Al Viro7de9c6ee2010-10-23 11:11:40 -0400531 ihold(inode);
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300532 inode->i_ctime = ubifs_current_time(inode);
533 dir->i_size += sz_change;
534 dir_ui->ui_size = dir->i_size;
535 dir->i_mtime = dir->i_ctime = inode->i_ctime;
536 err = ubifs_jnl_update(c, dir, &dentry->d_name, inode, 0, 0);
537 if (err)
538 goto out_cancel;
539 unlock_2_inodes(dir, inode);
540
541 ubifs_release_budget(c, &req);
542 d_instantiate(dentry, inode);
543 return 0;
544
545out_cancel:
546 dir->i_size -= sz_change;
547 dir_ui->ui_size = dir->i_size;
548 drop_nlink(inode);
549 unlock_2_inodes(dir, inode);
550 ubifs_release_budget(c, &req);
551 iput(inode);
552 return err;
553}
554
555static int ubifs_unlink(struct inode *dir, struct dentry *dentry)
556{
557 struct ubifs_info *c = dir->i_sb->s_fs_info;
David Howells2b0143b2015-03-17 22:25:59 +0000558 struct inode *inode = d_inode(dentry);
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300559 struct ubifs_inode *dir_ui = ubifs_inode(dir);
560 int sz_change = CALC_DENT_SIZE(dentry->d_name.len);
561 int err, budgeted = 1;
562 struct ubifs_budget_req req = { .mod_dent = 1, .dirtied_ino = 2 };
Artem Bityutskiyc43be102012-02-07 10:58:51 +0200563 unsigned int saved_nlink = inode->i_nlink;
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300564
565 /*
566 * Budget request settings: deletion direntry, deletion inode (+1 for
567 * @dirtied_ino), changing the parent directory inode. If budgeting
568 * fails, go ahead anyway because we have extra space reserved for
569 * deletions.
570 */
571
Al Viro4cb2a012013-09-16 10:58:53 -0400572 dbg_gen("dent '%pd' from ino %lu (nlink %d) in dir ino %lu",
573 dentry, inode->i_ino,
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300574 inode->i_nlink, dir->i_ino);
Al Viro59551022016-01-22 15:40:57 -0500575 ubifs_assert(inode_is_locked(dir));
576 ubifs_assert(inode_is_locked(inode));
Artem Bityutskiyd808efb2011-05-31 18:14:38 +0300577 err = dbg_check_synced_i_size(c, inode);
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300578 if (err)
579 return err;
580
581 err = ubifs_budget_space(c, &req);
582 if (err) {
583 if (err != -ENOSPC)
584 return err;
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300585 budgeted = 0;
586 }
587
588 lock_2_inodes(dir, inode);
589 inode->i_ctime = ubifs_current_time(dir);
590 drop_nlink(inode);
591 dir->i_size -= sz_change;
592 dir_ui->ui_size = dir->i_size;
593 dir->i_mtime = dir->i_ctime = inode->i_ctime;
594 err = ubifs_jnl_update(c, dir, &dentry->d_name, inode, 1, 0);
595 if (err)
596 goto out_cancel;
597 unlock_2_inodes(dir, inode);
598
599 if (budgeted)
600 ubifs_release_budget(c, &req);
601 else {
602 /* We've deleted something - clean the "no space" flags */
Artem Bityutskiyb1375452011-03-29 18:04:05 +0300603 c->bi.nospace = c->bi.nospace_rp = 0;
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300604 smp_wmb();
605 }
606 return 0;
607
608out_cancel:
609 dir->i_size += sz_change;
610 dir_ui->ui_size = dir->i_size;
Artem Bityutskiyc43be102012-02-07 10:58:51 +0200611 set_nlink(inode, saved_nlink);
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300612 unlock_2_inodes(dir, inode);
613 if (budgeted)
614 ubifs_release_budget(c, &req);
615 return err;
616}
617
618/**
619 * check_dir_empty - check if a directory is empty or not.
620 * @c: UBIFS file-system description object
621 * @dir: VFS inode object of the directory to check
622 *
623 * This function checks if directory @dir is empty. Returns zero if the
624 * directory is empty, %-ENOTEMPTY if it is not, and other negative error codes
625 * in case of of errors.
626 */
627static int check_dir_empty(struct ubifs_info *c, struct inode *dir)
628{
629 struct qstr nm = { .name = NULL };
630 struct ubifs_dent_node *dent;
631 union ubifs_key key;
632 int err;
633
634 lowest_dent_key(c, &key, dir->i_ino);
635 dent = ubifs_tnc_next_ent(c, &key, &nm);
636 if (IS_ERR(dent)) {
637 err = PTR_ERR(dent);
638 if (err == -ENOENT)
639 err = 0;
640 } else {
641 kfree(dent);
642 err = -ENOTEMPTY;
643 }
644 return err;
645}
646
647static int ubifs_rmdir(struct inode *dir, struct dentry *dentry)
648{
649 struct ubifs_info *c = dir->i_sb->s_fs_info;
David Howells2b0143b2015-03-17 22:25:59 +0000650 struct inode *inode = d_inode(dentry);
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300651 int sz_change = CALC_DENT_SIZE(dentry->d_name.len);
652 int err, budgeted = 1;
653 struct ubifs_inode *dir_ui = ubifs_inode(dir);
654 struct ubifs_budget_req req = { .mod_dent = 1, .dirtied_ino = 2 };
655
656 /*
657 * Budget request settings: deletion direntry, deletion inode and
658 * changing the parent inode. If budgeting fails, go ahead anyway
659 * because we have extra space reserved for deletions.
660 */
661
Al Viro4cb2a012013-09-16 10:58:53 -0400662 dbg_gen("directory '%pd', ino %lu in dir ino %lu", dentry,
663 inode->i_ino, dir->i_ino);
Al Viro59551022016-01-22 15:40:57 -0500664 ubifs_assert(inode_is_locked(dir));
665 ubifs_assert(inode_is_locked(inode));
David Howells2b0143b2015-03-17 22:25:59 +0000666 err = check_dir_empty(c, d_inode(dentry));
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300667 if (err)
668 return err;
669
670 err = ubifs_budget_space(c, &req);
671 if (err) {
672 if (err != -ENOSPC)
673 return err;
674 budgeted = 0;
675 }
676
677 lock_2_inodes(dir, inode);
678 inode->i_ctime = ubifs_current_time(dir);
679 clear_nlink(inode);
680 drop_nlink(dir);
681 dir->i_size -= sz_change;
682 dir_ui->ui_size = dir->i_size;
683 dir->i_mtime = dir->i_ctime = inode->i_ctime;
684 err = ubifs_jnl_update(c, dir, &dentry->d_name, inode, 1, 0);
685 if (err)
686 goto out_cancel;
687 unlock_2_inodes(dir, inode);
688
689 if (budgeted)
690 ubifs_release_budget(c, &req);
691 else {
692 /* We've deleted something - clean the "no space" flags */
Artem Bityutskiyb1375452011-03-29 18:04:05 +0300693 c->bi.nospace = c->bi.nospace_rp = 0;
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300694 smp_wmb();
695 }
696 return 0;
697
698out_cancel:
699 dir->i_size += sz_change;
700 dir_ui->ui_size = dir->i_size;
701 inc_nlink(dir);
Artem Bityutskiyc43be102012-02-07 10:58:51 +0200702 set_nlink(inode, 2);
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300703 unlock_2_inodes(dir, inode);
704 if (budgeted)
705 ubifs_release_budget(c, &req);
706 return err;
707}
708
Al Viro18bb1db2011-07-26 01:41:39 -0400709static int ubifs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300710{
711 struct inode *inode;
712 struct ubifs_inode *dir_ui = ubifs_inode(dir);
713 struct ubifs_info *c = dir->i_sb->s_fs_info;
714 int err, sz_change = CALC_DENT_SIZE(dentry->d_name.len);
Artem Bityutskiy182854b2008-07-18 18:54:29 +0300715 struct ubifs_budget_req req = { .new_ino = 1, .new_dent = 1 };
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300716
717 /*
718 * Budget request settings: new inode, new direntry and changing parent
719 * directory inode.
720 */
721
Al Viro4cb2a012013-09-16 10:58:53 -0400722 dbg_gen("dent '%pd', mode %#hx in dir ino %lu",
723 dentry, mode, dir->i_ino);
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300724
725 err = ubifs_budget_space(c, &req);
726 if (err)
727 return err;
728
729 inode = ubifs_new_inode(c, dir, S_IFDIR | mode);
730 if (IS_ERR(inode)) {
731 err = PTR_ERR(inode);
732 goto out_budg;
733 }
734
Subodh Nijsured7f0b702014-10-31 13:50:30 -0500735 err = ubifs_init_security(dir, inode, &dentry->d_name);
736 if (err)
Taesoo Kim9401a792015-03-25 09:53:37 +0100737 goto out_inode;
Subodh Nijsured7f0b702014-10-31 13:50:30 -0500738
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300739 mutex_lock(&dir_ui->ui_mutex);
740 insert_inode_hash(inode);
741 inc_nlink(inode);
742 inc_nlink(dir);
743 dir->i_size += sz_change;
744 dir_ui->ui_size = dir->i_size;
745 dir->i_mtime = dir->i_ctime = inode->i_ctime;
746 err = ubifs_jnl_update(c, dir, &dentry->d_name, inode, 0, 0);
747 if (err) {
Sheng Yong235c3622015-03-20 10:39:42 +0000748 ubifs_err(c, "cannot create directory, error %d", err);
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300749 goto out_cancel;
750 }
751 mutex_unlock(&dir_ui->ui_mutex);
752
753 ubifs_release_budget(c, &req);
754 d_instantiate(dentry, inode);
755 return 0;
756
757out_cancel:
758 dir->i_size -= sz_change;
759 dir_ui->ui_size = dir->i_size;
760 drop_nlink(dir);
761 mutex_unlock(&dir_ui->ui_mutex);
Taesoo Kim9401a792015-03-25 09:53:37 +0100762out_inode:
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300763 make_bad_inode(inode);
764 iput(inode);
765out_budg:
766 ubifs_release_budget(c, &req);
767 return err;
768}
769
770static int ubifs_mknod(struct inode *dir, struct dentry *dentry,
Al Viro1a67aaf2011-07-26 01:52:52 -0400771 umode_t mode, dev_t rdev)
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300772{
773 struct inode *inode;
774 struct ubifs_inode *ui;
775 struct ubifs_inode *dir_ui = ubifs_inode(dir);
776 struct ubifs_info *c = dir->i_sb->s_fs_info;
777 union ubifs_dev_desc *dev = NULL;
778 int sz_change = CALC_DENT_SIZE(dentry->d_name.len);
779 int err, devlen = 0;
780 struct ubifs_budget_req req = { .new_ino = 1, .new_dent = 1,
Artem Bityutskiydab4b4d2008-07-24 14:52:45 +0300781 .new_ino_d = ALIGN(devlen, 8),
782 .dirtied_ino = 1 };
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300783
784 /*
785 * Budget request settings: new inode, new direntry and changing parent
786 * directory inode.
787 */
788
Al Viro4cb2a012013-09-16 10:58:53 -0400789 dbg_gen("dent '%pd' in dir ino %lu", dentry, dir->i_ino);
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300790
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300791 if (S_ISBLK(mode) || S_ISCHR(mode)) {
792 dev = kmalloc(sizeof(union ubifs_dev_desc), GFP_NOFS);
793 if (!dev)
794 return -ENOMEM;
795 devlen = ubifs_encode_dev(dev, rdev);
796 }
797
798 err = ubifs_budget_space(c, &req);
799 if (err) {
800 kfree(dev);
801 return err;
802 }
803
804 inode = ubifs_new_inode(c, dir, mode);
805 if (IS_ERR(inode)) {
806 kfree(dev);
807 err = PTR_ERR(inode);
808 goto out_budg;
809 }
810
811 init_special_inode(inode, inode->i_mode, rdev);
812 inode->i_size = ubifs_inode(inode)->ui_size = devlen;
813 ui = ubifs_inode(inode);
814 ui->data = dev;
815 ui->data_len = devlen;
816
Subodh Nijsured7f0b702014-10-31 13:50:30 -0500817 err = ubifs_init_security(dir, inode, &dentry->d_name);
818 if (err)
Taesoo Kim9401a792015-03-25 09:53:37 +0100819 goto out_inode;
Subodh Nijsured7f0b702014-10-31 13:50:30 -0500820
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300821 mutex_lock(&dir_ui->ui_mutex);
822 dir->i_size += sz_change;
823 dir_ui->ui_size = dir->i_size;
824 dir->i_mtime = dir->i_ctime = inode->i_ctime;
825 err = ubifs_jnl_update(c, dir, &dentry->d_name, inode, 0, 0);
826 if (err)
827 goto out_cancel;
828 mutex_unlock(&dir_ui->ui_mutex);
829
830 ubifs_release_budget(c, &req);
831 insert_inode_hash(inode);
832 d_instantiate(dentry, inode);
833 return 0;
834
835out_cancel:
836 dir->i_size -= sz_change;
837 dir_ui->ui_size = dir->i_size;
838 mutex_unlock(&dir_ui->ui_mutex);
Taesoo Kim9401a792015-03-25 09:53:37 +0100839out_inode:
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300840 make_bad_inode(inode);
841 iput(inode);
842out_budg:
843 ubifs_release_budget(c, &req);
844 return err;
845}
846
847static int ubifs_symlink(struct inode *dir, struct dentry *dentry,
848 const char *symname)
849{
850 struct inode *inode;
851 struct ubifs_inode *ui;
852 struct ubifs_inode *dir_ui = ubifs_inode(dir);
853 struct ubifs_info *c = dir->i_sb->s_fs_info;
854 int err, len = strlen(symname);
855 int sz_change = CALC_DENT_SIZE(dentry->d_name.len);
856 struct ubifs_budget_req req = { .new_ino = 1, .new_dent = 1,
Artem Bityutskiydab4b4d2008-07-24 14:52:45 +0300857 .new_ino_d = ALIGN(len, 8),
858 .dirtied_ino = 1 };
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300859
860 /*
861 * Budget request settings: new inode, new direntry and changing parent
862 * directory inode.
863 */
864
Al Viro4cb2a012013-09-16 10:58:53 -0400865 dbg_gen("dent '%pd', target '%s' in dir ino %lu", dentry,
866 symname, dir->i_ino);
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300867
868 if (len > UBIFS_MAX_INO_DATA)
869 return -ENAMETOOLONG;
870
871 err = ubifs_budget_space(c, &req);
872 if (err)
873 return err;
874
875 inode = ubifs_new_inode(c, dir, S_IFLNK | S_IRWXUGO);
876 if (IS_ERR(inode)) {
877 err = PTR_ERR(inode);
878 goto out_budg;
879 }
880
881 ui = ubifs_inode(inode);
882 ui->data = kmalloc(len + 1, GFP_NOFS);
883 if (!ui->data) {
884 err = -ENOMEM;
885 goto out_inode;
886 }
887
888 memcpy(ui->data, symname, len);
889 ((char *)ui->data)[len] = '\0';
Al Viro0f301bd2015-05-02 10:35:42 -0400890 inode->i_link = ui->data;
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300891 /*
892 * The terminating zero byte is not written to the flash media and it
893 * is put just to make later in-memory string processing simpler. Thus,
894 * data length is @len, not @len + %1.
895 */
896 ui->data_len = len;
897 inode->i_size = ubifs_inode(inode)->ui_size = len;
898
Subodh Nijsured7f0b702014-10-31 13:50:30 -0500899 err = ubifs_init_security(dir, inode, &dentry->d_name);
900 if (err)
Taesoo Kim9401a792015-03-25 09:53:37 +0100901 goto out_inode;
Subodh Nijsured7f0b702014-10-31 13:50:30 -0500902
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300903 mutex_lock(&dir_ui->ui_mutex);
904 dir->i_size += sz_change;
905 dir_ui->ui_size = dir->i_size;
906 dir->i_mtime = dir->i_ctime = inode->i_ctime;
907 err = ubifs_jnl_update(c, dir, &dentry->d_name, inode, 0, 0);
908 if (err)
909 goto out_cancel;
910 mutex_unlock(&dir_ui->ui_mutex);
911
912 ubifs_release_budget(c, &req);
913 insert_inode_hash(inode);
914 d_instantiate(dentry, inode);
915 return 0;
916
917out_cancel:
918 dir->i_size -= sz_change;
919 dir_ui->ui_size = dir->i_size;
920 mutex_unlock(&dir_ui->ui_mutex);
921out_inode:
922 make_bad_inode(inode);
923 iput(inode);
924out_budg:
925 ubifs_release_budget(c, &req);
926 return err;
927}
928
929/**
Artem Bityutskiy82c15932009-01-20 16:46:02 +0200930 * lock_3_inodes - a wrapper for locking three UBIFS inodes.
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300931 * @inode1: first inode
932 * @inode2: second inode
933 * @inode3: third inode
934 *
Artem Bityutskiy82c15932009-01-20 16:46:02 +0200935 * This function is used for 'ubifs_rename()' and @inode1 may be the same as
936 * @inode2 whereas @inode3 may be %NULL.
937 *
938 * We do not implement any tricks to guarantee strict lock ordering, because
939 * VFS has already done it for us on the @i_mutex. So this is just a simple
940 * wrapper function.
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300941 */
942static void lock_3_inodes(struct inode *inode1, struct inode *inode2,
943 struct inode *inode3)
944{
Artem Bityutskiy82c15932009-01-20 16:46:02 +0200945 mutex_lock_nested(&ubifs_inode(inode1)->ui_mutex, WB_MUTEX_1);
946 if (inode2 != inode1)
947 mutex_lock_nested(&ubifs_inode(inode2)->ui_mutex, WB_MUTEX_2);
948 if (inode3)
949 mutex_lock_nested(&ubifs_inode(inode3)->ui_mutex, WB_MUTEX_3);
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300950}
951
952/**
Artem Bityutskiy82c15932009-01-20 16:46:02 +0200953 * unlock_3_inodes - a wrapper for unlocking three UBIFS inodes for rename.
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300954 * @inode1: first inode
955 * @inode2: second inode
956 * @inode3: third inode
957 */
958static void unlock_3_inodes(struct inode *inode1, struct inode *inode2,
959 struct inode *inode3)
960{
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300961 if (inode3)
962 mutex_unlock(&ubifs_inode(inode3)->ui_mutex);
Artem Bityutskiy82c15932009-01-20 16:46:02 +0200963 if (inode1 != inode2)
964 mutex_unlock(&ubifs_inode(inode2)->ui_mutex);
965 mutex_unlock(&ubifs_inode(inode1)->ui_mutex);
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300966}
967
968static int ubifs_rename(struct inode *old_dir, struct dentry *old_dentry,
969 struct inode *new_dir, struct dentry *new_dentry)
970{
971 struct ubifs_info *c = old_dir->i_sb->s_fs_info;
David Howells2b0143b2015-03-17 22:25:59 +0000972 struct inode *old_inode = d_inode(old_dentry);
973 struct inode *new_inode = d_inode(new_dentry);
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300974 struct ubifs_inode *old_inode_ui = ubifs_inode(old_inode);
975 int err, release, sync = 0, move = (new_dir != old_dir);
976 int is_dir = S_ISDIR(old_inode->i_mode);
977 int unlink = !!new_inode;
978 int new_sz = CALC_DENT_SIZE(new_dentry->d_name.len);
979 int old_sz = CALC_DENT_SIZE(old_dentry->d_name.len);
980 struct ubifs_budget_req req = { .new_dent = 1, .mod_dent = 1,
981 .dirtied_ino = 3 };
982 struct ubifs_budget_req ino_req = { .dirtied_ino = 1,
Artem Bityutskiydab4b4d2008-07-24 14:52:45 +0300983 .dirtied_ino_d = ALIGN(old_inode_ui->data_len, 8) };
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300984 struct timespec time;
Alexandre Pereira da Silva782759b2012-06-25 17:47:49 -0300985 unsigned int uninitialized_var(saved_nlink);
Artem Bityutskiy1e517642008-07-14 19:08:37 +0300986
987 /*
988 * Budget request settings: deletion direntry, new direntry, removing
989 * the old inode, and changing old and new parent directory inodes.
990 *
991 * However, this operation also marks the target inode as dirty and
992 * does not write it, so we allocate budget for the target inode
993 * separately.
994 */
995
Al Viro4cb2a012013-09-16 10:58:53 -0400996 dbg_gen("dent '%pd' ino %lu in dir ino %lu to dent '%pd' in dir ino %lu",
997 old_dentry, old_inode->i_ino, old_dir->i_ino,
998 new_dentry, new_dir->i_ino);
Al Viro59551022016-01-22 15:40:57 -0500999 ubifs_assert(inode_is_locked(old_dir));
1000 ubifs_assert(inode_is_locked(new_dir));
Artem Bityutskiy82c15932009-01-20 16:46:02 +02001001 if (unlink)
Al Viro59551022016-01-22 15:40:57 -05001002 ubifs_assert(inode_is_locked(new_inode));
Artem Bityutskiy82c15932009-01-20 16:46:02 +02001003
Artem Bityutskiy1e517642008-07-14 19:08:37 +03001004
1005 if (unlink && is_dir) {
1006 err = check_dir_empty(c, new_inode);
1007 if (err)
1008 return err;
1009 }
1010
1011 err = ubifs_budget_space(c, &req);
1012 if (err)
1013 return err;
1014 err = ubifs_budget_space(c, &ino_req);
1015 if (err) {
1016 ubifs_release_budget(c, &req);
1017 return err;
1018 }
1019
1020 lock_3_inodes(old_dir, new_dir, new_inode);
1021
1022 /*
1023 * Like most other Unix systems, set the @i_ctime for inodes on a
1024 * rename.
1025 */
1026 time = ubifs_current_time(old_dir);
1027 old_inode->i_ctime = time;
1028
1029 /* We must adjust parent link count when renaming directories */
1030 if (is_dir) {
1031 if (move) {
1032 /*
1033 * @old_dir loses a link because we are moving
1034 * @old_inode to a different directory.
1035 */
1036 drop_nlink(old_dir);
1037 /*
1038 * @new_dir only gains a link if we are not also
1039 * overwriting an existing directory.
1040 */
1041 if (!unlink)
1042 inc_nlink(new_dir);
1043 } else {
1044 /*
1045 * @old_inode is not moving to a different directory,
1046 * but @old_dir still loses a link if we are
1047 * overwriting an existing directory.
1048 */
1049 if (unlink)
1050 drop_nlink(old_dir);
1051 }
1052 }
1053
1054 old_dir->i_size -= old_sz;
1055 ubifs_inode(old_dir)->ui_size = old_dir->i_size;
1056 old_dir->i_mtime = old_dir->i_ctime = time;
1057 new_dir->i_mtime = new_dir->i_ctime = time;
1058
1059 /*
1060 * And finally, if we unlinked a direntry which happened to have the
1061 * same name as the moved direntry, we have to decrement @i_nlink of
1062 * the unlinked inode and change its ctime.
1063 */
1064 if (unlink) {
1065 /*
1066 * Directories cannot have hard-links, so if this is a
Artem Bityutskiyc43be102012-02-07 10:58:51 +02001067 * directory, just clear @i_nlink.
Artem Bityutskiy1e517642008-07-14 19:08:37 +03001068 */
Artem Bityutskiyc43be102012-02-07 10:58:51 +02001069 saved_nlink = new_inode->i_nlink;
Artem Bityutskiy1e517642008-07-14 19:08:37 +03001070 if (is_dir)
Artem Bityutskiyc43be102012-02-07 10:58:51 +02001071 clear_nlink(new_inode);
1072 else
Artem Bityutskiy1e517642008-07-14 19:08:37 +03001073 drop_nlink(new_inode);
1074 new_inode->i_ctime = time;
Artem Bityutskiy1e517642008-07-14 19:08:37 +03001075 } else {
1076 new_dir->i_size += new_sz;
1077 ubifs_inode(new_dir)->ui_size = new_dir->i_size;
1078 }
1079
1080 /*
1081 * Do not ask 'ubifs_jnl_rename()' to flush write-buffer if @old_inode
1082 * is dirty, because this will be done later on at the end of
1083 * 'ubifs_rename()'.
1084 */
1085 if (IS_SYNC(old_inode)) {
1086 sync = IS_DIRSYNC(old_dir) || IS_DIRSYNC(new_dir);
1087 if (unlink && IS_SYNC(new_inode))
1088 sync = 1;
1089 }
1090 err = ubifs_jnl_rename(c, old_dir, old_dentry, new_dir, new_dentry,
1091 sync);
1092 if (err)
1093 goto out_cancel;
1094
1095 unlock_3_inodes(old_dir, new_dir, new_inode);
1096 ubifs_release_budget(c, &req);
1097
1098 mutex_lock(&old_inode_ui->ui_mutex);
1099 release = old_inode_ui->dirty;
1100 mark_inode_dirty_sync(old_inode);
1101 mutex_unlock(&old_inode_ui->ui_mutex);
1102
1103 if (release)
1104 ubifs_release_budget(c, &ino_req);
1105 if (IS_SYNC(old_inode))
Christoph Hellwiga9185b42010-03-05 09:21:37 +01001106 err = old_inode->i_sb->s_op->write_inode(old_inode, NULL);
Artem Bityutskiy1e517642008-07-14 19:08:37 +03001107 return err;
1108
1109out_cancel:
1110 if (unlink) {
Artem Bityutskiyc43be102012-02-07 10:58:51 +02001111 set_nlink(new_inode, saved_nlink);
Artem Bityutskiy1e517642008-07-14 19:08:37 +03001112 } else {
1113 new_dir->i_size -= new_sz;
1114 ubifs_inode(new_dir)->ui_size = new_dir->i_size;
1115 }
1116 old_dir->i_size += old_sz;
1117 ubifs_inode(old_dir)->ui_size = old_dir->i_size;
1118 if (is_dir) {
1119 if (move) {
1120 inc_nlink(old_dir);
1121 if (!unlink)
1122 drop_nlink(new_dir);
1123 } else {
1124 if (unlink)
1125 inc_nlink(old_dir);
1126 }
1127 }
1128 unlock_3_inodes(old_dir, new_dir, new_inode);
1129 ubifs_release_budget(c, &ino_req);
1130 ubifs_release_budget(c, &req);
1131 return err;
1132}
1133
1134int ubifs_getattr(struct vfsmount *mnt, struct dentry *dentry,
1135 struct kstat *stat)
1136{
1137 loff_t size;
David Howells2b0143b2015-03-17 22:25:59 +00001138 struct inode *inode = d_inode(dentry);
Artem Bityutskiy1e517642008-07-14 19:08:37 +03001139 struct ubifs_inode *ui = ubifs_inode(inode);
1140
1141 mutex_lock(&ui->ui_mutex);
Al Viro6d42e7e2012-04-02 14:25:07 -04001142 generic_fillattr(inode, stat);
Artem Bityutskiy1e517642008-07-14 19:08:37 +03001143 stat->blksize = UBIFS_BLOCK_SIZE;
1144 stat->size = ui->ui_size;
1145
1146 /*
1147 * Unfortunately, the 'stat()' system call was designed for block
1148 * device based file systems, and it is not appropriate for UBIFS,
1149 * because UBIFS does not have notion of "block". For example, it is
1150 * difficult to tell how many block a directory takes - it actually
1151 * takes less than 300 bytes, but we have to round it to block size,
1152 * which introduces large mistake. This makes utilities like 'du' to
1153 * report completely senseless numbers. This is the reason why UBIFS
1154 * goes the same way as JFFS2 - it reports zero blocks for everything
1155 * but regular files, which makes more sense than reporting completely
1156 * wrong sizes.
1157 */
1158 if (S_ISREG(inode->i_mode)) {
1159 size = ui->xattr_size;
1160 size += stat->size;
1161 size = ALIGN(size, UBIFS_BLOCK_SIZE);
1162 /*
1163 * Note, user-space expects 512-byte blocks count irrespectively
1164 * of what was reported in @stat->size.
1165 */
1166 stat->blocks = size >> 9;
1167 } else
1168 stat->blocks = 0;
1169 mutex_unlock(&ui->ui_mutex);
1170 return 0;
1171}
1172
Artem Bityutskiye8b81562009-01-15 17:43:23 +02001173const struct inode_operations ubifs_dir_inode_operations = {
Artem Bityutskiy1e517642008-07-14 19:08:37 +03001174 .lookup = ubifs_lookup,
1175 .create = ubifs_create,
1176 .link = ubifs_link,
1177 .symlink = ubifs_symlink,
1178 .unlink = ubifs_unlink,
1179 .mkdir = ubifs_mkdir,
1180 .rmdir = ubifs_rmdir,
1181 .mknod = ubifs_mknod,
1182 .rename = ubifs_rename,
1183 .setattr = ubifs_setattr,
1184 .getattr = ubifs_getattr,
Andreas Gruenbacher2b88fc22016-04-22 19:14:00 +02001185 .setxattr = generic_setxattr,
1186 .getxattr = generic_getxattr,
Artem Bityutskiy1e517642008-07-14 19:08:37 +03001187 .listxattr = ubifs_listxattr,
Andreas Gruenbacher2b88fc22016-04-22 19:14:00 +02001188 .removexattr = generic_removexattr,
Dongsheng Yang8c1c5f22015-11-07 12:46:11 +08001189#ifdef CONFIG_UBIFS_ATIME_SUPPORT
1190 .update_time = ubifs_update_time,
1191#endif
Artem Bityutskiy1e517642008-07-14 19:08:37 +03001192};
1193
Artem Bityutskiye8b81562009-01-15 17:43:23 +02001194const struct file_operations ubifs_dir_operations = {
Al Viro01122e02013-05-16 01:14:46 -04001195 .llseek = generic_file_llseek,
Artem Bityutskiy1e517642008-07-14 19:08:37 +03001196 .release = ubifs_dir_release,
1197 .read = generic_read_dir,
Al Viroc51da202016-04-30 22:37:34 -04001198 .iterate_shared = ubifs_readdir,
Artem Bityutskiy1e517642008-07-14 19:08:37 +03001199 .fsync = ubifs_fsync,
1200 .unlocked_ioctl = ubifs_ioctl,
1201#ifdef CONFIG_COMPAT
1202 .compat_ioctl = ubifs_compat_ioctl,
1203#endif
1204};