xattr.c 28 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037
  1. /*
  2. * linux/fs/ext2/xattr.c
  3. *
  4. * Copyright (C) 2001-2003 Andreas Gruenbacher <agruen@suse.de>
  5. *
  6. * Fix by Harrison Xing <harrison@mountainviewdata.com>.
  7. * Extended attributes for symlinks and special files added per
  8. * suggestion of Luka Renko <luka.renko@hermes.si>.
  9. * xattr consolidation Copyright (c) 2004 James Morris <jmorris@redhat.com>,
  10. * Red Hat Inc.
  11. *
  12. */
  13. /*
  14. * Extended attributes are stored on disk blocks allocated outside of
  15. * any inode. The i_file_acl field is then made to point to this allocated
  16. * block. If all extended attributes of an inode are identical, these
  17. * inodes may share the same extended attribute block. Such situations
  18. * are automatically detected by keeping a cache of recent attribute block
  19. * numbers and hashes over the block's contents in memory.
  20. *
  21. *
  22. * Extended attribute block layout:
  23. *
  24. * +------------------+
  25. * | header |
  26. * | entry 1 | |
  27. * | entry 2 | | growing downwards
  28. * | entry 3 | v
  29. * | four null bytes |
  30. * | . . . |
  31. * | value 1 | ^
  32. * | value 3 | | growing upwards
  33. * | value 2 | |
  34. * +------------------+
  35. *
  36. * The block header is followed by multiple entry descriptors. These entry
  37. * descriptors are variable in size, and alligned to EXT2_XATTR_PAD
  38. * byte boundaries. The entry descriptors are sorted by attribute name,
  39. * so that two extended attribute blocks can be compared efficiently.
  40. *
  41. * Attribute values are aligned to the end of the block, stored in
  42. * no specific order. They are also padded to EXT2_XATTR_PAD byte
  43. * boundaries. No additional gaps are left between them.
  44. *
  45. * Locking strategy
  46. * ----------------
  47. * EXT2_I(inode)->i_file_acl is protected by EXT2_I(inode)->xattr_sem.
  48. * EA blocks are only changed if they are exclusive to an inode, so
  49. * holding xattr_sem also means that nothing but the EA block's reference
  50. * count will change. Multiple writers to an EA block are synchronized
  51. * by the bh lock. No more than a single bh lock is held at any time
  52. * to avoid deadlocks.
  53. */
  54. #include <linux/buffer_head.h>
  55. #include <linux/module.h>
  56. #include <linux/init.h>
  57. #include <linux/slab.h>
  58. #include <linux/mbcache.h>
  59. #include <linux/quotaops.h>
  60. #include <linux/rwsem.h>
  61. #include "ext2.h"
  62. #include "xattr.h"
  63. #include "acl.h"
  64. #define HDR(bh) ((struct ext2_xattr_header *)((bh)->b_data))
  65. #define ENTRY(ptr) ((struct ext2_xattr_entry *)(ptr))
  66. #define FIRST_ENTRY(bh) ENTRY(HDR(bh)+1)
  67. #define IS_LAST_ENTRY(entry) (*(__u32 *)(entry) == 0)
  68. #ifdef EXT2_XATTR_DEBUG
  69. # define ea_idebug(inode, f...) do { \
  70. printk(KERN_DEBUG "inode %s:%ld: ", \
  71. inode->i_sb->s_id, inode->i_ino); \
  72. printk(f); \
  73. printk("\n"); \
  74. } while (0)
  75. # define ea_bdebug(bh, f...) do { \
  76. char b[BDEVNAME_SIZE]; \
  77. printk(KERN_DEBUG "block %s:%lu: ", \
  78. bdevname(bh->b_bdev, b), \
  79. (unsigned long) bh->b_blocknr); \
  80. printk(f); \
  81. printk("\n"); \
  82. } while (0)
  83. #else
  84. # define ea_idebug(f...)
  85. # define ea_bdebug(f...)
  86. #endif
  87. static int ext2_xattr_set2(struct inode *, struct buffer_head *,
  88. struct ext2_xattr_header *);
  89. static int ext2_xattr_cache_insert(struct buffer_head *);
  90. static struct buffer_head *ext2_xattr_cache_find(struct inode *,
  91. struct ext2_xattr_header *);
  92. static void ext2_xattr_rehash(struct ext2_xattr_header *,
  93. struct ext2_xattr_entry *);
  94. static struct mb_cache *ext2_xattr_cache;
  95. static struct xattr_handler *ext2_xattr_handler_map[] = {
  96. [EXT2_XATTR_INDEX_USER] = &ext2_xattr_user_handler,
  97. #ifdef CONFIG_EXT2_FS_POSIX_ACL
  98. [EXT2_XATTR_INDEX_POSIX_ACL_ACCESS] = &ext2_xattr_acl_access_handler,
  99. [EXT2_XATTR_INDEX_POSIX_ACL_DEFAULT] = &ext2_xattr_acl_default_handler,
  100. #endif
  101. [EXT2_XATTR_INDEX_TRUSTED] = &ext2_xattr_trusted_handler,
  102. #ifdef CONFIG_EXT2_FS_SECURITY
  103. [EXT2_XATTR_INDEX_SECURITY] = &ext2_xattr_security_handler,
  104. #endif
  105. };
  106. struct xattr_handler *ext2_xattr_handlers[] = {
  107. &ext2_xattr_user_handler,
  108. &ext2_xattr_trusted_handler,
  109. #ifdef CONFIG_EXT2_FS_POSIX_ACL
  110. &ext2_xattr_acl_access_handler,
  111. &ext2_xattr_acl_default_handler,
  112. #endif
  113. #ifdef CONFIG_EXT2_FS_SECURITY
  114. &ext2_xattr_security_handler,
  115. #endif
  116. NULL
  117. };
  118. static inline struct xattr_handler *
  119. ext2_xattr_handler(int name_index)
  120. {
  121. struct xattr_handler *handler = NULL;
  122. if (name_index > 0 && name_index < ARRAY_SIZE(ext2_xattr_handler_map))
  123. handler = ext2_xattr_handler_map[name_index];
  124. return handler;
  125. }
  126. /*
  127. * ext2_xattr_get()
  128. *
  129. * Copy an extended attribute into the buffer
  130. * provided, or compute the buffer size required.
  131. * Buffer is NULL to compute the size of the buffer required.
  132. *
  133. * Returns a negative error number on failure, or the number of bytes
  134. * used / required on success.
  135. */
  136. int
  137. ext2_xattr_get(struct inode *inode, int name_index, const char *name,
  138. void *buffer, size_t buffer_size)
  139. {
  140. struct buffer_head *bh = NULL;
  141. struct ext2_xattr_entry *entry;
  142. size_t name_len, size;
  143. char *end;
  144. int error;
  145. ea_idebug(inode, "name=%d.%s, buffer=%p, buffer_size=%ld",
  146. name_index, name, buffer, (long)buffer_size);
  147. if (name == NULL)
  148. return -EINVAL;
  149. down_read(&EXT2_I(inode)->xattr_sem);
  150. error = -ENODATA;
  151. if (!EXT2_I(inode)->i_file_acl)
  152. goto cleanup;
  153. ea_idebug(inode, "reading block %d", EXT2_I(inode)->i_file_acl);
  154. bh = sb_bread(inode->i_sb, EXT2_I(inode)->i_file_acl);
  155. error = -EIO;
  156. if (!bh)
  157. goto cleanup;
  158. ea_bdebug(bh, "b_count=%d, refcount=%d",
  159. atomic_read(&(bh->b_count)), le32_to_cpu(HDR(bh)->h_refcount));
  160. end = bh->b_data + bh->b_size;
  161. if (HDR(bh)->h_magic != cpu_to_le32(EXT2_XATTR_MAGIC) ||
  162. HDR(bh)->h_blocks != cpu_to_le32(1)) {
  163. bad_block: ext2_error(inode->i_sb, "ext2_xattr_get",
  164. "inode %ld: bad block %d", inode->i_ino,
  165. EXT2_I(inode)->i_file_acl);
  166. error = -EIO;
  167. goto cleanup;
  168. }
  169. /* find named attribute */
  170. name_len = strlen(name);
  171. error = -ERANGE;
  172. if (name_len > 255)
  173. goto cleanup;
  174. entry = FIRST_ENTRY(bh);
  175. while (!IS_LAST_ENTRY(entry)) {
  176. struct ext2_xattr_entry *next =
  177. EXT2_XATTR_NEXT(entry);
  178. if ((char *)next >= end)
  179. goto bad_block;
  180. if (name_index == entry->e_name_index &&
  181. name_len == entry->e_name_len &&
  182. memcmp(name, entry->e_name, name_len) == 0)
  183. goto found;
  184. entry = next;
  185. }
  186. /* Check the remaining name entries */
  187. while (!IS_LAST_ENTRY(entry)) {
  188. struct ext2_xattr_entry *next =
  189. EXT2_XATTR_NEXT(entry);
  190. if ((char *)next >= end)
  191. goto bad_block;
  192. entry = next;
  193. }
  194. if (ext2_xattr_cache_insert(bh))
  195. ea_idebug(inode, "cache insert failed");
  196. error = -ENODATA;
  197. goto cleanup;
  198. found:
  199. /* check the buffer size */
  200. if (entry->e_value_block != 0)
  201. goto bad_block;
  202. size = le32_to_cpu(entry->e_value_size);
  203. if (size > inode->i_sb->s_blocksize ||
  204. le16_to_cpu(entry->e_value_offs) + size > inode->i_sb->s_blocksize)
  205. goto bad_block;
  206. if (ext2_xattr_cache_insert(bh))
  207. ea_idebug(inode, "cache insert failed");
  208. if (buffer) {
  209. error = -ERANGE;
  210. if (size > buffer_size)
  211. goto cleanup;
  212. /* return value of attribute */
  213. memcpy(buffer, bh->b_data + le16_to_cpu(entry->e_value_offs),
  214. size);
  215. }
  216. error = size;
  217. cleanup:
  218. brelse(bh);
  219. up_read(&EXT2_I(inode)->xattr_sem);
  220. return error;
  221. }
  222. /*
  223. * ext2_xattr_list()
  224. *
  225. * Copy a list of attribute names into the buffer
  226. * provided, or compute the buffer size required.
  227. * Buffer is NULL to compute the size of the buffer required.
  228. *
  229. * Returns a negative error number on failure, or the number of bytes
  230. * used / required on success.
  231. */
  232. static int
  233. ext2_xattr_list(struct inode *inode, char *buffer, size_t buffer_size)
  234. {
  235. struct buffer_head *bh = NULL;
  236. struct ext2_xattr_entry *entry;
  237. char *end;
  238. size_t rest = buffer_size;
  239. int error;
  240. ea_idebug(inode, "buffer=%p, buffer_size=%ld",
  241. buffer, (long)buffer_size);
  242. down_read(&EXT2_I(inode)->xattr_sem);
  243. error = 0;
  244. if (!EXT2_I(inode)->i_file_acl)
  245. goto cleanup;
  246. ea_idebug(inode, "reading block %d", EXT2_I(inode)->i_file_acl);
  247. bh = sb_bread(inode->i_sb, EXT2_I(inode)->i_file_acl);
  248. error = -EIO;
  249. if (!bh)
  250. goto cleanup;
  251. ea_bdebug(bh, "b_count=%d, refcount=%d",
  252. atomic_read(&(bh->b_count)), le32_to_cpu(HDR(bh)->h_refcount));
  253. end = bh->b_data + bh->b_size;
  254. if (HDR(bh)->h_magic != cpu_to_le32(EXT2_XATTR_MAGIC) ||
  255. HDR(bh)->h_blocks != cpu_to_le32(1)) {
  256. bad_block: ext2_error(inode->i_sb, "ext2_xattr_list",
  257. "inode %ld: bad block %d", inode->i_ino,
  258. EXT2_I(inode)->i_file_acl);
  259. error = -EIO;
  260. goto cleanup;
  261. }
  262. /* check the on-disk data structure */
  263. entry = FIRST_ENTRY(bh);
  264. while (!IS_LAST_ENTRY(entry)) {
  265. struct ext2_xattr_entry *next = EXT2_XATTR_NEXT(entry);
  266. if ((char *)next >= end)
  267. goto bad_block;
  268. entry = next;
  269. }
  270. if (ext2_xattr_cache_insert(bh))
  271. ea_idebug(inode, "cache insert failed");
  272. /* list the attribute names */
  273. for (entry = FIRST_ENTRY(bh); !IS_LAST_ENTRY(entry);
  274. entry = EXT2_XATTR_NEXT(entry)) {
  275. struct xattr_handler *handler =
  276. ext2_xattr_handler(entry->e_name_index);
  277. if (handler) {
  278. size_t size = handler->list(inode, buffer, rest,
  279. entry->e_name,
  280. entry->e_name_len);
  281. if (buffer) {
  282. if (size > rest) {
  283. error = -ERANGE;
  284. goto cleanup;
  285. }
  286. buffer += size;
  287. }
  288. rest -= size;
  289. }
  290. }
  291. error = buffer_size - rest; /* total size */
  292. cleanup:
  293. brelse(bh);
  294. up_read(&EXT2_I(inode)->xattr_sem);
  295. return error;
  296. }
  297. /*
  298. * Inode operation listxattr()
  299. *
  300. * dentry->d_inode->i_mutex: don't care
  301. */
  302. ssize_t
  303. ext2_listxattr(struct dentry *dentry, char *buffer, size_t size)
  304. {
  305. return ext2_xattr_list(dentry->d_inode, buffer, size);
  306. }
  307. /*
  308. * If the EXT2_FEATURE_COMPAT_EXT_ATTR feature of this file system is
  309. * not set, set it.
  310. */
  311. static void ext2_xattr_update_super_block(struct super_block *sb)
  312. {
  313. if (EXT2_HAS_COMPAT_FEATURE(sb, EXT2_FEATURE_COMPAT_EXT_ATTR))
  314. return;
  315. EXT2_SET_COMPAT_FEATURE(sb, EXT2_FEATURE_COMPAT_EXT_ATTR);
  316. sb->s_dirt = 1;
  317. mark_buffer_dirty(EXT2_SB(sb)->s_sbh);
  318. }
  319. /*
  320. * ext2_xattr_set()
  321. *
  322. * Create, replace or remove an extended attribute for this inode. Buffer
  323. * is NULL to remove an existing extended attribute, and non-NULL to
  324. * either replace an existing extended attribute, or create a new extended
  325. * attribute. The flags XATTR_REPLACE and XATTR_CREATE
  326. * specify that an extended attribute must exist and must not exist
  327. * previous to the call, respectively.
  328. *
  329. * Returns 0, or a negative error number on failure.
  330. */
  331. int
  332. ext2_xattr_set(struct inode *inode, int name_index, const char *name,
  333. const void *value, size_t value_len, int flags)
  334. {
  335. struct super_block *sb = inode->i_sb;
  336. struct buffer_head *bh = NULL;
  337. struct ext2_xattr_header *header = NULL;
  338. struct ext2_xattr_entry *here, *last;
  339. size_t name_len, free, min_offs = sb->s_blocksize;
  340. int not_found = 1, error;
  341. char *end;
  342. /*
  343. * header -- Points either into bh, or to a temporarily
  344. * allocated buffer.
  345. * here -- The named entry found, or the place for inserting, within
  346. * the block pointed to by header.
  347. * last -- Points right after the last named entry within the block
  348. * pointed to by header.
  349. * min_offs -- The offset of the first value (values are aligned
  350. * towards the end of the block).
  351. * end -- Points right after the block pointed to by header.
  352. */
  353. ea_idebug(inode, "name=%d.%s, value=%p, value_len=%ld",
  354. name_index, name, value, (long)value_len);
  355. if (value == NULL)
  356. value_len = 0;
  357. if (name == NULL)
  358. return -EINVAL;
  359. name_len = strlen(name);
  360. if (name_len > 255 || value_len > sb->s_blocksize)
  361. return -ERANGE;
  362. down_write(&EXT2_I(inode)->xattr_sem);
  363. if (EXT2_I(inode)->i_file_acl) {
  364. /* The inode already has an extended attribute block. */
  365. bh = sb_bread(sb, EXT2_I(inode)->i_file_acl);
  366. error = -EIO;
  367. if (!bh)
  368. goto cleanup;
  369. ea_bdebug(bh, "b_count=%d, refcount=%d",
  370. atomic_read(&(bh->b_count)),
  371. le32_to_cpu(HDR(bh)->h_refcount));
  372. header = HDR(bh);
  373. end = bh->b_data + bh->b_size;
  374. if (header->h_magic != cpu_to_le32(EXT2_XATTR_MAGIC) ||
  375. header->h_blocks != cpu_to_le32(1)) {
  376. bad_block: ext2_error(sb, "ext2_xattr_set",
  377. "inode %ld: bad block %d", inode->i_ino,
  378. EXT2_I(inode)->i_file_acl);
  379. error = -EIO;
  380. goto cleanup;
  381. }
  382. /* Find the named attribute. */
  383. here = FIRST_ENTRY(bh);
  384. while (!IS_LAST_ENTRY(here)) {
  385. struct ext2_xattr_entry *next = EXT2_XATTR_NEXT(here);
  386. if ((char *)next >= end)
  387. goto bad_block;
  388. if (!here->e_value_block && here->e_value_size) {
  389. size_t offs = le16_to_cpu(here->e_value_offs);
  390. if (offs < min_offs)
  391. min_offs = offs;
  392. }
  393. not_found = name_index - here->e_name_index;
  394. if (!not_found)
  395. not_found = name_len - here->e_name_len;
  396. if (!not_found)
  397. not_found = memcmp(name, here->e_name,name_len);
  398. if (not_found <= 0)
  399. break;
  400. here = next;
  401. }
  402. last = here;
  403. /* We still need to compute min_offs and last. */
  404. while (!IS_LAST_ENTRY(last)) {
  405. struct ext2_xattr_entry *next = EXT2_XATTR_NEXT(last);
  406. if ((char *)next >= end)
  407. goto bad_block;
  408. if (!last->e_value_block && last->e_value_size) {
  409. size_t offs = le16_to_cpu(last->e_value_offs);
  410. if (offs < min_offs)
  411. min_offs = offs;
  412. }
  413. last = next;
  414. }
  415. /* Check whether we have enough space left. */
  416. free = min_offs - ((char*)last - (char*)header) - sizeof(__u32);
  417. } else {
  418. /* We will use a new extended attribute block. */
  419. free = sb->s_blocksize -
  420. sizeof(struct ext2_xattr_header) - sizeof(__u32);
  421. here = last = NULL; /* avoid gcc uninitialized warning. */
  422. }
  423. if (not_found) {
  424. /* Request to remove a nonexistent attribute? */
  425. error = -ENODATA;
  426. if (flags & XATTR_REPLACE)
  427. goto cleanup;
  428. error = 0;
  429. if (value == NULL)
  430. goto cleanup;
  431. } else {
  432. /* Request to create an existing attribute? */
  433. error = -EEXIST;
  434. if (flags & XATTR_CREATE)
  435. goto cleanup;
  436. if (!here->e_value_block && here->e_value_size) {
  437. size_t size = le32_to_cpu(here->e_value_size);
  438. if (le16_to_cpu(here->e_value_offs) + size >
  439. sb->s_blocksize || size > sb->s_blocksize)
  440. goto bad_block;
  441. free += EXT2_XATTR_SIZE(size);
  442. }
  443. free += EXT2_XATTR_LEN(name_len);
  444. }
  445. error = -ENOSPC;
  446. if (free < EXT2_XATTR_LEN(name_len) + EXT2_XATTR_SIZE(value_len))
  447. goto cleanup;
  448. /* Here we know that we can set the new attribute. */
  449. if (header) {
  450. struct mb_cache_entry *ce;
  451. /* assert(header == HDR(bh)); */
  452. ce = mb_cache_entry_get(ext2_xattr_cache, bh->b_bdev,
  453. bh->b_blocknr);
  454. lock_buffer(bh);
  455. if (header->h_refcount == cpu_to_le32(1)) {
  456. ea_bdebug(bh, "modifying in-place");
  457. if (ce)
  458. mb_cache_entry_free(ce);
  459. /* keep the buffer locked while modifying it. */
  460. } else {
  461. int offset;
  462. if (ce)
  463. mb_cache_entry_release(ce);
  464. unlock_buffer(bh);
  465. ea_bdebug(bh, "cloning");
  466. header = kmalloc(bh->b_size, GFP_KERNEL);
  467. error = -ENOMEM;
  468. if (header == NULL)
  469. goto cleanup;
  470. memcpy(header, HDR(bh), bh->b_size);
  471. header->h_refcount = cpu_to_le32(1);
  472. offset = (char *)here - bh->b_data;
  473. here = ENTRY((char *)header + offset);
  474. offset = (char *)last - bh->b_data;
  475. last = ENTRY((char *)header + offset);
  476. }
  477. } else {
  478. /* Allocate a buffer where we construct the new block. */
  479. header = kzalloc(sb->s_blocksize, GFP_KERNEL);
  480. error = -ENOMEM;
  481. if (header == NULL)
  482. goto cleanup;
  483. end = (char *)header + sb->s_blocksize;
  484. header->h_magic = cpu_to_le32(EXT2_XATTR_MAGIC);
  485. header->h_blocks = header->h_refcount = cpu_to_le32(1);
  486. last = here = ENTRY(header+1);
  487. }
  488. /* Iff we are modifying the block in-place, bh is locked here. */
  489. if (not_found) {
  490. /* Insert the new name. */
  491. size_t size = EXT2_XATTR_LEN(name_len);
  492. size_t rest = (char *)last - (char *)here;
  493. memmove((char *)here + size, here, rest);
  494. memset(here, 0, size);
  495. here->e_name_index = name_index;
  496. here->e_name_len = name_len;
  497. memcpy(here->e_name, name, name_len);
  498. } else {
  499. if (!here->e_value_block && here->e_value_size) {
  500. char *first_val = (char *)header + min_offs;
  501. size_t offs = le16_to_cpu(here->e_value_offs);
  502. char *val = (char *)header + offs;
  503. size_t size = EXT2_XATTR_SIZE(
  504. le32_to_cpu(here->e_value_size));
  505. if (size == EXT2_XATTR_SIZE(value_len)) {
  506. /* The old and the new value have the same
  507. size. Just replace. */
  508. here->e_value_size = cpu_to_le32(value_len);
  509. memset(val + size - EXT2_XATTR_PAD, 0,
  510. EXT2_XATTR_PAD); /* Clear pad bytes. */
  511. memcpy(val, value, value_len);
  512. goto skip_replace;
  513. }
  514. /* Remove the old value. */
  515. memmove(first_val + size, first_val, val - first_val);
  516. memset(first_val, 0, size);
  517. here->e_value_offs = 0;
  518. min_offs += size;
  519. /* Adjust all value offsets. */
  520. last = ENTRY(header+1);
  521. while (!IS_LAST_ENTRY(last)) {
  522. size_t o = le16_to_cpu(last->e_value_offs);
  523. if (!last->e_value_block && o < offs)
  524. last->e_value_offs =
  525. cpu_to_le16(o + size);
  526. last = EXT2_XATTR_NEXT(last);
  527. }
  528. }
  529. if (value == NULL) {
  530. /* Remove the old name. */
  531. size_t size = EXT2_XATTR_LEN(name_len);
  532. last = ENTRY((char *)last - size);
  533. memmove(here, (char*)here + size,
  534. (char*)last - (char*)here);
  535. memset(last, 0, size);
  536. }
  537. }
  538. if (value != NULL) {
  539. /* Insert the new value. */
  540. here->e_value_size = cpu_to_le32(value_len);
  541. if (value_len) {
  542. size_t size = EXT2_XATTR_SIZE(value_len);
  543. char *val = (char *)header + min_offs - size;
  544. here->e_value_offs =
  545. cpu_to_le16((char *)val - (char *)header);
  546. memset(val + size - EXT2_XATTR_PAD, 0,
  547. EXT2_XATTR_PAD); /* Clear the pad bytes. */
  548. memcpy(val, value, value_len);
  549. }
  550. }
  551. skip_replace:
  552. if (IS_LAST_ENTRY(ENTRY(header+1))) {
  553. /* This block is now empty. */
  554. if (bh && header == HDR(bh))
  555. unlock_buffer(bh); /* we were modifying in-place. */
  556. error = ext2_xattr_set2(inode, bh, NULL);
  557. } else {
  558. ext2_xattr_rehash(header, here);
  559. if (bh && header == HDR(bh))
  560. unlock_buffer(bh); /* we were modifying in-place. */
  561. error = ext2_xattr_set2(inode, bh, header);
  562. }
  563. cleanup:
  564. brelse(bh);
  565. if (!(bh && header == HDR(bh)))
  566. kfree(header);
  567. up_write(&EXT2_I(inode)->xattr_sem);
  568. return error;
  569. }
  570. /*
  571. * Second half of ext2_xattr_set(): Update the file system.
  572. */
  573. static int
  574. ext2_xattr_set2(struct inode *inode, struct buffer_head *old_bh,
  575. struct ext2_xattr_header *header)
  576. {
  577. struct super_block *sb = inode->i_sb;
  578. struct buffer_head *new_bh = NULL;
  579. int error;
  580. if (header) {
  581. new_bh = ext2_xattr_cache_find(inode, header);
  582. if (new_bh) {
  583. /* We found an identical block in the cache. */
  584. if (new_bh == old_bh) {
  585. ea_bdebug(new_bh, "keeping this block");
  586. } else {
  587. /* The old block is released after updating
  588. the inode. */
  589. ea_bdebug(new_bh, "reusing block");
  590. error = -EDQUOT;
  591. if (DQUOT_ALLOC_BLOCK(inode, 1)) {
  592. unlock_buffer(new_bh);
  593. goto cleanup;
  594. }
  595. HDR(new_bh)->h_refcount = cpu_to_le32(1 +
  596. le32_to_cpu(HDR(new_bh)->h_refcount));
  597. ea_bdebug(new_bh, "refcount now=%d",
  598. le32_to_cpu(HDR(new_bh)->h_refcount));
  599. }
  600. unlock_buffer(new_bh);
  601. } else if (old_bh && header == HDR(old_bh)) {
  602. /* Keep this block. No need to lock the block as we
  603. don't need to change the reference count. */
  604. new_bh = old_bh;
  605. get_bh(new_bh);
  606. ext2_xattr_cache_insert(new_bh);
  607. } else {
  608. /* We need to allocate a new block */
  609. int goal = le32_to_cpu(EXT2_SB(sb)->s_es->
  610. s_first_data_block) +
  611. EXT2_I(inode)->i_block_group *
  612. EXT2_BLOCKS_PER_GROUP(sb);
  613. int block = ext2_new_block(inode, goal,
  614. NULL, NULL, &error);
  615. if (error)
  616. goto cleanup;
  617. ea_idebug(inode, "creating block %d", block);
  618. new_bh = sb_getblk(sb, block);
  619. if (!new_bh) {
  620. ext2_free_blocks(inode, block, 1);
  621. error = -EIO;
  622. goto cleanup;
  623. }
  624. lock_buffer(new_bh);
  625. memcpy(new_bh->b_data, header, new_bh->b_size);
  626. set_buffer_uptodate(new_bh);
  627. unlock_buffer(new_bh);
  628. ext2_xattr_cache_insert(new_bh);
  629. ext2_xattr_update_super_block(sb);
  630. }
  631. mark_buffer_dirty(new_bh);
  632. if (IS_SYNC(inode)) {
  633. sync_dirty_buffer(new_bh);
  634. error = -EIO;
  635. if (buffer_req(new_bh) && !buffer_uptodate(new_bh))
  636. goto cleanup;
  637. }
  638. }
  639. /* Update the inode. */
  640. EXT2_I(inode)->i_file_acl = new_bh ? new_bh->b_blocknr : 0;
  641. inode->i_ctime = CURRENT_TIME_SEC;
  642. if (IS_SYNC(inode)) {
  643. error = ext2_sync_inode (inode);
  644. /* In case sync failed due to ENOSPC the inode was actually
  645. * written (only some dirty data were not) so we just proceed
  646. * as if nothing happened and cleanup the unused block */
  647. if (error && error != -ENOSPC) {
  648. if (new_bh && new_bh != old_bh)
  649. DQUOT_FREE_BLOCK(inode, 1);
  650. goto cleanup;
  651. }
  652. } else
  653. mark_inode_dirty(inode);
  654. error = 0;
  655. if (old_bh && old_bh != new_bh) {
  656. struct mb_cache_entry *ce;
  657. /*
  658. * If there was an old block and we are no longer using it,
  659. * release the old block.
  660. */
  661. ce = mb_cache_entry_get(ext2_xattr_cache, old_bh->b_bdev,
  662. old_bh->b_blocknr);
  663. lock_buffer(old_bh);
  664. if (HDR(old_bh)->h_refcount == cpu_to_le32(1)) {
  665. /* Free the old block. */
  666. if (ce)
  667. mb_cache_entry_free(ce);
  668. ea_bdebug(old_bh, "freeing");
  669. ext2_free_blocks(inode, old_bh->b_blocknr, 1);
  670. /* We let our caller release old_bh, so we
  671. * need to duplicate the buffer before. */
  672. get_bh(old_bh);
  673. bforget(old_bh);
  674. } else {
  675. /* Decrement the refcount only. */
  676. HDR(old_bh)->h_refcount = cpu_to_le32(
  677. le32_to_cpu(HDR(old_bh)->h_refcount) - 1);
  678. if (ce)
  679. mb_cache_entry_release(ce);
  680. DQUOT_FREE_BLOCK(inode, 1);
  681. mark_buffer_dirty(old_bh);
  682. ea_bdebug(old_bh, "refcount now=%d",
  683. le32_to_cpu(HDR(old_bh)->h_refcount));
  684. }
  685. unlock_buffer(old_bh);
  686. }
  687. cleanup:
  688. brelse(new_bh);
  689. return error;
  690. }
  691. /*
  692. * ext2_xattr_delete_inode()
  693. *
  694. * Free extended attribute resources associated with this inode. This
  695. * is called immediately before an inode is freed.
  696. */
  697. void
  698. ext2_xattr_delete_inode(struct inode *inode)
  699. {
  700. struct buffer_head *bh = NULL;
  701. struct mb_cache_entry *ce;
  702. down_write(&EXT2_I(inode)->xattr_sem);
  703. if (!EXT2_I(inode)->i_file_acl)
  704. goto cleanup;
  705. bh = sb_bread(inode->i_sb, EXT2_I(inode)->i_file_acl);
  706. if (!bh) {
  707. ext2_error(inode->i_sb, "ext2_xattr_delete_inode",
  708. "inode %ld: block %d read error", inode->i_ino,
  709. EXT2_I(inode)->i_file_acl);
  710. goto cleanup;
  711. }
  712. ea_bdebug(bh, "b_count=%d", atomic_read(&(bh->b_count)));
  713. if (HDR(bh)->h_magic != cpu_to_le32(EXT2_XATTR_MAGIC) ||
  714. HDR(bh)->h_blocks != cpu_to_le32(1)) {
  715. ext2_error(inode->i_sb, "ext2_xattr_delete_inode",
  716. "inode %ld: bad block %d", inode->i_ino,
  717. EXT2_I(inode)->i_file_acl);
  718. goto cleanup;
  719. }
  720. ce = mb_cache_entry_get(ext2_xattr_cache, bh->b_bdev, bh->b_blocknr);
  721. lock_buffer(bh);
  722. if (HDR(bh)->h_refcount == cpu_to_le32(1)) {
  723. if (ce)
  724. mb_cache_entry_free(ce);
  725. ext2_free_blocks(inode, EXT2_I(inode)->i_file_acl, 1);
  726. get_bh(bh);
  727. bforget(bh);
  728. unlock_buffer(bh);
  729. } else {
  730. HDR(bh)->h_refcount = cpu_to_le32(
  731. le32_to_cpu(HDR(bh)->h_refcount) - 1);
  732. if (ce)
  733. mb_cache_entry_release(ce);
  734. ea_bdebug(bh, "refcount now=%d",
  735. le32_to_cpu(HDR(bh)->h_refcount));
  736. unlock_buffer(bh);
  737. mark_buffer_dirty(bh);
  738. if (IS_SYNC(inode))
  739. sync_dirty_buffer(bh);
  740. DQUOT_FREE_BLOCK(inode, 1);
  741. }
  742. EXT2_I(inode)->i_file_acl = 0;
  743. cleanup:
  744. brelse(bh);
  745. up_write(&EXT2_I(inode)->xattr_sem);
  746. }
  747. /*
  748. * ext2_xattr_put_super()
  749. *
  750. * This is called when a file system is unmounted.
  751. */
  752. void
  753. ext2_xattr_put_super(struct super_block *sb)
  754. {
  755. mb_cache_shrink(sb->s_bdev);
  756. }
  757. /*
  758. * ext2_xattr_cache_insert()
  759. *
  760. * Create a new entry in the extended attribute cache, and insert
  761. * it unless such an entry is already in the cache.
  762. *
  763. * Returns 0, or a negative error number on failure.
  764. */
  765. static int
  766. ext2_xattr_cache_insert(struct buffer_head *bh)
  767. {
  768. __u32 hash = le32_to_cpu(HDR(bh)->h_hash);
  769. struct mb_cache_entry *ce;
  770. int error;
  771. ce = mb_cache_entry_alloc(ext2_xattr_cache);
  772. if (!ce)
  773. return -ENOMEM;
  774. error = mb_cache_entry_insert(ce, bh->b_bdev, bh->b_blocknr, &hash);
  775. if (error) {
  776. mb_cache_entry_free(ce);
  777. if (error == -EBUSY) {
  778. ea_bdebug(bh, "already in cache (%d cache entries)",
  779. atomic_read(&ext2_xattr_cache->c_entry_count));
  780. error = 0;
  781. }
  782. } else {
  783. ea_bdebug(bh, "inserting [%x] (%d cache entries)", (int)hash,
  784. atomic_read(&ext2_xattr_cache->c_entry_count));
  785. mb_cache_entry_release(ce);
  786. }
  787. return error;
  788. }
  789. /*
  790. * ext2_xattr_cmp()
  791. *
  792. * Compare two extended attribute blocks for equality.
  793. *
  794. * Returns 0 if the blocks are equal, 1 if they differ, and
  795. * a negative error number on errors.
  796. */
  797. static int
  798. ext2_xattr_cmp(struct ext2_xattr_header *header1,
  799. struct ext2_xattr_header *header2)
  800. {
  801. struct ext2_xattr_entry *entry1, *entry2;
  802. entry1 = ENTRY(header1+1);
  803. entry2 = ENTRY(header2+1);
  804. while (!IS_LAST_ENTRY(entry1)) {
  805. if (IS_LAST_ENTRY(entry2))
  806. return 1;
  807. if (entry1->e_hash != entry2->e_hash ||
  808. entry1->e_name_index != entry2->e_name_index ||
  809. entry1->e_name_len != entry2->e_name_len ||
  810. entry1->e_value_size != entry2->e_value_size ||
  811. memcmp(entry1->e_name, entry2->e_name, entry1->e_name_len))
  812. return 1;
  813. if (entry1->e_value_block != 0 || entry2->e_value_block != 0)
  814. return -EIO;
  815. if (memcmp((char *)header1 + le16_to_cpu(entry1->e_value_offs),
  816. (char *)header2 + le16_to_cpu(entry2->e_value_offs),
  817. le32_to_cpu(entry1->e_value_size)))
  818. return 1;
  819. entry1 = EXT2_XATTR_NEXT(entry1);
  820. entry2 = EXT2_XATTR_NEXT(entry2);
  821. }
  822. if (!IS_LAST_ENTRY(entry2))
  823. return 1;
  824. return 0;
  825. }
  826. /*
  827. * ext2_xattr_cache_find()
  828. *
  829. * Find an identical extended attribute block.
  830. *
  831. * Returns a locked buffer head to the block found, or NULL if such
  832. * a block was not found or an error occurred.
  833. */
  834. static struct buffer_head *
  835. ext2_xattr_cache_find(struct inode *inode, struct ext2_xattr_header *header)
  836. {
  837. __u32 hash = le32_to_cpu(header->h_hash);
  838. struct mb_cache_entry *ce;
  839. if (!header->h_hash)
  840. return NULL; /* never share */
  841. ea_idebug(inode, "looking for cached blocks [%x]", (int)hash);
  842. again:
  843. ce = mb_cache_entry_find_first(ext2_xattr_cache, 0,
  844. inode->i_sb->s_bdev, hash);
  845. while (ce) {
  846. struct buffer_head *bh;
  847. if (IS_ERR(ce)) {
  848. if (PTR_ERR(ce) == -EAGAIN)
  849. goto again;
  850. break;
  851. }
  852. bh = sb_bread(inode->i_sb, ce->e_block);
  853. if (!bh) {
  854. ext2_error(inode->i_sb, "ext2_xattr_cache_find",
  855. "inode %ld: block %ld read error",
  856. inode->i_ino, (unsigned long) ce->e_block);
  857. } else {
  858. lock_buffer(bh);
  859. if (le32_to_cpu(HDR(bh)->h_refcount) >
  860. EXT2_XATTR_REFCOUNT_MAX) {
  861. ea_idebug(inode, "block %ld refcount %d>%d",
  862. (unsigned long) ce->e_block,
  863. le32_to_cpu(HDR(bh)->h_refcount),
  864. EXT2_XATTR_REFCOUNT_MAX);
  865. } else if (!ext2_xattr_cmp(header, HDR(bh))) {
  866. ea_bdebug(bh, "b_count=%d",
  867. atomic_read(&(bh->b_count)));
  868. mb_cache_entry_release(ce);
  869. return bh;
  870. }
  871. unlock_buffer(bh);
  872. brelse(bh);
  873. }
  874. ce = mb_cache_entry_find_next(ce, 0, inode->i_sb->s_bdev, hash);
  875. }
  876. return NULL;
  877. }
  878. #define NAME_HASH_SHIFT 5
  879. #define VALUE_HASH_SHIFT 16
  880. /*
  881. * ext2_xattr_hash_entry()
  882. *
  883. * Compute the hash of an extended attribute.
  884. */
  885. static inline void ext2_xattr_hash_entry(struct ext2_xattr_header *header,
  886. struct ext2_xattr_entry *entry)
  887. {
  888. __u32 hash = 0;
  889. char *name = entry->e_name;
  890. int n;
  891. for (n=0; n < entry->e_name_len; n++) {
  892. hash = (hash << NAME_HASH_SHIFT) ^
  893. (hash >> (8*sizeof(hash) - NAME_HASH_SHIFT)) ^
  894. *name++;
  895. }
  896. if (entry->e_value_block == 0 && entry->e_value_size != 0) {
  897. __le32 *value = (__le32 *)((char *)header +
  898. le16_to_cpu(entry->e_value_offs));
  899. for (n = (le32_to_cpu(entry->e_value_size) +
  900. EXT2_XATTR_ROUND) >> EXT2_XATTR_PAD_BITS; n; n--) {
  901. hash = (hash << VALUE_HASH_SHIFT) ^
  902. (hash >> (8*sizeof(hash) - VALUE_HASH_SHIFT)) ^
  903. le32_to_cpu(*value++);
  904. }
  905. }
  906. entry->e_hash = cpu_to_le32(hash);
  907. }
  908. #undef NAME_HASH_SHIFT
  909. #undef VALUE_HASH_SHIFT
  910. #define BLOCK_HASH_SHIFT 16
  911. /*
  912. * ext2_xattr_rehash()
  913. *
  914. * Re-compute the extended attribute hash value after an entry has changed.
  915. */
  916. static void ext2_xattr_rehash(struct ext2_xattr_header *header,
  917. struct ext2_xattr_entry *entry)
  918. {
  919. struct ext2_xattr_entry *here;
  920. __u32 hash = 0;
  921. ext2_xattr_hash_entry(header, entry);
  922. here = ENTRY(header+1);
  923. while (!IS_LAST_ENTRY(here)) {
  924. if (!here->e_hash) {
  925. /* Block is not shared if an entry's hash value == 0 */
  926. hash = 0;
  927. break;
  928. }
  929. hash = (hash << BLOCK_HASH_SHIFT) ^
  930. (hash >> (8*sizeof(hash) - BLOCK_HASH_SHIFT)) ^
  931. le32_to_cpu(here->e_hash);
  932. here = EXT2_XATTR_NEXT(here);
  933. }
  934. header->h_hash = cpu_to_le32(hash);
  935. }
  936. #undef BLOCK_HASH_SHIFT
  937. int __init
  938. init_ext2_xattr(void)
  939. {
  940. ext2_xattr_cache = mb_cache_create("ext2_xattr", NULL,
  941. sizeof(struct mb_cache_entry) +
  942. sizeof(((struct mb_cache_entry *) 0)->e_indexes[0]), 1, 6);
  943. if (!ext2_xattr_cache)
  944. return -ENOMEM;
  945. return 0;
  946. }
  947. void
  948. exit_ext2_xattr(void)
  949. {
  950. mb_cache_destroy(ext2_xattr_cache);
  951. }