1// SPDX-License-Identifier: GPL-2.0
  2/*
  3 * (C) 2001 Clemson University and The University of Chicago
  4 *
  5 * See COPYING in top-level directory.
  6 */
  7
  8/*
  9 *  Linux VFS inode operations.
 10 */
 11
 12#include <linux/bvec.h>
 13#include "protocol.h"
 14#include "orangefs-kernel.h"
 15#include "orangefs-bufmap.h"
 16
 17static int read_one_page(struct page *page)
 18{
 19	int ret;
 20	int max_block;
 21	ssize_t bytes_read = 0;
 22	struct inode *inode = page->mapping->host;
 23	const __u32 blocksize = PAGE_SIZE;	/* inode->i_blksize */
 24	const __u32 blockbits = PAGE_SHIFT;	/* inode->i_blkbits */
 25	struct iov_iter to;
 26	struct bio_vec bv = {.bv_page = page, .bv_len = PAGE_SIZE};
 27
 28	iov_iter_bvec(&to, ITER_BVEC | READ, &bv, 1, PAGE_SIZE);
 29
 30	gossip_debug(GOSSIP_INODE_DEBUG,
 31		    "orangefs_readpage called with page %p\n",
 32		     page);
 33
 34	max_block = ((inode->i_size / blocksize) + 1);
 35
 36	if (page->index < max_block) {
 37		loff_t blockptr_offset = (((loff_t) page->index) << blockbits);
 38
 39		bytes_read = orangefs_inode_read(inode,
 40						 &to,
 41						 &blockptr_offset,
 42						 inode->i_size);
 43	}
 44	/* this will only zero remaining unread portions of the page data */
 45	iov_iter_zero(~0U, &to);
 46	/* takes care of potential aliasing */
 47	flush_dcache_page(page);
 48	if (bytes_read < 0) {
 49		ret = bytes_read;
 50		SetPageError(page);
 51	} else {
 52		SetPageUptodate(page);
 53		if (PageError(page))
 54			ClearPageError(page);
 55		ret = 0;
 56	}
 57	/* unlock the page after the ->readpage() routine completes */
 58	unlock_page(page);
 59	return ret;
 60}
 61
 62static int orangefs_readpage(struct file *file, struct page *page)
 63{
 64	return read_one_page(page);
 65}
 66
 67static int orangefs_readpages(struct file *file,
 68			   struct address_space *mapping,
 69			   struct list_head *pages,
 70			   unsigned nr_pages)
 71{
 72	int page_idx;
 73	int ret;
 74
 75	gossip_debug(GOSSIP_INODE_DEBUG, "orangefs_readpages called\n");
 76
 77	for (page_idx = 0; page_idx < nr_pages; page_idx++) {
 78		struct page *page;
 79
 80		page = list_entry(pages->prev, struct page, lru);
 81		list_del(&page->lru);
 82		if (!add_to_page_cache(page,
 83				       mapping,
 84				       page->index,
 85				       readahead_gfp_mask(mapping))) {
 86			ret = read_one_page(page);
 87			gossip_debug(GOSSIP_INODE_DEBUG,
 88				"failure adding page to cache, read_one_page returned: %d\n",
 89				ret);
 90	      } else {
 91			put_page(page);
 92	      }
 93	}
 94	BUG_ON(!list_empty(pages));
 95	return 0;
 96}
 97
 98static void orangefs_invalidatepage(struct page *page,
 99				 unsigned int offset,
100				 unsigned int length)
101{
102	gossip_debug(GOSSIP_INODE_DEBUG,
103		     "orangefs_invalidatepage called on page %p "
104		     "(offset is %u)\n",
105		     page,
106		     offset);
107
108	ClearPageUptodate(page);
109	ClearPageMappedToDisk(page);
110	return;
111
112}
113
114static int orangefs_releasepage(struct page *page, gfp_t foo)
115{
116	gossip_debug(GOSSIP_INODE_DEBUG,
117		     "orangefs_releasepage called on page %p\n",
118		     page);
119	return 0;
120}
121
122/*
123 * Having a direct_IO entry point in the address_space_operations
124 * struct causes the kernel to allows us to use O_DIRECT on
125 * open. Nothing will ever call this thing, but in the future we
126 * will need to be able to use O_DIRECT on open in order to support
127 * AIO. Modeled after NFS, they do this too.
128 */
129
130static ssize_t orangefs_direct_IO(struct kiocb *iocb,
131				  struct iov_iter *iter)
132{
133	gossip_debug(GOSSIP_INODE_DEBUG,
134		     "orangefs_direct_IO: %pD\n",
135		     iocb->ki_filp);
136
137	return -EINVAL;
138}
139
140/** ORANGEFS2 implementation of address space operations */
141static const struct address_space_operations orangefs_address_operations = {
142	.readpage = orangefs_readpage,
143	.readpages = orangefs_readpages,
144	.invalidatepage = orangefs_invalidatepage,
145	.releasepage = orangefs_releasepage,
146	.direct_IO = orangefs_direct_IO,
147};
148
149static int orangefs_setattr_size(struct inode *inode, struct iattr *iattr)
150{
151	struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode);
152	struct orangefs_kernel_op_s *new_op;
153	loff_t orig_size;
154	int ret = -EINVAL;
155
156	gossip_debug(GOSSIP_INODE_DEBUG,
157		     "%s: %pU: Handle is %pU | fs_id %d | size is %llu\n",
158		     __func__,
159		     get_khandle_from_ino(inode),
160		     &orangefs_inode->refn.khandle,
161		     orangefs_inode->refn.fs_id,
162		     iattr->ia_size);
163
164	/* Ensure that we have a up to date size, so we know if it changed. */
165	ret = orangefs_inode_getattr(inode, 0, 1, STATX_SIZE);
166	if (ret == -ESTALE)
167		ret = -EIO;
168	if (ret) {
169		gossip_err("%s: orangefs_inode_getattr failed, ret:%d:.\n",
170		    __func__, ret);
171		return ret;
172	}
173	orig_size = i_size_read(inode);
174
175	truncate_setsize(inode, iattr->ia_size);
176
177	new_op = op_alloc(ORANGEFS_VFS_OP_TRUNCATE);
178	if (!new_op)
179		return -ENOMEM;
180
181	new_op->upcall.req.truncate.refn = orangefs_inode->refn;
182	new_op->upcall.req.truncate.size = (__s64) iattr->ia_size;
183
184	ret = service_operation(new_op, __func__,
185				get_interruptible_flag(inode));
186
187	/*
188	 * the truncate has no downcall members to retrieve, but
189	 * the status value tells us if it went through ok or not
190	 */
191	gossip_debug(GOSSIP_INODE_DEBUG,
192		     "orangefs: orangefs_truncate got return value of %d\n",
193		     ret);
194
195	op_release(new_op);
196
197	if (ret != 0)
198		return ret;
199
200	if (orig_size != i_size_read(inode))
201		iattr->ia_valid |= ATTR_CTIME | ATTR_MTIME;
202
203	return ret;
204}
205
206/*
207 * Change attributes of an object referenced by dentry.
208 */
209int orangefs_setattr(struct dentry *dentry, struct iattr *iattr)
210{
211	int ret = -EINVAL;
212	struct inode *inode = dentry->d_inode;
213
214	gossip_debug(GOSSIP_INODE_DEBUG,
215		     "orangefs_setattr: called on %pd\n",
216		     dentry);
217
218	ret = setattr_prepare(dentry, iattr);
219	if (ret)
220		goto out;
221
222	if (iattr->ia_valid & ATTR_SIZE) {
223		ret = orangefs_setattr_size(inode, iattr);
224		if (ret)
225			goto out;
226	}
227
228	setattr_copy(inode, iattr);
229	mark_inode_dirty(inode);
230
231	ret = orangefs_inode_setattr(inode, iattr);
232	gossip_debug(GOSSIP_INODE_DEBUG,
233		     "orangefs_setattr: inode_setattr returned %d\n",
234		     ret);
235
236	if (!ret && (iattr->ia_valid & ATTR_MODE))
237		/* change mod on a file that has ACLs */
238		ret = posix_acl_chmod(inode, inode->i_mode);
239
240out:
241	gossip_debug(GOSSIP_INODE_DEBUG, "orangefs_setattr: returning %d\n", ret);
242	return ret;
243}
244
245/*
246 * Obtain attributes of an object given a dentry
247 */
248int orangefs_getattr(const struct path *path, struct kstat *stat,
249		     u32 request_mask, unsigned int flags)
250{
251	int ret = -ENOENT;
252	struct inode *inode = path->dentry->d_inode;
253	struct orangefs_inode_s *orangefs_inode = NULL;
254
255	gossip_debug(GOSSIP_INODE_DEBUG,
256		     "orangefs_getattr: called on %pd\n",
257		     path->dentry);
258
259	ret = orangefs_inode_getattr(inode, 0, 0, request_mask);
260	if (ret == 0) {
261		generic_fillattr(inode, stat);
262
263		/* override block size reported to stat */
264		orangefs_inode = ORANGEFS_I(inode);
265		stat->blksize = orangefs_inode->blksize;
266
267		if (request_mask & STATX_SIZE)
268			stat->result_mask = STATX_BASIC_STATS;
269		else
270			stat->result_mask = STATX_BASIC_STATS &
271			    ~STATX_SIZE;
272	}
273	return ret;
274}
275
276int orangefs_permission(struct inode *inode, int mask)
277{
278	int ret;
279
280	if (mask & MAY_NOT_BLOCK)
281		return -ECHILD;
282
283	gossip_debug(GOSSIP_INODE_DEBUG, "%s: refreshing\n", __func__);
284
285	/* Make sure the permission (and other common attrs) are up to date. */
286	ret = orangefs_inode_getattr(inode, 0, 0, STATX_MODE);
287	if (ret < 0)
288		return ret;
289
290	return generic_permission(inode, mask);
291}
292
293int orangefs_update_time(struct inode *inode, struct timespec *time, int flags)
294{
295	struct iattr iattr;
296	gossip_debug(GOSSIP_INODE_DEBUG, "orangefs_update_time: %pU\n",
297	    get_khandle_from_ino(inode));
298	generic_update_time(inode, time, flags);
299	memset(&iattr, 0, sizeof iattr);
300        if (flags & S_ATIME)
301		iattr.ia_valid |= ATTR_ATIME;
302	if (flags & S_CTIME)
303		iattr.ia_valid |= ATTR_CTIME;
304	if (flags & S_MTIME)
305		iattr.ia_valid |= ATTR_MTIME;
306	return orangefs_inode_setattr(inode, &iattr);
307}
308
309/* ORANGEDS2 implementation of VFS inode operations for files */
310static const struct inode_operations orangefs_file_inode_operations = {
311	.get_acl = orangefs_get_acl,
312	.set_acl = orangefs_set_acl,
313	.setattr = orangefs_setattr,
314	.getattr = orangefs_getattr,
315	.listxattr = orangefs_listxattr,
316	.permission = orangefs_permission,
317	.update_time = orangefs_update_time,
318};
319
320static int orangefs_init_iops(struct inode *inode)
321{
322	inode->i_mapping->a_ops = &orangefs_address_operations;
323
324	switch (inode->i_mode & S_IFMT) {
325	case S_IFREG:
326		inode->i_op = &orangefs_file_inode_operations;
327		inode->i_fop = &orangefs_file_operations;
328		inode->i_blkbits = PAGE_SHIFT;
329		break;
330	case S_IFLNK:
331		inode->i_op = &orangefs_symlink_inode_operations;
332		break;
333	case S_IFDIR:
334		inode->i_op = &orangefs_dir_inode_operations;
335		inode->i_fop = &orangefs_dir_operations;
336		break;
337	default:
338		gossip_debug(GOSSIP_INODE_DEBUG,
339			     "%s: unsupported mode\n",
340			     __func__);
341		return -EINVAL;
342	}
343
344	return 0;
345}
346
347/*
348 * Given a ORANGEFS object identifier (fsid, handle), convert it into a ino_t type
349 * that will be used as a hash-index from where the handle will
350 * be searched for in the VFS hash table of inodes.
351 */
352static inline ino_t orangefs_handle_hash(struct orangefs_object_kref *ref)
353{
354	if (!ref)
355		return 0;
356	return orangefs_khandle_to_ino(&(ref->khandle));
357}
358
359/*
360 * Called to set up an inode from iget5_locked.
361 */
362static int orangefs_set_inode(struct inode *inode, void *data)
363{
364	struct orangefs_object_kref *ref = (struct orangefs_object_kref *) data;
365	ORANGEFS_I(inode)->refn.fs_id = ref->fs_id;
366	ORANGEFS_I(inode)->refn.khandle = ref->khandle;
367	return 0;
368}
369
370/*
371 * Called to determine if handles match.
372 */
373static int orangefs_test_inode(struct inode *inode, void *data)
374{
375	struct orangefs_object_kref *ref = (struct orangefs_object_kref *) data;
376	struct orangefs_inode_s *orangefs_inode = NULL;
377
378	orangefs_inode = ORANGEFS_I(inode);
379	return (!ORANGEFS_khandle_cmp(&(orangefs_inode->refn.khandle), &(ref->khandle))
380		&& orangefs_inode->refn.fs_id == ref->fs_id);
381}
382
383/*
384 * Front-end to lookup the inode-cache maintained by the VFS using the ORANGEFS
385 * file handle.
386 *
387 * @sb: the file system super block instance.
388 * @ref: The ORANGEFS object for which we are trying to locate an inode structure.
389 */
390struct inode *orangefs_iget(struct super_block *sb, struct orangefs_object_kref *ref)
391{
392	struct inode *inode = NULL;
393	unsigned long hash;
394	int error;
395
396	hash = orangefs_handle_hash(ref);
397	inode = iget5_locked(sb, hash, orangefs_test_inode, orangefs_set_inode, ref);
398	if (!inode || !(inode->i_state & I_NEW))
399		return inode;
400
401	error = orangefs_inode_getattr(inode, 1, 1, STATX_ALL);
402	if (error) {
403		iget_failed(inode);
404		return ERR_PTR(error);
405	}
406
407	inode->i_ino = hash;	/* needed for stat etc */
408	orangefs_init_iops(inode);
409	unlock_new_inode(inode);
410
411	gossip_debug(GOSSIP_INODE_DEBUG,
412		     "iget handle %pU, fsid %d hash %ld i_ino %lu\n",
413		     &ref->khandle,
414		     ref->fs_id,
415		     hash,
416		     inode->i_ino);
417
418	return inode;
419}
420
421/*
422 * Allocate an inode for a newly created file and insert it into the inode hash.
423 */
424struct inode *orangefs_new_inode(struct super_block *sb, struct inode *dir,
425		int mode, dev_t dev, struct orangefs_object_kref *ref)
426{
427	unsigned long hash = orangefs_handle_hash(ref);
428	struct inode *inode;
429	int error;
430
431	gossip_debug(GOSSIP_INODE_DEBUG,
432		     "%s:(sb is %p | MAJOR(dev)=%u | MINOR(dev)=%u mode=%o)\n",
433		     __func__,
434		     sb,
435		     MAJOR(dev),
436		     MINOR(dev),
437		     mode);
438
439	inode = new_inode(sb);
440	if (!inode)
441		return NULL;
442
443	orangefs_set_inode(inode, ref);
444	inode->i_ino = hash;	/* needed for stat etc */
445
446	error = orangefs_inode_getattr(inode, 1, 1, STATX_ALL);
447	if (error)
448		goto out_iput;
449
450	orangefs_init_iops(inode);
451
452	inode->i_mode = mode;
453	inode->i_uid = current_fsuid();
454	inode->i_gid = current_fsgid();
455	inode->i_atime = inode->i_mtime = inode->i_ctime = current_time(inode);
456	inode->i_size = PAGE_SIZE;
457	inode->i_rdev = dev;
458
459	error = insert_inode_locked4(inode, hash, orangefs_test_inode, ref);
460	if (error < 0)
461		goto out_iput;
462
463	gossip_debug(GOSSIP_INODE_DEBUG,
464		     "Initializing ACL's for inode %pU\n",
465		     get_khandle_from_ino(inode));
466	orangefs_init_acl(inode, dir);
467	return inode;
468
469out_iput:
470	iput(inode);
471	return ERR_PTR(error);
472}